#include "node_platform.h"

#include "node_internals.h"

#include "util.h"

namespace node {

using v8::HandleScope;

using v8::Isolate;

using v8::Local;

using v8::Object;

using v8::Platform;

using v8::Task;

using v8::TracingController;

static void FlushTasks(uv_async_t* handle) {

NodePlatform* platform = static_cast<NodePlatform*>(handle->data);

platform->FlushForegroundTasksInternal();

}

static void BackgroundRunner(void* data) {

}

NodePlatform::NodePlatform(int thread_pool_size, uv_loop_t* loop,

}

void NodePlatform::Shutdown() {

}

size_t NodePlatform::NumberOfAvailableBackgroundThreads() {

return threads_.size();

}

static void RunForegroundTask(Task* task) {

}

static void RunForegroundTask(uv_timer_t* handle) {

}

void NodePlatform::DrainBackgroundTasks() {

while (FlushForegroundTasksInternal())

background_tasks_.BlockingDrain();

}

bool NodePlatform::FlushForegroundTasksInternal() {

}

void NodePlatform::CallOnBackgroundThread(Task* task,

ExpectedRuntime expected_runtime) {

background_tasks_.Push(task);

}

void NodePlatform::CallOnForegroundThread(Isolate* isolate, Task* task) {

foreground_tasks_.Push(task);

uv_async_send(&flush_tasks_);

}

void NodePlatform::CallDelayedOnForegroundThread(Isolate* isolate,

}

bool NodePlatform::IdleTasksEnabled(Isolate* isolate) { return false; }

double NodePlatform::MonotonicallyIncreasingTime() {

// Convert nanos to seconds.

return uv_hrtime() / 1e9;

}

TracingController* NodePlatform::GetTracingController() {

return tracing_controller_.get();

}

template <class T>

TaskQueue<T>::TaskQueue()

: lock_(), tasks_available_(), tasks_drained_(),

outstanding_tasks_(0), stopped_(false), task_queue_() { }

template <class T>

void TaskQueue<T>::Push(T* task) {

Mutex::ScopedLock scoped_lock(lock_);

outstanding_tasks_++;

task_queue_.push(task);

tasks_available_.Signal(scoped_lock);

}

template <class T>

T* TaskQueue<T>::Pop() {

Mutex::ScopedLock scoped_lock(lock_);

T* result = nullptr;

if (!task_queue_.empty()) {

result = task_queue_.front();

task_queue_.pop();

}

return result;

}

template <class T>

T* TaskQueue<T>::BlockingPop() {

Mutex::ScopedLock scoped_lock(lock_);

while (task_queue_.empty() && !stopped_) {

tasks_available_.Wait(scoped_lock);

}

if (stopped_) {

return nullptr;

}

T* result = task_queue_.front();

task_queue_.pop();

return result;

}

template <class T>

void TaskQueue<T>::NotifyOfCompletion() {

Mutex::ScopedLock scoped_lock(lock_);

if (--outstanding_tasks_ == 0) {

tasks_drained_.Broadcast(scoped_lock);

}

}

template <class T>

void TaskQueue<T>::BlockingDrain() {

Mutex::ScopedLock scoped_lock(lock_);

while (outstanding_tasks_ > 0) {

tasks_drained_.Wait(scoped_lock);

}

}

template <class T>

void TaskQueue<T>::Stop() {

Mutex::ScopedLock scoped_lock(lock_);

stopped_ = true;

tasks_available_.Broadcast(scoped_lock);

}

} // namespace node