Move WebDevToolsAgent{Delegate} into the WebKit API....

webkit/glue/webdevtoolsagent_impl.cc

 // Copyright (c) 2009 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 <string>
 
 #include "Document.h"
 #include "EventListener.h"
 #include "InspectorBackend.h"
 #include "InspectorController.h"
 #include "InspectorFrontend.h"
 #include "InspectorResource.h"
 #include "Node.h"
 #include "Page.h"
 #include "PlatformString.h"
 #include "ScriptObject.h"
 #include "ScriptState.h"
 #include "ScriptValue.h"
 #include "V8Binding.h"
 #include "V8Proxy.h"
 #include "V8Utilities.h"
 #include <wtf/OwnPtr.h>
 #undef LOG
 
 #include "webkit/api/public/WebDataSource.h"
+#include "webkit/api/public/WebDevToolsAgentClient.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLRequest.h"
 #include "webkit/glue/devtools/bound_object.h"
 #include "webkit/glue/devtools/debugger_agent_impl.h"
 #include "webkit/glue/devtools/debugger_agent_manager.h"
 #include "webkit/glue/glue_util.h"
-#include "webkit/glue/webdevtoolsagent_delegate.h"
 #include "webkit/glue/webdevtoolsagent_impl.h"
 #include "webkit/glue/webview_impl.h"
 
 using WebCore::Document;
 using WebCore::InspectorBackend;
 using WebCore::InspectorController;
 using WebCore::InspectorFrontend;
 using WebCore::InspectorResource;
 using WebCore::Node;
 using WebCore::Page;
 using WebCore::SafeAllocation;
 using WebCore::ScriptObject;
 using WebCore::ScriptState;
 using WebCore::ScriptValue;
 using WebCore::String;
 using WebCore::V8ClassIndex;
 using WebCore::V8DOMWrapper;
 using WebCore::V8Proxy;
 using WebKit::WebDataSource;
+using WebKit::WebDevToolsAgentClient;
 using WebKit::WebFrame;
+using WebKit::WebPoint;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLRequest;
 
 namespace {
 
 void InspectorBackendWeakReferenceCallback(v8::Persistent<v8::Value> object,
                                            void* parameter) {
   InspectorBackend* backend = static_cast<InspectorBackend*>(parameter);
   backend->deref();
   object.Dispose();
 }
 
 void SetApuAgentEnabledInUtilityContext(v8::Handle<v8::Context> context,
                                         bool enabled) {
   v8::HandleScope handle_scope;
   v8::Context::Scope context_scope(context);
   v8::Handle<v8::Object> dispatcher = v8::Local<v8::Object>::Cast(
       context->Global()->Get(v8::String::New("ApuAgentDispatcher")));
   if (dispatcher.IsEmpty()) {
     return;
   }
   dispatcher->Set(v8::String::New("enabled"), v8::Boolean::New(enabled));
 }
 
 } //  namespace
 
 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
     WebViewImpl* web_view_impl,
-    WebDevToolsAgentDelegate* delegate)
-    : host_id_(delegate->GetHostId()),
-      delegate_(delegate),
+    WebDevToolsAgentClient* client)
+    : host_id_(client->hostIdentifier()),
+      client_(client),
       web_view_impl_(web_view_impl),
       apu_agent_enabled_(false),
       resource_tracking_was_enabled_(false),
       attached_(false) {
   debugger_agent_delegate_stub_.set(new DebuggerAgentDelegateStub(this));
   tools_agent_delegate_stub_.set(new ToolsAgentDelegateStub(this));
   tools_agent_native_delegate_stub_.set(new ToolsAgentNativeDelegateStub(this));
   apu_agent_delegate_stub_.set(new ApuAgentDelegateStub(this));
 }
 
@@ skipping 10 matching lines @@
 }
 
 void WebDevToolsAgentImpl::UnhideResourcesPanelIfNecessary() {
   InspectorController* ic = web_view_impl_->page()->inspectorController();
   ic->ensureResourceTrackingSettingsLoaded();
   String command = String::format("[\"setResourcesPanelEnabled\", %s]",
       ic->resourceTrackingEnabled() ? "true" : "false");
   tools_agent_delegate_stub_->DispatchOnClient(command);
 }
 
-void WebDevToolsAgentImpl::Attach() {
+void WebDevToolsAgentImpl::attach() {
   if (attached_) {
     return;
   }
   debugger_agent_impl_.set(
       new DebuggerAgentImpl(web_view_impl_,
                             debugger_agent_delegate_stub_.get(),
                             this));
   ResetInspectorFrontendProxy();
   UnhideResourcesPanelIfNecessary();
   // Allow controller to send messages to the frontend.
   InspectorController* ic = web_view_impl_->page()->inspectorController();
   ic->setWindowVisible(true, false);
   attached_ = true;
 }
 
-void WebDevToolsAgentImpl::Detach() {
+void WebDevToolsAgentImpl::detach() {
   // Prevent controller from sending messages to the frontend.
   InspectorController* ic = web_view_impl_->page()->inspectorController();
   ic->hideHighlight();
   ic->close();
   DisposeUtilityContext();
   inspector_frontend_script_state_.clear();
   devtools_agent_host_.set(NULL);
   debugger_agent_impl_.set(NULL);
   attached_ = false;
 }
 
-void WebDevToolsAgentImpl::OnNavigate() {
+void WebDevToolsAgentImpl::didNavigate() {
   DebuggerAgentManager::OnNavigate();
 }
 
 void WebDevToolsAgentImpl::DidCommitLoadForFrame(
     WebViewImpl* webview,
     WebFrame* frame,
     bool is_new_navigation) {
   if (!attached_) {
     return;
   }
@@ skipping 13 matching lines @@
 
 void WebDevToolsAgentImpl::WindowObjectCleared(WebFrameImpl* webframe) {
   DebuggerAgentManager::SetHostId(webframe, host_id_);
   if (attached_) {
     // Push context id into the client if it is already attached.
     debugger_agent_delegate_stub_->SetContextId(host_id_);
   }
 }
 
 void WebDevToolsAgentImpl::ForceRepaint() {
-  delegate_->ForceRepaint();
+  client_->forceRepaint();
 }
 
 void WebDevToolsAgentImpl::DispatchOnInspectorController(
       int call_id,
       const String& function_name,
       const String& json_args) {
   String result;
   String exception;
   result = debugger_agent_impl_->ExecuteUtilityFunction(utility_context_,
       call_id, "InspectorControllerDispatcher", function_name, json_args,
@@ skipping 33 matching lines @@
   if (page) {
     RefPtr<InspectorResource> resource =
         page->inspectorController()->resources().get(identifier);
     if (resource.get()) {
       content = resource->sourceString();
     }
   }
   tools_agent_native_delegate_stub_->DidGetResourceContent(call_id, content);
 }
 
-void WebDevToolsAgentImpl::SetApuAgentEnabled(bool enable) {
-  apu_agent_enabled_ = enable;
-  SetApuAgentEnabledInUtilityContext(utility_context_, enable);
-  InspectorController* ic = web_view_impl_->page()->inspectorController();
-  if (enable) {
-    resource_tracking_was_enabled_ = ic->resourceTrackingEnabled();
-    ic->startTimelineProfiler();
-    if (!resource_tracking_was_enabled_) {
-      // TODO(knorton): Introduce some kind of agents dependency here so that
-      // user could turn off resource tracking while apu agent is on.
-      ic->enableResourceTracking(false);
-    }
-  } else {
-    ic->stopTimelineProfiler();
-    if (!resource_tracking_was_enabled_) {
-      ic->disableResourceTracking(false);
-    }
-    resource_tracking_was_enabled_ = false;
-  }
-}
-
-void WebDevToolsAgentImpl::DispatchMessageFromClient(
+void WebDevToolsAgentImpl::dispatchMessageFromFrontend(
     const WebString& class_name,
     const WebString& method_name,
     const WebString& param1,
     const WebString& param2,
     const WebString& param3) {
   if (ToolsAgentDispatch::Dispatch(
       this,
       webkit_glue::WebStringToString(class_name),
       webkit_glue::WebStringToString(method_name),
       webkit_glue::WebStringToString(param1),
@@ skipping 11 matching lines @@
           debugger_agent_impl_.get(),
           webkit_glue::WebStringToString(class_name),
           webkit_glue::WebStringToString(method_name),
           webkit_glue::WebStringToString(param1),
           webkit_glue::WebStringToString(param2),
           webkit_glue::WebStringToString(param3))) {
     return;
   }
 }
 
-void WebDevToolsAgentImpl::InspectElement(int x, int y) {
-  Node* node = web_view_impl_->GetNodeForWindowPos(x, y);
-  if (!node) {
-    return;
+void WebDevToolsAgentImpl::inspectElementAt(const WebPoint& point) {
+  web_view_impl_->inspectElementAt(point);
+}
+
+void WebDevToolsAgentImpl::setApuAgentEnabled(bool enable) {
+  apu_agent_enabled_ = enable;
+  SetApuAgentEnabledInUtilityContext(utility_context_, enable);
+  InspectorController* ic = web_view_impl_->page()->inspectorController();
+  if (enable) {
+    resource_tracking_was_enabled_ = ic->resourceTrackingEnabled();
+    ic->startTimelineProfiler();
+    if (!resource_tracking_was_enabled_) {
+      // TODO(knorton): Introduce some kind of agents dependency here so that
+      // user could turn off resource tracking while apu agent is on.
+      ic->enableResourceTracking(false);
+    }
+  } else {
+    ic->stopTimelineProfiler();
+    if (!resource_tracking_was_enabled_) {
+      ic->disableResourceTracking(false);
+    }
+    resource_tracking_was_enabled_ = false;
   }
-  InspectorController* ic = web_view_impl_->page()->inspectorController();
-  ic->inspect(node);
 }
 
 void WebDevToolsAgentImpl::SendRpcMessage(
     const String& class_name,
     const String& method_name,
     const String& param1,
     const String& param2,
     const String& param3) {
-  delegate_->SendMessageToClient(
+  client_->sendMessageToFrontend(
       webkit_glue::StringToWebString(class_name),
       webkit_glue::StringToWebString(method_name),
       webkit_glue::StringToWebString(param1),
       webkit_glue::StringToWebString(param2),
       webkit_glue::StringToWebString(param3));
 }
 
 void WebDevToolsAgentImpl::InitDevToolsAgentHost() {
   devtools_agent_host_.set(
       new BoundObject(utility_context_, this, "DevToolsAgentHost"));
@@ skipping 88 matching lines @@
   String message = WebCore::toWebCoreStringWithNullCheck(args[0]);
   if (message.isEmpty() || exception_catcher.HasCaught()) {
     return v8::Undefined();
   }
   WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(
       v8::External::Cast(*args.Data())->Value());
   agent->apu_agent_delegate_stub_->DispatchToApu(message);
   return v8::Undefined();
 }
 
+namespace WebKit {
+
 // static
-void WebDevToolsAgent::ExecuteDebuggerCommand(
+void WebDevToolsAgent::executeDebuggerCommand(
     const WebString& command,
     int caller_id) {
   DebuggerAgentManager::ExecuteDebuggerCommand(
       webkit_glue::WebStringToString(command), caller_id);
 }
 
 // static
-void WebDevToolsAgent::SetMessageLoopDispatchHandler(
+void WebDevToolsAgent::setMessageLoopDispatchHandler(
     MessageLoopDispatchHandler handler) {
   DebuggerAgentManager::SetMessageLoopDispatchHandler(handler);
 }
+
+} // namespace WebKit