Move many more classes to use WebLocalFrameBase over WebLocalFrameImpl.

third_party/WebKit/Source/web/WebDevToolsAgentImpl.cpp

 /*
  * Copyright (C) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 23 matching lines @@
 #include <memory>
 
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "core/CoreProbeSink.h"
 #include "core/events/WebInputEventConversion.h"
 #include "core/exported/WebViewBase.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
+#include "core/frame/WebLocalFrameBase.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorAnimationAgent.h"
 #include "core/inspector/InspectorApplicationCacheAgent.h"
 #include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
 #include "core/inspector/InspectorInputAgent.h"
 #include "core/inspector/InspectorLayerTreeAgent.h"
 #include "core/inspector/InspectorLogAgent.h"
 #include "core/inspector/InspectorMemoryAgent.h"
@@ skipping 27 matching lines @@
 #include "public/platform/Platform.h"
 #include "public/platform/WebLayerTreeView.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebString.h"
 #include "public/web/WebDevToolsAgentClient.h"
 #include "public/web/WebSettings.h"
 #include "web/DevToolsEmulator.h"
 #include "web/InspectorEmulationAgent.h"
 #include "web/InspectorOverlayAgent.h"
 #include "web/WebFrameWidgetImpl.h"
-#include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 
 namespace blink {
 
 namespace {
 
-bool IsMainFrame(WebLocalFrameImpl* frame) {
+bool IsMainFrame(WebLocalFrameBase* frame) {
   // TODO(dgozman): sometimes view->mainFrameImpl() does return null, even
   // though |frame| is meant to be main frame.  See http://crbug.com/526162.
   return frame->ViewImpl() && !frame->Parent();
 }
 }
 
 class ClientMessageLoopAdapter : public MainThreadDebugger::ClientMessageLoop {
  public:
   ~ClientMessageLoopAdapter() override { instance_ = nullptr; }
 
   static void EnsureMainThreadDebuggerCreated(WebDevToolsAgentClient* client) {
     if (instance_)
       return;
     std::unique_ptr<ClientMessageLoopAdapter> instance =
         WTF::WrapUnique(new ClientMessageLoopAdapter(
             WTF::WrapUnique(client->CreateClientMessageLoop())));
     instance_ = instance.get();
     MainThreadDebugger::Instance()->SetClientMessageLoop(std::move(instance));
   }
 
   static void ContinueProgram() {
     // Release render thread if necessary.
     if (instance_)
       instance_->QuitNow();
   }
 
-  static void PauseForCreateWindow(WebLocalFrameImpl* frame) {
+  static void PauseForCreateWindow(WebLocalFrameBase* frame) {
     if (instance_)
       instance_->RunForCreateWindow(frame);
   }
 
   static bool ResumeForCreateWindow() {
     return instance_ ? instance_->QuitForCreateWindow() : false;
   }
 
  private:
   ClientMessageLoopAdapter(
       std::unique_ptr<WebDevToolsAgentClient::WebKitClientMessageLoop>
           message_loop)
       : running_for_debug_break_(false),
         running_for_create_window_(false),
         message_loop_(std::move(message_loop)) {
     DCHECK(message_loop_.get());
   }
 
   void Run(LocalFrame* frame) override {
     if (running_for_debug_break_)
       return;
 
     running_for_debug_break_ = true;
     if (!running_for_create_window_)
-      RunLoop(WebLocalFrameImpl::FromFrame(frame));
+      RunLoop(WebLocalFrameBase::FromFrame(frame));
   }
 
-  void RunForCreateWindow(WebLocalFrameImpl* frame) {
+  void RunForCreateWindow(WebLocalFrameBase* frame) {
     if (running_for_create_window_)
       return;
 
     running_for_create_window_ = true;
     if (!running_for_debug_break_)
       RunLoop(frame);
   }
 
-  void RunLoop(WebLocalFrameImpl* frame) {
+  void RunLoop(WebLocalFrameBase* frame) {
     // 0. Flush pending frontend messages.
     WebDevToolsAgentImpl* agent = frame->DevToolsAgentImpl();
     agent->FlushProtocolNotifications();
 
     // 1. Disable input events.
     WebFrameWidgetBase::SetIgnoreInputEvents(true);
     for (const auto view : WebViewBase::AllInstances())
       view->ChromeClient().NotifyPopupOpeningObservers();
 
     // 2. Notify embedder about pausing.
@@ skipping 33 matching lines @@
     }
     return false;
   }
 
   void RunIfWaitingForDebugger(LocalFrame* frame) override {
     // If we've paused for createWindow, handle it ourselves.
     if (QuitForCreateWindow())
       return;
     // Otherwise, pass to the client (embedded workers do it differently).
     WebDevToolsAgentImpl* agent =
-        WebLocalFrameImpl::FromFrame(frame)->DevToolsAgentImpl();
+        WebLocalFrameBase::FromFrame(frame)->DevToolsAgentImpl();
     if (agent && agent->Client())
       agent->Client()->ResumeStartup();
   }
 
   bool running_for_debug_break_;
   bool running_for_create_window_;
   std::unique_ptr<WebDevToolsAgentClient::WebKitClientMessageLoop>
       message_loop_;
 
   static ClientMessageLoopAdapter* instance_;
 };
 
 ClientMessageLoopAdapter* ClientMessageLoopAdapter::instance_ = nullptr;
 
 // static
 WebDevToolsAgentImpl* WebDevToolsAgentImpl::Create(
-    WebLocalFrameImpl* frame,
+    WebLocalFrameBase* frame,
     WebDevToolsAgentClient* client) {
   if (!IsMainFrame(frame)) {
     WebDevToolsAgentImpl* agent =
         new WebDevToolsAgentImpl(frame, client, false);
     if (frame->FrameWidget())
       agent->LayerTreeViewChanged(
           ToWebFrameWidgetImpl(frame->FrameWidget())->LayerTreeView());
     return agent;
   }
 
   WebViewBase* view = frame->ViewImpl();
   WebDevToolsAgentImpl* agent = new WebDevToolsAgentImpl(frame, client, true);
   agent->LayerTreeViewChanged(view->LayerTreeView());
   return agent;
 }
 
 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
-    WebLocalFrameImpl* web_local_frame_impl,
+    WebLocalFrameBase* web_local_frame_impl,
     WebDevToolsAgentClient* client,
     bool include_view_agents)
     : client_(client),
       web_local_frame_impl_(web_local_frame_impl),
       probe_sink_(web_local_frame_impl_->GetFrame()->GetProbeSink()),
       resource_content_loader_(InspectorResourceContentLoader::Create(
           web_local_frame_impl_->GetFrame())),
       inspected_frames_(
           InspectedFrames::Create(web_local_frame_impl_->GetFrame())),
       resource_container_(new InspectorResourceContainer(inspected_frames_)),
@@ skipping 303 matching lines @@
 
 void WebDevToolsAgentImpl::PageLayoutInvalidated(bool resized) {
   if (overlay_agent_)
     overlay_agent_->PageLayoutInvalidated(resized);
 }
 
 void WebDevToolsAgentImpl::WaitForCreateWindow(LocalFrame* frame) {
   if (!Attached())
     return;
   if (client_ &&
-      client_->RequestDevToolsForFrame(WebLocalFrameImpl::FromFrame(frame)))
+      client_->RequestDevToolsForFrame(WebLocalFrameBase::FromFrame(frame)))
     ClientMessageLoopAdapter::PauseForCreateWindow(web_local_frame_impl_);
 }
 
 WebString WebDevToolsAgentImpl::EvaluateInWebInspectorOverlay(
     const WebString& script) {
   if (!overlay_agent_)
     return WebString();
 
   return overlay_agent_->EvaluateInOverlayForTest(script);
 }
@@ skipping 62 matching lines @@
 }
 
 bool WebDevToolsAgent::ShouldInterruptForMethod(const WebString& method) {
   return method == "Debugger.pause" || method == "Debugger.setBreakpoint" ||
          method == "Debugger.setBreakpointByUrl" ||
          method == "Debugger.removeBreakpoint" ||
          method == "Debugger.setBreakpointsActive";
 }
 
 }  // namespace blink