Create base class for common functionality of Web{Local,Remote}Frame

third_party/WebKit/Source/web/WebFrame.cpp

 // Copyright 2014 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 "config.h"
 #include "public/web/WebFrame.h"
 
 #include "bindings/core/v8/WindowProxyManager.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/Page.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/heap/Handle.h"
 #include "public/web/WebElement.h"
 #include "public/web/WebFrameOwnerProperties.h"
 #include "public/web/WebSandboxFlags.h"
 #include "web/OpenedFrameTracker.h"
 #include "web/RemoteBridgeFrameOwner.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 #include <algorithm>
 
 namespace blink {
 
-Frame* toCoreFrame(const WebFrame* frame)
-{
-    if (!frame)
-        return 0;
-
-    return frame->isWebLocalFrame()
-        ? static_cast<Frame*>(toWebLocalFrameImpl(frame)->frame())
-        : toWebRemoteFrameImpl(frame)->frame();
-}
-
 bool WebFrame::swap(WebFrame* frame)
 {
     using std::swap;
-    RefPtrWillBeRawPtr<Frame> oldFrame = toCoreFrame(this);
+    RefPtrWillBeRawPtr<Frame> oldFrame = toImplBase()->frame();
 #if !ENABLE(OILPAN)
-    RefPtrWillBeRawPtr<WebLocalFrameImpl> protectWebLocalFrame = isWebLocalFrame() ? toWebLocalFrameImpl(this) : nullptr;
-    RefPtrWillBeRawPtr<WebRemoteFrameImpl> protectWebRemoteFrame = isWebRemoteFrame() ? toWebRemoteFrameImpl(this) : nullptr;
+    RefPtr<WebFrameImplBase> protectThis = toImplBase();
 #endif
 
     // Unload the current Document in this frame: this calls unload handlers,
     // detaches child frames, etc. Since this runs script, make sure this frame
     // wasn't detached before continuing with the swap.
     // FIXME: There is no unit test for this condition, so one needs to be
     // written.
     if (!oldFrame->prepareForCommit())
         return false;
 
@@ skipping 50 matching lines @@
                 HTMLFrameOwnerElement* ownerElement = toHTMLFrameOwnerElement(owner);
                 ownerElement->setContentFrame(localFrame);
                 ownerElement->setWidget(localFrame.view());
             } else {
                 toRemoteBridgeFrameOwner(owner)->setContentFrame(toWebLocalFrameImpl(frame));
             }
         } else {
             localFrame.page()->setMainFrame(&localFrame);
         }
     } else {
-        toWebRemoteFrameImpl(frame)->initializeCoreFrame(host, owner, name);
+        toWebRemoteFrameImpl(frame)->initializeCoreFrame(host, owner, name, nullAtom);
     }
 
-    toCoreFrame(frame)->windowProxyManager()->setGlobals(globals);
+    frame->toImplBase()->frame()->windowProxyManager()->setGlobals(globals);
 
     m_parent = nullptr;
 
     return true;
 }
 
 void WebFrame::detach()
 {
-    toCoreFrame(this)->detach(FrameDetachType::Remove);
+    toImplBase()->frame()->detach(FrameDetachType::Remove);
 }
 
 WebSecurityOrigin WebFrame::securityOrigin() const
 {
-    return WebSecurityOrigin(toCoreFrame(this)->securityContext()->securityOrigin());
+    return WebSecurityOrigin(toImplBase()->frame()->securityContext()->securityOrigin());
 }
 
 
 void WebFrame::setFrameOwnerSandboxFlags(WebSandboxFlags flags)
 {
     // At the moment, this is only used to replicate sandbox flags
     // for frames with a remote owner.
-    FrameOwner* owner = toCoreFrame(this)->owner();
+    FrameOwner* owner = toImplBase()->frame()->owner();
     ASSERT(owner);
     toRemoteBridgeFrameOwner(owner)->setSandboxFlags(static_cast<SandboxFlags>(flags));
 }
 
 WebFrame* WebFrame::opener() const
 {
     return m_opener;
 }
 
 void WebFrame::setOpener(WebFrame* opener)
@@ skipping 21 matching lines @@
         newChild->m_previousSibling = previousSibling;
     }
 
     if (next) {
         newChild->m_nextSibling = next;
         next->m_previousSibling = newChild;
     } else {
         m_lastChild = newChild;
     }
 
-    toCoreFrame(this)->tree().invalidateScopedChildCount();
-    toCoreFrame(this)->host()->incrementSubframeCount();
+    toImplBase()->frame()->tree().invalidateScopedChildCount();
+    toImplBase()->frame()->host()->incrementSubframeCount();
 }
 
 void WebFrame::appendChild(WebFrame* child)
 {
     // TODO(dcheng): Original code asserts that the frames have the same Page.
     // We should add an equivalent check... figure out what.
     insertAfter(child, m_lastChild);
 }
 
 void WebFrame::removeChild(WebFrame* child)
 {
     child->m_parent = 0;
 
     if (m_firstChild == child)
         m_firstChild = child->m_nextSibling;
     else
         child->m_previousSibling->m_nextSibling = child->m_nextSibling;
 
     if (m_lastChild == child)
         m_lastChild = child->m_previousSibling;
     else
         child->m_nextSibling->m_previousSibling = child->m_previousSibling;
 
     child->m_previousSibling = child->m_nextSibling = 0;
 
-    toCoreFrame(this)->tree().invalidateScopedChildCount();
-    toCoreFrame(this)->host()->decrementSubframeCount();
+    toImplBase()->frame()->tree().invalidateScopedChildCount();
+    toImplBase()->frame()->host()->decrementSubframeCount();
 }
 
 void WebFrame::setParent(WebFrame* parent)
 {
     m_parent = parent;
 }
 
 WebFrame* WebFrame::parent() const
 {
     return m_parent;
@@ skipping 22 matching lines @@
     return m_previousSibling;
 }
 
 WebFrame* WebFrame::nextSibling() const
 {
     return m_nextSibling;
 }
 
 WebFrame* WebFrame::traversePrevious(bool wrap) const
 {
-    if (Frame* frame = toCoreFrame(this))
+    if (Frame* frame = toImplBase()->frame())
         return fromFrame(frame->tree().traversePreviousWithWrap(wrap));
     return 0;
 }
 
 WebFrame* WebFrame::traverseNext(bool wrap) const
 {
-    if (Frame* frame = toCoreFrame(this))
+    if (Frame* frame = toImplBase()->frame())
         return fromFrame(frame->tree().traverseNextWithWrap(wrap));
     return 0;
 }
 
 WebFrame* WebFrame::findChildByName(const WebString& name) const
 {
-    Frame* frame = toCoreFrame(this);
+    Frame* frame = toImplBase()->frame();
     if (!frame)
         return 0;
     // FIXME: It's not clear this should ever be called to find a remote frame.
     // Perhaps just disallow that completely?
     return fromFrame(frame->tree().child(name));
 }
 
 WebFrame* WebFrame::fromFrameOwnerElement(const WebElement& webElement)
 {
     Element* element = PassRefPtrWillBeRawPtr<Element>(webElement).get();
 
     if (!isHTMLFrameElementBase(element))
         return nullptr;
     return fromFrame(toHTMLFrameElementBase(element)->contentFrame());
 }
 
 bool WebFrame::isLoading() const
 {
-    if (Frame* frame = toCoreFrame(this))
+    if (Frame* frame = toImplBase()->frame())
         return frame->isLoading();
     return false;
 }
 
 WebFrame* WebFrame::fromFrame(Frame* frame)
 {
     if (!frame)
         return 0;
 
     if (frame->isLocalFrame())
@@ skipping 12 matching lines @@
     , m_openedFrameTracker(new OpenedFrameTracker)
 {
 }
 
 WebFrame::~WebFrame()
 {
     m_openedFrameTracker.reset(0);
 }
 
 #if ENABLE(OILPAN)
 ALWAYS_INLINE bool WebFrame::isFrameAlive(const WebFrame* frame)

[dcheng, 2015/11/23 09:00:17]

It's possible to take advantage of the shared impl base to move all tracing
details there. However, I have a followup patch to change how the frame tree is
stored which will substantially change this anyway (to fix some edge cases
around swap and simplify how the swap code looks). So I'm going to address the
Oilpan tracing in a followup patch.

 {
     if (!frame)
         return true;
 
     if (frame->isWebLocalFrame())
         return Heap::isHeapObjectAlive(toWebLocalFrameImpl(frame));
 
     return Heap::isHeapObjectAlive(toWebRemoteFrameImpl(frame));
 }
 
@@ skipping 32 matching lines @@
     void WebFrame::traceFrames(VisitorDispatcher visitor, WebFrame* frame) { traceFramesImpl(visitor, frame); }                \
     void WebFrame::clearWeakFrames(VisitorDispatcher visitor) { clearWeakFramesImpl(visitor); }
 
 DEFINE_VISITOR_METHOD(Visitor*)
 DEFINE_VISITOR_METHOD(InlinedGlobalMarkingVisitor)
 
 #undef DEFINE_VISITOR_METHOD
 #endif
 
 } // namespace blink