Refresh LocalDOMWindow post-Oilpan.

third_party/WebKit/Source/core/frame/LocalDOMWindow.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 61 matching lines @@
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/Suborigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFrameScheduler.h"
 #include "public/platform/WebScreenInfo.h"
 
 namespace blink {
 
-LocalDOMWindow::WindowFrameObserver::WindowFrameObserver(LocalDOMWindow* window, LocalFrame& frame)
-    : LocalFrameLifecycleObserver(&frame)
-    , m_window(window)
-{
-}
+// Rather than simply inheriting LocalFrameLifecycleObserver like most other
+// classes, LocalDOMWindow hides its LocalFrameLifecycleObserver with
+// composition. This prevents conflicting overloads between DOMWindow, which
+// has a frame() accessor that returns Frame* for bindings code, and
+// LocalFrameLifecycleObserver, which has a frame() accessor that returns a
+// LocalFrame*.
+class LocalDOMWindow::WindowFrameObserver final : public GarbageCollected<LocalDOMWindow::WindowFrameObserver>, public LocalFrameLifecycleObserver {
+    USING_GARBAGE_COLLECTED_MIXIN(WindowFrameObserver);
+public:
+    static WindowFrameObserver* create(LocalDOMWindow* window, LocalFrame& frame)
+    {
+        return new WindowFrameObserver(window, frame);
+    }
 
-LocalDOMWindow::WindowFrameObserver* LocalDOMWindow::WindowFrameObserver::create(LocalDOMWindow* window, LocalFrame& frame)
-{
-    return new WindowFrameObserver(window, frame);
-}
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        visitor->trace(m_window);
+        LocalFrameLifecycleObserver::trace(visitor);
+    }
 
-DEFINE_TRACE(LocalDOMWindow::WindowFrameObserver)
-{
-    visitor->trace(m_window);
-    LocalFrameLifecycleObserver::trace(visitor);
-}
+    // LocalFrameLifecycleObserver overrides:
+    void willDetachFrameHost() override
+    {
+        m_window->willDetachFrameHost();
+    }
 
-void LocalDOMWindow::WindowFrameObserver::willDetachFrameHost()
-{
-    m_window->willDetachFrameHost();
-}
+    void contextDestroyed() override
+    {
+        m_window->frameDestroyed();
+        LocalFrameLifecycleObserver::contextDestroyed();
+    }
 
-void LocalDOMWindow::WindowFrameObserver::contextDestroyed()
-{
-    m_window->frameDestroyed();
-    LocalFrameLifecycleObserver::contextDestroyed();
-}
+private:
+    WindowFrameObserver(LocalDOMWindow* window, LocalFrame& frame)
+        : LocalFrameLifecycleObserver(&frame)
+        , m_window(window)
+    {
+    }
+
+    Member<LocalDOMWindow> m_window;
+};
 
 class PostMessageTimer final : public GarbageCollectedFinalized<PostMessageTimer>, public SuspendableTimer {
     USING_GARBAGE_COLLECTED_MIXIN(PostMessageTimer);
 public:
     PostMessageTimer(LocalDOMWindow& window, MessageEvent* event, SecurityOrigin* targetOrigin, PassRefPtr<ScriptCallStack> stackTrace, UserGestureToken* userGestureToken)
         : SuspendableTimer(window.document())
         , m_event(event)
         , m_window(&window)
         , m_targetOrigin(targetOrigin)
         , m_stackTrace(stackTrace)
         , m_userGestureToken(userGestureToken)
         , m_disposalAllowed(true)
     {
         InspectorInstrumentation::asyncTaskScheduled(window.document(), "postMessage", this);
     }
 
-    MessageEvent* event() const { return m_event.get(); }
+    MessageEvent* event() const { return m_event; }
     SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
     ScriptCallStack* stackTrace() const { return m_stackTrace.get(); }
     UserGestureToken* userGestureToken() const { return m_userGestureToken.get(); }
     void stop() override
     {
         SuspendableTimer::stop();
 
         if (m_disposalAllowed)
             dispose();
     }
@@ skipping 143 matching lines @@
 }
 
 bool LocalDOMWindow::allowPopUp()
 {
     return frame() && allowPopUp(*frame());
 }
 
 LocalDOMWindow::LocalDOMWindow(LocalFrame& frame)
     : m_frameObserver(WindowFrameObserver::create(this, frame))
     , m_shouldPrintWhenFinishedLoading(false)
-#if ENABLE(ASSERT)
-    , m_hasBeenReset(false)
-#endif
 {
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 void LocalDOMWindow::clearDocument()
 {
     if (!m_document)
         return;
 
     ASSERT(!m_document->isActive());
@@ skipping 225 matching lines @@
     m_locationbar = nullptr;
     m_menubar = nullptr;
     m_personalbar = nullptr;
     m_scrollbars = nullptr;
     m_statusbar = nullptr;
     m_toolbar = nullptr;
     m_navigator = nullptr;
     m_media = nullptr;
     m_customElements = nullptr;
     m_applicationCache = nullptr;
-#if ENABLE(ASSERT)
-    m_hasBeenReset = true;
-#endif
 
     LocalDOMWindow::notifyContextDestroyed();
 }
 
 void LocalDOMWindow::sendOrientationChangeEvent()
 {
     ASSERT(RuntimeEnabledFeatures::orientationEventEnabled());
     ASSERT(frame()->isMainFrame());
 
     // Before dispatching the event, build a list of all frames in the page
@@ skipping 947 matching lines @@
 {
     // If the LocalDOMWindow still has a frame reference, that frame must point
     // back to this LocalDOMWindow: otherwise, it's easy to get into a situation
     // where script execution leaks between different LocalDOMWindows.
     if (m_frameObserver->frame())
         ASSERT_WITH_SECURITY_IMPLICATION(m_frameObserver->frame()->domWindow() == this);
     return m_frameObserver->frame();
 }
 
 } // namespace blink