Move WebFrame to use WebLocalFrameBase instead of WebLocalFrameImpl.

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 <algorithm>
 #include "bindings/core/v8/WindowProxyManager.h"
 #include "core/HTMLNames.h"
 #include "core/dom/IncrementLoadEventDelayCount.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
+#include "core/frame/WebLocalFrameBase.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 "platform/instrumentation/tracing/TraceEvent.h"
 #include "public/web/WebElement.h"
 #include "public/web/WebFrameOwnerProperties.h"
 #include "public/web/WebSandboxFlags.h"
 #include "web/OpenedFrameTracker.h"
 #include "web/RemoteFrameOwner.h"
-#include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 
 namespace blink {
 
 bool WebFrame::Swap(WebFrame* frame) {
   using std::swap;
   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;
 
   // If there is a local parent, it might incorrectly declare itself complete
   // during the detach phase of this swap. Suppress its completion until swap is
   // over, at which point its completion will be correctly dependent on its
   // newly swapped-in child.
   std::unique_ptr<IncrementLoadEventDelayCount> delay_parent_load =
       parent_ && parent_->IsWebLocalFrame()
           ? IncrementLoadEventDelayCount::Create(
-                *ToWebLocalFrameImpl(parent_)->GetFrame()->GetDocument())
+                *ToWebLocalFrameBase(parent_)->GetFrame()->GetDocument())
           : nullptr;
 
   if (parent_) {
     if (parent_->first_child_ == this)
       parent_->first_child_ = frame;
     if (parent_->last_child_ == this)
       parent_->last_child_ = frame;
     // FIXME: This is due to the fact that the |frame| may be a provisional
     // local frame, because we don't know if the navigation will result in
     // an actual page or something else, like a download. The PlzNavigate
@@ skipping 32 matching lines @@
   // 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
     // 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();
+    LocalFrame& local_frame = *ToWebLocalFrameBase(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",
@@ skipping 170 matching lines @@
   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));
+    return WebLocalFrameBase::FromFrame(ToLocalFrame(*frame));
   return WebRemoteFrameImpl::FromFrame(ToRemoteFrame(*frame));
 }
 
 WebFrame::WebFrame(WebTreeScopeType scope)
     : scope_(scope),
       parent_(0),
       previous_sibling_(0),
       next_sibling_(0),
       first_child_(0),
       last_child_(0),
       opener_(0),
       opened_frame_tracker_(new OpenedFrameTracker) {}
 
 WebFrame::~WebFrame() {
   opened_frame_tracker_.reset(0);
 }
 
 void WebFrame::TraceFrame(Visitor* visitor, WebFrame* frame) {
   if (!frame)
     return;
 
   if (frame->IsWebLocalFrame())
-    visitor->Trace(ToWebLocalFrameImpl(frame));
+    visitor->Trace(ToWebLocalFrameBase(frame));
   else
     visitor->Trace(ToWebRemoteFrameImpl(frame));
 }
 
 void WebFrame::TraceFrames(Visitor* visitor, WebFrame* frame) {
   DCHECK(frame);
   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);
+    ToWebLocalFrameBase(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();
+    return ToWebLocalFrameBase(frame).GetFrame();
   if (frame.IsWebRemoteFrame())
     return ToWebRemoteFrameImpl(frame).GetFrame();
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace blink