Bindings: Manage multiple DOMWrapperWorlds for worklets

third_party/WebKit/Source/bindings/core/v8/DOMWrapperWorld.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 #include <memory>
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "bindings/core/v8/V8DOMWrapper.h"
 #include "bindings/core/v8/V8Window.h"
 #include "bindings/core/v8/WindowProxy.h"
 #include "bindings/core/v8/WrapperTypeInfo.h"
 #include "core/dom/ExecutionContext.h"
+#include "wtf/Atomics.h"
 #include "wtf/HashTraits.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 
 namespace blink {
 
 class DOMObjectHolderBase {
   USING_FAST_MALLOC(DOMObjectHolderBase);
 
  public:
@@ skipping 23 matching lines @@
 
  private:
   DOMObjectHolder(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
       : DOMObjectHolderBase(isolate, wrapper), m_object(object) {}
 
   Persistent<T> m_object;
 };
 
 unsigned DOMWrapperWorld::s_numberOfNonMainWorldsInMainThread = 0;
 
+using WorldMap = HashMap<int, DOMWrapperWorld*>;
+
+static WorldMap& isolatedWorldMap() {
+  DCHECK(isMainThread());
+  DEFINE_STATIC_LOCAL(WorldMap, map, ());
+  return map;
+}
+
+static WorldMap& worldMap() {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<WorldMap>, map,
+                                  new ThreadSpecific<WorldMap>);
+  return *map;
+}
+
 PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::create(v8::Isolate* isolate,
                                                     WorldType worldType) {
   DCHECK_NE(WorldType::Isolated, worldType);
-  return adoptRef(
-      new DOMWrapperWorld(isolate, worldType, getWorldIdForType(worldType)));
+  return adoptRef(new DOMWrapperWorld(isolate, worldType,
+                                      generateWorldIdForType(worldType)));
 }
 
 DOMWrapperWorld::DOMWrapperWorld(v8::Isolate* isolate,
                                  WorldType worldType,
                                  int worldId)
     : m_worldType(worldType),
       m_worldId(worldId),
       m_domDataStore(
           WTF::wrapUnique(new DOMDataStore(isolate, isMainWorld()))) {
-  if (isWorkerWorld())
-    workerWorld() = this;
+  switch (worldType) {
+    case WorldType::Main:
+      // MainWorld is managed separately from worldMap() and isolatedWorldMap().
+      // See mainWorld().
+      break;
+    case WorldType::Isolated: {
+      DCHECK(isMainThread());
+      WorldMap& map = isolatedWorldMap();
+      DCHECK(!map.contains(worldId));
+      map.insert(worldId, this);
+      break;
+    }
+    case WorldType::GarbageCollector:
+    case WorldType::RegExp:
+    case WorldType::Testing:
+    case WorldType::Worker: {
+      WorldMap& map = worldMap();
+      DCHECK(!map.contains(worldId));
+      map.insert(worldId, this);
+      break;
+    }
+  }
   if (worldId != WorldId::MainWorldId && isMainThread())
     s_numberOfNonMainWorldsInMainThread++;
 }
 
 DOMWrapperWorld& DOMWrapperWorld::mainWorld() {
   ASSERT(isMainThread());
   DEFINE_STATIC_REF(
       DOMWrapperWorld, cachedMainWorld,
       (DOMWrapperWorld::create(v8::Isolate::GetCurrent(), WorldType::Main)));
   return *cachedMainWorld;
 }
 
-DOMWrapperWorld*& DOMWrapperWorld::workerWorld() {
-  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<DOMWrapperWorld*>, workerWorld,
-                                  new ThreadSpecific<DOMWrapperWorld*>);
-  return *workerWorld;
-}
-
 PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::fromWorldId(v8::Isolate* isolate,
                                                          int worldId) {
   if (worldId == MainWorldId)
     return &mainWorld();
   return ensureIsolatedWorld(isolate, worldId);
 }
 
-typedef HashMap<int, DOMWrapperWorld*> WorldMap;
-static WorldMap& isolatedWorldMap() {
-  ASSERT(isMainThread());
-  DEFINE_STATIC_LOCAL(WorldMap, map, ());
-  return map;
-}
-
 void DOMWrapperWorld::allWorldsInMainThread(
     Vector<RefPtr<DOMWrapperWorld>>& worlds) {
   ASSERT(isMainThread());
   worlds.push_back(&mainWorld());
-  WorldMap& isolatedWorlds = isolatedWorldMap();
-  for (WorldMap::iterator it = isolatedWorlds.begin();
-       it != isolatedWorlds.end(); ++it)
-    worlds.push_back(it->value);
+  for (DOMWrapperWorld* world : worldMap().values())
+    worlds.push_back(world);
+  for (DOMWrapperWorld* world : isolatedWorldMap().values())
+    worlds.push_back(world);
 }
 
 void DOMWrapperWorld::markWrappersInAllWorlds(
     ScriptWrappable* scriptWrappable,
     const ScriptWrappableVisitor* visitor) {
-  // Handle marking in per-worker wrapper worlds.
-  if (!isMainThread()) {
-    DCHECK(ThreadState::current()->isolate());
-    DOMWrapperWorld* worker = workerWorld();
-    if (worker) {
-      DOMDataStore& dataStore = worker->domDataStore();
-      if (dataStore.containsWrapper(scriptWrappable)) {
-        dataStore.markWrapper(scriptWrappable);
-      }
-    }
-    return;
+  // Marking for worlds other than the main world and the isolated worlds.
+  DCHECK(ThreadState::current()->isolate());
+  for (DOMWrapperWorld* world : worldMap().values()) {
+    DOMDataStore& dataStore = world->domDataStore();
+    if (dataStore.containsWrapper(scriptWrappable))
+      dataStore.markWrapper(scriptWrappable);
   }
 
+  // The main world and isolated worlds should exist only on the main thread.
+  if (!isMainThread())
+    return;
+
+  // Marking for the main world.
   scriptWrappable->markWrapper(visitor);
+
+  // Marking for the isolated worlds.
   WorldMap& isolatedWorlds = isolatedWorldMap();
   for (auto& world : isolatedWorlds.values()) {
     DOMDataStore& dataStore = world->domDataStore();
-    if (dataStore.containsWrapper(scriptWrappable)) {
-      // Marking for the isolated worlds
+    if (dataStore.containsWrapper(scriptWrappable))
       dataStore.markWrapper(scriptWrappable);
-    }
   }
 }
 
 DOMWrapperWorld::~DOMWrapperWorld() {
   ASSERT(!isMainWorld());
 
   dispose();
 
   if (isMainThread())
     s_numberOfNonMainWorldsInMainThread--;
 
   if (!isIsolatedWorld())
     return;
 
   WorldMap& map = isolatedWorldMap();
   WorldMap::iterator it = map.find(m_worldId);
   if (it == map.end()) {
     ASSERT_NOT_REACHED();
     return;
   }
   ASSERT(it->value == this);
 
   map.remove(it);
 }
 
 void DOMWrapperWorld::dispose() {
   m_domObjectHolders.clear();
   m_domDataStore.reset();
-  if (isWorkerWorld())
-    workerWorld() = nullptr;
+  worldMap().remove(m_worldId);
 }
 
 #if DCHECK_IS_ON()
 static bool isIsolatedWorldId(int worldId) {
   return DOMWrapperWorld::MainWorldId < worldId &&
          worldId < DOMWrapperWorld::IsolatedWorldIdLimit;
 }
 #endif
 
 PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::ensureIsolatedWorld(
     v8::Isolate* isolate,
     int worldId) {
   ASSERT(isIsolatedWorldId(worldId));
 
   WorldMap& map = isolatedWorldMap();
-  WorldMap::AddResult result = map.insert(worldId, nullptr);
-  RefPtr<DOMWrapperWorld> world = result.storedValue->value;
-  if (world) {
-    ASSERT(world->worldId() == worldId);
+  auto it = map.find(worldId);
+  if (it != map.end()) {
+    RefPtr<DOMWrapperWorld> world = it->value;
+    DCHECK_EQ(worldId, world->worldId());
     return world.release();
   }
 
-  world = adoptRef(new DOMWrapperWorld(isolate, WorldType::Isolated, worldId));
-  result.storedValue->value = world.get();
-  return world.release();
+  return adoptRef(new DOMWrapperWorld(isolate, WorldType::Isolated, worldId));
 }
 
 typedef HashMap<int, RefPtr<SecurityOrigin>> IsolatedWorldSecurityOriginMap;
 static IsolatedWorldSecurityOriginMap& isolatedWorldSecurityOrigins() {
   ASSERT(isMainThread());
   DEFINE_STATIC_LOCAL(IsolatedWorldSecurityOriginMap, map, ());
   return map;
 }
 
 SecurityOrigin* DOMWrapperWorld::isolatedWorldSecurityOrigin() {
@@ skipping 83 matching lines @@
   ASSERT(m_domObjectHolders.contains(holderBase));
   m_domObjectHolders.erase(holderBase);
 }
 
 void DOMWrapperWorld::weakCallbackForDOMObjectHolder(
     const v8::WeakCallbackInfo<DOMObjectHolderBase>& data) {
   DOMObjectHolderBase* holderBase = data.GetParameter();
   holderBase->world()->unregisterDOMObjectHolder(holderBase);
 }
 
-int DOMWrapperWorld::getWorldIdForType(WorldType worldType) {
+int DOMWrapperWorld::generateWorldIdForType(WorldType worldType) {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(
+      int, s_lastGeneratedWorldId,
+      new int(DOMWrapperWorld::WorldId::IsolatedWorldIdLimit));

[haraken, 2017/03/14 09:18:20]

I think you could just use ThreadSpecific. The world ID needs to be unique per
thread, not per process.

[nhiroki, 2017/03/14 09:39:05]

Done.

   switch (worldType) {
     case WorldType::Main:
       return MainWorldId;
     case WorldType::Isolated:
       // This function should not be called for IsolatedWorld because an
       // identifier for the world is given from out of DOMWrapperWorld.
       NOTREACHED();
       return InvalidWorldId;
     case WorldType::GarbageCollector:
-      return GarbageCollectorWorldId;
     case WorldType::RegExp:
-      return RegExpWorldId;
     case WorldType::Testing:
-      return TestingWorldId;
-    // Currently, WorldId for a worker/worklet is a fixed value, but this
-    // doesn't work when multiple worklets are created on a thread.
-    // TODO(nhiroki): Expand the identifier space for workers/worklets.
-    // (https://crbug.com/697622)
     case WorldType::Worker:
-      return WorkerWorldId;
+      int worldId = WTF::atomicIncrement(&s_lastGeneratedWorldId);
+      CHECK_GT(worldId, 0);
+      return worldId;
   }
   NOTREACHED();
   return InvalidWorldId;
 }
 
 }  // namespace blink