[TimeZoneMonitor] Decouple renderer side impl from content to blink.

third_party/WebKit/Source/core/workers/WorkerBackingThread.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/workers/WorkerBackingThread.h"
 
+#include "base/task_runner.h"
+#include "base/threading/platform_thread.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8IdleTaskRunner.h"
 #include "bindings/core/v8/V8Initializer.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/PtrUtil.h"
+#include <map>

[haraken, 2016/10/11 11:45:06]

Don't use std::map in Blink. You can use HashMap.

[leonhsl(Using Gerrit), 2016/10/12 03:55:55]

Acknowledged.

 #include <memory>
 
 namespace blink {
 
 #define DEFINE_STATIC_LOCAL_WITH_LOCK(type, name, arguments) \
-  ASSERT(isolatesMutex().locked());                          \
+  DCHECK(mutex().locked());                                  \
   static type& name = *new type arguments
 
-static Mutex& isolatesMutex() {
+static Mutex& mutex() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mutex, new Mutex);
   return mutex;
 }
 
 static HashSet<v8::Isolate*>& isolates() {
   DEFINE_STATIC_LOCAL_WITH_LOCK(HashSet<v8::Isolate*>, isolates, ());
   return isolates;
 }
 
 static void addWorkerIsolate(v8::Isolate* isolate) {
-  MutexLocker lock(isolatesMutex());
+  MutexLocker lock(mutex());
   isolates().add(isolate);
 }
 
 static void removeWorkerIsolate(v8::Isolate* isolate) {
-  MutexLocker lock(isolatesMutex());
+  MutexLocker lock(mutex());
   isolates().remove(isolate);
 }
 
+using IDToTaskRunnerMap = std::map<base::PlatformThreadId, base::TaskRunner*>;
+static IDToTaskRunnerMap& threadRunners() {

[haraken, 2016/10/11 11:45:06]

Yeah, this looks nasty.

nhiroki@: What's an expected way to get a set of all workers in Blink?

[leonhsl(Using Gerrit), 2016/10/12 03:55:55]

Yeah the purpose is to post a task to all running worker threads in Blink.
Thanks for help about this and eager to comments from nhiroki@.

[nhiroki, 2016/10/12 06:20:20]

As blundell@'s comment (and an email thread[1]), WorkerThread::workerThreads()
is an expected way to communicate with all workers. The function is private, so
we need to make it public or create a static helper function like
WorkerThread::PostTaskToAllWorkerThreads().

[1] https://groups.google.com/a/chromium.org/forum/#!msg/blink-dev/G0qnCE5A67o/

leonhsl: As you commented, multiple blink::WorkerThread can correspond with 1
blink::WorkerBackingThread. If you'd like to avoid posting duplicate tasks to
the same WorkerBackingThread, you could filter out the set of WorkerThread
returned by workerThreads() in some way, for example, memoize Isolate and skip
if it's duplicate.

[leonhsl(Using Gerrit), 2016/10/12 13:54:44]

Thanks a lot! I suppose WorkerThread::isOwningBackingThread() could be used to
avoid possible duplication, is it OK?

+  DEFINE_STATIC_LOCAL_WITH_LOCK(IDToTaskRunnerMap, threadRunners, ());
+  return threadRunners;
+}
+
+static void addCurrentThreadRunner() {
+  DCHECK(!base::PlatformThread::CurrentRef().is_null());
+  MutexLocker lock(mutex());
+
+  int id = base::PlatformThread::CurrentId();
+  threadRunners()[id] = base::ThreadTaskRunnerHandle::Get().get();
+}
+
+static void removeCurrentThreadRunner() {
+  MutexLocker lock(mutex());
+
+  int id = base::PlatformThread::CurrentId();
+  threadRunners().erase(id);
+}
+
 WorkerBackingThread::WorkerBackingThread(const char* name,
                                          bool shouldCallGCOnShutdown,
                                          BlinkGC::ThreadHeapMode threadHeapMode)
     : m_backingThread(WebThreadSupportingGC::create(name, threadHeapMode)),
       m_isOwningThread(true),
       m_shouldCallGCOnShutdown(shouldCallGCOnShutdown) {}
 
 WorkerBackingThread::WorkerBackingThread(WebThread* thread,
                                          bool shouldCallGCOnShutdown)
     : m_backingThread(
@@ skipping 13 matching lines @@
 
   std::unique_ptr<V8IsolateInterruptor> interruptor =
       wrapUnique(new V8IsolateInterruptor(m_isolate));
   ThreadState::current()->addInterruptor(std::move(interruptor));
   ThreadState::current()->registerTraceDOMWrappers(
       m_isolate, V8GCController::traceDOMWrappers, nullptr, nullptr);
   if (RuntimeEnabledFeatures::v8IdleTasksEnabled())
     V8PerIsolateData::enableIdleTasks(
         m_isolate, wrapUnique(new V8IdleTaskRunner(
                        backingThread().platformThread().scheduler())));
-  if (m_isOwningThread)
+  if (m_isOwningThread) {
+    addCurrentThreadRunner();
     Platform::current()->didStartWorkerThread();
+  }
 }
 
 void WorkerBackingThread::shutdown() {
-  if (m_isOwningThread)
+  if (m_isOwningThread) {
     Platform::current()->willStopWorkerThread();
+    removeCurrentThreadRunner();
+  }
 
   V8PerIsolateData::willBeDestroyed(m_isolate);
   // TODO(yhirano): Remove this when https://crbug.com/v8/1428 is fixed.
   if (m_shouldCallGCOnShutdown) {
     // This statement runs only in tests.
     V8GCController::collectAllGarbageForTesting(m_isolate);
   }
   m_backingThread->shutdown();
 
   removeWorkerIsolate(m_isolate);
   V8PerIsolateData::destroy(m_isolate);
   m_isolate = nullptr;
 }
 
 // static
 void WorkerBackingThread::MemoryPressureNotificationToWorkerThreadIsolates(
     v8::MemoryPressureLevel level) {
-  MutexLocker lock(isolatesMutex());
+  MutexLocker lock(mutex());
   for (v8::Isolate* isolate : isolates())
     isolate->MemoryPressureNotification(level);
 }
 
 // static
 void WorkerBackingThread::setRAILModeOnWorkerThreadIsolates(
     v8::RAILMode railMode) {
-  MutexLocker lock(isolatesMutex());
+  MutexLocker lock(mutex());
   for (v8::Isolate* isolate : isolates())
     isolate->SetRAILMode(railMode);
 }
 
+// static
+void WorkerBackingThread::PostTaskToAllThreads(const base::Closure& closure) {
+  MutexLocker lock(mutex());
+
+  for (const auto& it : threadRunners())
+    it.second->PostTask(FROM_HERE, closure);
+}
+
 }  // namespace blink