bindings: Simplifies WindowProxyManager and its relation to Frame.

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

 // Copyright 2015 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 "bindings/core/v8/WindowProxyManager.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 
 namespace blink {
 
 namespace {
 
 WindowProxy* createWindowProxyForFrame(v8::Isolate* isolate,
                                        Frame& frame,
-
                                        RefPtr<DOMWrapperWorld> world) {
   if (frame.isLocalFrame()) {
     return LocalWindowProxy::create(isolate, toLocalFrame(frame),
                                     std::move(world));
   }
   return RemoteWindowProxy::create(isolate, toRemoteFrame(frame),
                                    std::move(world));
 }
-}
 
-DEFINE_TRACE(WindowProxyManagerBase) {
+}  // namespace
+
+DEFINE_TRACE(WindowProxyManager) {
   visitor->trace(m_frame);
   visitor->trace(m_windowProxy);
   visitor->trace(m_isolatedWorlds);
 }
 
-WindowProxy* WindowProxyManagerBase::windowProxy(DOMWrapperWorld& world) {
+void WindowProxyManager::clearForClose() {
+  m_windowProxy->clearForClose();
+  for (auto& entry : m_isolatedWorlds)
+    entry.value->clearForClose();
+}
+
+void WindowProxyManager::clearForNavigation() {
+  m_windowProxy->clearForNavigation();
+  for (auto& entry : m_isolatedWorlds)
+    entry.value->clearForNavigation();
+}
+
+void WindowProxyManager::releaseGlobals(
+    HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>& map) {
+  map.insert(&m_windowProxy->world(), m_windowProxy->releaseGlobal());
+  for (auto& entry : m_isolatedWorlds) {
+    map.insert(
+        &entry.value->world(),
+        windowProxyMaybeUninitialized(entry.value->world())->releaseGlobal());
+  }
+}
+
+void WindowProxyManager::setGlobals(
+    const HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>& map) {
+  for (auto& entry : map)
+    windowProxyMaybeUninitialized(*entry.key)->setGlobal(entry.value);
+}
+
+WindowProxyManager::WindowProxyManager(Frame& frame)
+    : m_isolate(v8::Isolate::GetCurrent()),

[haraken, 2017/03/10 12:44:12]

toIsolate(frame).

Avoid using v8::Isolate::GetCurrent().

[Yuki, 2017/03/10 15:21:50]

blink::toIsolate(frame) is returning the frame's WindowProxyManager's isolate,
i.e. this value itself.  So we cannot use it.

[haraken, 2017/03/11 19:35:24]

Can we explicitly pass in the Isolate* parameter?

[Yuki, 2017/03/13 08:24:30]

Currently, the call sites don't have an Isolate.  So it's not easy.  Anyway, I
didn't change this point in this CL (the old implementation has been using
v8::Isolate::GetCurrent()), so I suppose that it should be addressed separately.

+      m_frame(&frame),
+      m_windowProxy(createWindowProxyForFrame(m_isolate,
+                                              *m_frame,
+                                              &DOMWrapperWorld::mainWorld())) {}
+
+WindowProxy* WindowProxyManager::windowProxyMaybeUninitialized(
+    DOMWrapperWorld& world) {
   WindowProxy* windowProxy = nullptr;
   if (world.isMainWorld()) {
     windowProxy = m_windowProxy.get();
   } else {
     IsolatedWorldMap::iterator iter = m_isolatedWorlds.find(world.worldId());
     if (iter != m_isolatedWorlds.end()) {
       windowProxy = iter->value.get();
     } else {
       windowProxy = createWindowProxyForFrame(m_isolate, *m_frame, &world);
       m_isolatedWorlds.set(world.worldId(), windowProxy);
     }
   }
   return windowProxy;
 }
 
-void WindowProxyManagerBase::clearForClose() {
-  m_windowProxy->clearForClose();
-  for (auto& entry : m_isolatedWorlds)
-    entry.value->clearForClose();
-}
-
-void WindowProxyManagerBase::clearForNavigation() {
-  m_windowProxy->clearForNavigation();
-  for (auto& entry : m_isolatedWorlds)
-    entry.value->clearForNavigation();
-}
-
-void WindowProxyManagerBase::releaseGlobals(
-    HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>& map) {
-  map.insert(&m_windowProxy->world(), m_windowProxy->releaseGlobal());
-  for (auto& entry : m_isolatedWorlds)
-    map.insert(&entry.value->world(),
-               windowProxy(entry.value->world())->releaseGlobal());
-}
-
-void WindowProxyManagerBase::setGlobals(
-    const HashMap<DOMWrapperWorld*, v8::Local<v8::Object>>& map) {
-  for (auto& entry : map)
-    windowProxy(*entry.key)->setGlobal(entry.value);
-}
-
-WindowProxyManagerBase::WindowProxyManagerBase(Frame& frame)
-    : m_isolate(v8::Isolate::GetCurrent()),
-      m_frame(&frame),
-      m_windowProxy(createWindowProxyForFrame(m_isolate,
-                                              frame,
-                                              &DOMWrapperWorld::mainWorld())) {}
-
 void LocalWindowProxyManager::updateSecurityOrigin(
     SecurityOrigin* securityOrigin) {
-  static_cast<LocalWindowProxy*>(mainWorldProxy())
+  static_cast<LocalWindowProxy*>(m_windowProxy.get())
       ->updateSecurityOrigin(securityOrigin);
-  for (auto& entry : isolatedWorlds()) {
+
+  for (auto& entry : m_isolatedWorlds) {
     auto* isolatedWindowProxy =
         static_cast<LocalWindowProxy*>(entry.value.get());
     SecurityOrigin* isolatedSecurityOrigin =
         isolatedWindowProxy->world().isolatedWorldSecurityOrigin();
     isolatedWindowProxy->updateSecurityOrigin(isolatedSecurityOrigin);
   }
 }
 
 }  // namespace blink