Nuked WebFrameImplBase.

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 "public/web/WebFrame.h"
 
 #include "bindings/core/v8/WindowProxyManager.h"
 #include "core/HTMLNames.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 10 matching lines @@
 #include "web/OpenedFrameTracker.h"
 #include "web/RemoteFrameOwner.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 #include <algorithm>
 
 namespace blink {
 
 bool WebFrame::Swap(WebFrame* frame) {
   using std::swap;
-  Frame* old_frame = ToImplBase()->GetFrame();
+  Frame* old_frame = ToCoreFrame(*this);
   if (!old_frame->IsAttached())
     return false;
 
   // 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 (!old_frame->PrepareForCommit())
     return false;
@@ skipping 36 matching lines @@
 
   // Although the Document in this frame is now unloaded, many resources
   // associated with the frame itself have not yet been freed yet.
   old_frame->Detach(FrameDetachType::kSwap);
 
   // Clone the state of the current Frame into the one being swapped in.
   // FIXME: This is a bit clunky; this results in pointless decrements and
   // increments of connected subframes.
   if (frame->IsWebLocalFrame()) {
     // TODO(dcheng): in an ideal world, both branches would just use
-    // WebFrameImplBase's initializeCoreFrame() helper. However, Blink
+    // WebFrame's initializeCoreFrame() helper. However, Blink
     // currently requires a 'provisional' local frame to serve as a
     // placeholder for loading state when swapping to a local frame.
     // In this case, the core LocalFrame is already initialized, so just
     // update a bit of state.
     LocalFrame& local_frame = *ToWebLocalFrameImpl(frame)->GetFrame();
     DCHECK_EQ(owner, local_frame.Owner());
     if (owner) {
       owner->SetContentFrame(local_frame);
       if (owner->IsLocal())
         ToHTMLFrameOwnerElement(owner)->SetWidget(local_frame.View());
     } else {
       local_frame.GetPage()->SetMainFrame(&local_frame);
       // This trace event is needed to detect the main frame of the
       // renderer in telemetry metrics. See crbug.com/692112#c11.
       TRACE_EVENT_INSTANT1("loading", "markAsMainFrame",
                            TRACE_EVENT_SCOPE_THREAD, "frame", &local_frame);
     }
   } else {
     ToWebRemoteFrameImpl(frame)->InitializeCoreFrame(*page, owner, name);
   }
 
   if (parent_ && old_frame->HasReceivedUserGesture())
-    frame->ToImplBase()->GetFrame()->SetDocumentHasReceivedUserGesture();
+    ToCoreFrame(*frame)->SetDocumentHasReceivedUserGesture();
 
-  frame->ToImplBase()->GetFrame()->GetWindowProxyManager()->SetGlobalProxies(
+  ToCoreFrame(*frame)->GetWindowProxyManager()->SetGlobalProxies(
       global_proxies);
 
   parent_ = nullptr;
 
   return true;
 }
 
 void WebFrame::Detach() {
-  ToImplBase()->GetFrame()->Detach(FrameDetachType::kRemove);
+  ToCoreFrame(*this)->Detach(FrameDetachType::kRemove);
 }
 
 WebSecurityOrigin WebFrame::GetSecurityOrigin() const {
   return WebSecurityOrigin(
-      ToImplBase()->GetFrame()->GetSecurityContext()->GetSecurityOrigin());
+      ToCoreFrame(*this)->GetSecurityContext()->GetSecurityOrigin());
 }
 
 void WebFrame::SetFrameOwnerPolicy(
     WebSandboxFlags flags,
     const blink::WebParsedFeaturePolicy& container_policy) {
   // At the moment, this is only used to replicate sandbox flags and container
   // policy for frames with a remote owner.
-  RemoteFrameOwner* owner =
-      ToRemoteFrameOwner(ToImplBase()->GetFrame()->Owner());
+  RemoteFrameOwner* owner = ToRemoteFrameOwner(ToCoreFrame(*this)->Owner());
   DCHECK(owner);
   owner->SetSandboxFlags(static_cast<SandboxFlags>(flags));
   owner->SetContainerPolicy(container_policy);
 }
 
 WebInsecureRequestPolicy WebFrame::GetInsecureRequestPolicy() const {
-  return ToImplBase()
-      ->GetFrame()
-      ->GetSecurityContext()
-      ->GetInsecureRequestPolicy();
+  return ToCoreFrame(*this)->GetSecurityContext()->GetInsecureRequestPolicy();
 }
 
 void WebFrame::SetFrameOwnerProperties(
     const WebFrameOwnerProperties& properties) {
   // At the moment, this is only used to replicate frame owner properties
   // for frames with a remote owner.
-  RemoteFrameOwner* owner =
-      ToRemoteFrameOwner(ToImplBase()->GetFrame()->Owner());
+  RemoteFrameOwner* owner = ToRemoteFrameOwner(ToCoreFrame(*this)->Owner());
   DCHECK(owner);
 
-  Frame* frame = ToImplBase()->GetFrame();
+  Frame* frame = ToCoreFrame(*this);
   DCHECK(frame);
 
   if (frame->IsLocalFrame()) {
     ToLocalFrame(frame)->GetDocument()->WillChangeFrameOwnerProperties(
         properties.margin_width, properties.margin_height,
         static_cast<ScrollbarMode>(properties.scrolling_mode),
         properties.is_display_none);
   }
 
   owner->SetBrowsingContextContainerName(properties.name);
@@ skipping 34 matching lines @@
     new_child->previous_sibling_ = previous_sibling;
   }
 
   if (next) {
     new_child->next_sibling_ = next;
     next->previous_sibling_ = new_child;
   } else {
     last_child_ = new_child;
   }
 
-  ToImplBase()->GetFrame()->Tree().InvalidateScopedChildCount();
-  ToImplBase()->GetFrame()->GetPage()->IncrementSubframeCount();
+  ToCoreFrame(*this)->Tree().InvalidateScopedChildCount();
+  ToCoreFrame(*this)->GetPage()->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, last_child_);
 }
 
 void WebFrame::RemoveChild(WebFrame* child) {
   child->parent_ = 0;
 
   if (first_child_ == child)
     first_child_ = child->next_sibling_;
   else
     child->previous_sibling_->next_sibling_ = child->next_sibling_;
 
   if (last_child_ == child)
     last_child_ = child->previous_sibling_;
   else
     child->next_sibling_->previous_sibling_ = child->previous_sibling_;
 
   child->previous_sibling_ = child->next_sibling_ = 0;
 
-  ToImplBase()->GetFrame()->Tree().InvalidateScopedChildCount();
-  ToImplBase()->GetFrame()->GetPage()->DecrementSubframeCount();
+  ToCoreFrame(*this)->Tree().InvalidateScopedChildCount();
+  ToCoreFrame(*this)->GetPage()->DecrementSubframeCount();
 }
 
 void WebFrame::SetParent(WebFrame* parent) {
   parent_ = parent;
 }
 
 WebFrame* WebFrame::Parent() const {
   return parent_;
 }
 
 WebFrame* WebFrame::Top() const {
   WebFrame* frame = const_cast<WebFrame*>(this);
   for (WebFrame* parent = frame; parent; parent = parent->parent_)
     frame = parent;
   return frame;
 }
 
 WebFrame* WebFrame::FirstChild() const {
   return first_child_;
 }
 
 WebFrame* WebFrame::NextSibling() const {
   return next_sibling_;
 }
 
 WebFrame* WebFrame::TraverseNext() const {
-  if (Frame* frame = ToImplBase()->GetFrame())
+  if (Frame* frame = ToCoreFrame(*this))
     return FromFrame(frame->Tree().TraverseNext());
   return nullptr;
 }
 
 WebFrame* WebFrame::FromFrameOwnerElement(const WebElement& web_element) {
   Element* element = web_element;
 
   if (!element->IsFrameOwnerElement())
     return nullptr;
   return FromFrame(ToHTMLFrameOwnerElement(element)->ContentFrame());
 }
 
 bool WebFrame::IsLoading() const {
-  if (Frame* frame = ToImplBase()->GetFrame())
+  if (Frame* frame = ToCoreFrame(*this))
     return frame->IsLoading();
   return false;
 }
 
 WebFrame* WebFrame::FromFrame(Frame* frame) {
   if (!frame)
     return 0;
 
   if (frame->IsLocalFrame())
     return WebLocalFrameImpl::FromFrame(ToLocalFrame(*frame));
@@ skipping 29 matching lines @@
   TraceFrame(visitor, frame->parent_);
   for (WebFrame* child = frame->FirstChild(); child;
        child = child->NextSibling())
     TraceFrame(visitor, child);
 }
 
 void WebFrame::Close() {
   opened_frame_tracker_->Dispose();
 }
 
+void WebFrame::InitializeCoreFrame(WebFrame& frame, Page& page) {
+  if (frame.IsWebLocalFrame())
+    ToWebLocalFrameImpl(frame).InitializeCoreFrame(page, 0, g_null_atom);
+  else if (frame.IsWebRemoteFrame())
+    ToWebRemoteFrameImpl(frame).InitializeCoreFrame(page, 0, g_null_atom);
+  else
+    NOTREACHED();
+}
+
+Frame* WebFrame::ToCoreFrame(const WebFrame& frame) {
+  if (frame.IsWebLocalFrame())
+    return ToWebLocalFrameImpl(frame).GetFrame();
+  if (frame.IsWebRemoteFrame())
+    return ToWebRemoteFrameImpl(frame).GetFrame();
+  NOTREACHED();
+  return nullptr;
+}
+
 }  // namespace blink