Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / v8 / src / libplatform / default-platform.cc

diff --git a/src/v8/src/libplatform/default-platform.cc b/src/v8/src/libplatform/default-platform.cc
index 733bcf0..9a503bc 100644 (file)
--- a/src/v8/src/libplatform/default-platform.cc
+++ b/src/v8/src/libplatform/default-platform.cc
@@ -7,13 +7,25 @@
 #include <algorithm>
 #include <queue>
 
-// TODO(jochen): We should have our own version of checks.h.
-#include "src/checks.h"
-#include "src/platform.h"
+#include "src/base/logging.h"
+#include "src/base/platform/platform.h"
 #include "src/libplatform/worker-thread.h"
 
 namespace v8 {
-namespace internal {
+namespace platform {
+
+
+v8::Platform* CreateDefaultPlatform(int thread_pool_size) {
+  DefaultPlatform* platform = new DefaultPlatform();
+  platform->SetThreadPoolSize(thread_pool_size);
+  platform->EnsureInitialized();
+  return platform;
+}
+
+
+bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate) {
+  return reinterpret_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate);
+}
 
 
 const int DefaultPlatform::kMaxThreadPoolSize = 4;
@@ -24,7 +36,7 @@ DefaultPlatform::DefaultPlatform()
 
 
 DefaultPlatform::~DefaultPlatform() {
-  LockGuard<Mutex> guard(&lock_);
+  base::LockGuard<base::Mutex> guard(&lock_);
   queue_.Terminate();
   if (initialized_) {
     for (std::vector<WorkerThread*>::iterator i = thread_pool_.begin();
@@ -32,21 +44,29 @@ DefaultPlatform::~DefaultPlatform() {
       delete *i;
     }
   }
+  for (std::map<v8::Isolate*, std::queue<Task*> >::iterator i =
+           main_thread_queue_.begin();
+       i != main_thread_queue_.end(); ++i) {
+    while (!i->second.empty()) {
+      delete i->second.front();
+      i->second.pop();
+    }
+  }
 }
 
 
 void DefaultPlatform::SetThreadPoolSize(int thread_pool_size) {
-  LockGuard<Mutex> guard(&lock_);
-  ASSERT(thread_pool_size >= 0);
+  base::LockGuard<base::Mutex> guard(&lock_);
+  DCHECK(thread_pool_size >= 0);
   if (thread_pool_size < 1)
-    thread_pool_size = OS::NumberOfProcessorsOnline();
+    thread_pool_size = base::OS::NumberOfProcessorsOnline();
   thread_pool_size_ =
       std::max(std::min(thread_pool_size, kMaxThreadPoolSize), 1);
 }
 
 
 void DefaultPlatform::EnsureInitialized() {
-  LockGuard<Mutex> guard(&lock_);
+  base::LockGuard<base::Mutex> guard(&lock_);
   if (initialized_) return;
   initialized_ = true;
 
@@ -54,6 +74,24 @@ void DefaultPlatform::EnsureInitialized() {
     thread_pool_.push_back(new WorkerThread(&queue_));
 }
 
+
+bool DefaultPlatform::PumpMessageLoop(v8::Isolate* isolate) {
+  Task* task = NULL;
+  {
+    base::LockGuard<base::Mutex> guard(&lock_);
+    std::map<v8::Isolate*, std::queue<Task*> >::iterator it =
+        main_thread_queue_.find(isolate);
+    if (it == main_thread_queue_.end() || it->second.empty()) {
+      return false;
+    }
+    task = it->second.front();
+    it->second.pop();
+  }
+  task->Run();
+  delete task;
+  return true;
+}
+
 void DefaultPlatform::CallOnBackgroundThread(Task *task,
                                              ExpectedRuntime expected_runtime) {
   EnsureInitialized();
@@ -62,9 +100,8 @@ void DefaultPlatform::CallOnBackgroundThread(Task *task,
 
 
 void DefaultPlatform::CallOnForegroundThread(v8::Isolate* isolate, Task* task) {
-  // TODO(jochen): implement.
-  task->Run();
-  delete task;
+  base::LockGuard<base::Mutex> guard(&lock_);
+  main_thread_queue_[isolate].push(task);
 }
 
-} }  // namespace v8::internal
+} }  // namespace v8::platform