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 65 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