DevTools: support cross-navigation instrumentation.

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/WebFrame.h"
+#include "webkit/api/public/WebString.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLRequest.h"
 #include "webkit/api/src/WebViewImpl.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_impl.h"
 
 using WebCore::Document;
@@ skipping 35 matching lines @@
   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));
 }
 
+// TODO(pfeldman): Make this public in WebDevToolsAgent API.
+static const char kApuAgentFeatureName[] = "apu-agent";
+
+// Keep these in sync with the ones in inject_dispatch.js.
+static const char kTimelineFeatureName[] = "timeline-profiler";
+static const char kResourceTrackingFeatureName[] = "resource-tracking";
+
 } //  namespace
 
 WebDevToolsAgentImpl::WebDevToolsAgentImpl(
     WebViewImpl* web_view_impl,
     WebDevToolsAgentClient* client)
     : host_id_(client->hostIdentifier()),
       client_(client),
       web_view_impl_(web_view_impl),
       apu_agent_enabled_(false),
       resource_tracking_was_enabled_(false),
@@ skipping 169 matching lines @@
           webkit_glue::WebStringToString(param2),
           webkit_glue::WebStringToString(param3))) {
     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, false);
-    }
-  } else {
-    ic->stopTimelineProfiler();
-    if (!resource_tracking_was_enabled_) {
-      ic->disableResourceTracking(false);
-    }
-    resource_tracking_was_enabled_ = false;
+void WebDevToolsAgentImpl::setRuntimeFeatureEnabled(const WebString& wfeature,
+                                                    bool enabled) {
+  String feature = webkit_glue::WebStringToString(wfeature);
+  if (feature == kApuAgentFeatureName) {
+    setApuAgentEnabled(enabled);
+  } else if (feature == kTimelineFeatureName) {
+    InspectorController* ic = web_view_impl_->page()->inspectorController();
+    if (enabled)
+      ic->startTimelineProfiler();
+    else
+      ic->stopTimelineProfiler();
+  } else if (feature == kResourceTrackingFeatureName) {
+    InspectorController* ic = web_view_impl_->page()->inspectorController();
+    if (enabled)
+      ic->enableResourceTracking(false /* not sticky */, false /* no reload */);
+    else
+      ic->disableResourceTracking(false /* not sticky */);
   }
 }
 
 void WebDevToolsAgentImpl::SendRpcMessage(
     const String& class_name,
     const String& method_name,
     const String& param1,
     const String& param2,
     const String& param3) {
   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"));
   devtools_agent_host_->AddProtoFunction(
       "dispatch",
       WebDevToolsAgentImpl::JsDispatchOnClient);
   devtools_agent_host_->AddProtoFunction(
       "dispatchToApu",
       WebDevToolsAgentImpl::JsDispatchToApu);
+  devtools_agent_host_->AddProtoFunction(
+      "runtimeFeatureStateChanged",
+      WebDevToolsAgentImpl::JsOnRuntimeFeatureStateChanged);
   devtools_agent_host_->Build();
 
   v8::HandleScope scope;
   v8::Context::Scope utility_scope(utility_context_);
   // Call custom code to create inspector backend wrapper in the utility context
   // instead of calling V8DOMWrapper::convertToV8Object that would create the
   // wrapper in the Page main frame context.
   v8::Handle<v8::Object> backend_wrapper = CreateInspectorBackendV8Wrapper();
   if (backend_wrapper.IsEmpty()) {
     return;
@@ skipping 44 matching lines @@
   v8::Handle<v8::Object> injected_script = v8::Local<v8::Object>::Cast(
       utility_context_->Global()->Get(v8::String::New("InjectedScript")));
   ScriptState* state = inspector_frontend_script_state_.get();
   InspectorController* ic = web_view_impl_->page()->inspectorController();
   ic->setFrontendProxyObject(
       state,
       ScriptObject(state, utility_context_->Global()),
       ScriptObject(state, injected_script));
 }
 
+void WebDevToolsAgentImpl::setApuAgentEnabled(bool enabled) {
+  apu_agent_enabled_ = enabled;
+  SetApuAgentEnabledInUtilityContext(utility_context_, enabled);
+  InspectorController* ic = web_view_impl_->page()->inspectorController();
+  if (enabled) {
+    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, false);
+    }
+  } else {
+    ic->stopTimelineProfiler();
+    if (!resource_tracking_was_enabled_) {
+      ic->disableResourceTracking(false);
+    }
+    resource_tracking_was_enabled_ = false;
+  }
+  client_->runtimeFeatureStateChanged(
+      webkit_glue::StringToWebString(kApuAgentFeatureName),
+      enabled);
+}
+
 // static
 v8::Handle<v8::Value> WebDevToolsAgentImpl::JsDispatchOnClient(
     const v8::Arguments& args) {
   v8::TryCatch exception_catcher;
   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->tools_agent_delegate_stub_->DispatchOnClient(message);
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value> WebDevToolsAgentImpl::JsDispatchToApu(
     const v8::Arguments& args) {
   v8::TryCatch exception_catcher;
   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();
 }
 
+// static
+v8::Handle<v8::Value> WebDevToolsAgentImpl::JsOnRuntimeFeatureStateChanged(
+    const v8::Arguments& args) {
+  v8::TryCatch exception_catcher;
+  String feature = WebCore::toWebCoreStringWithNullCheck(args[0]);
+  bool enabled = args[1]->ToBoolean()->Value();
+  if (feature.isEmpty() || exception_catcher.HasCaught()) {
+    return v8::Undefined();
+  }
+  WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(
+      v8::External::Cast(*args.Data())->Value());
+  agent->client_->runtimeFeatureStateChanged(
+      webkit_glue::StringToWebString(feature),
+      enabled);
+  return v8::Undefined();
+}
+
 namespace WebKit {
 
 // static
 void WebDevToolsAgent::executeDebuggerCommand(
     const WebString& command,
     int caller_id) {
   DebuggerAgentManager::ExecuteDebuggerCommand(
       webkit_glue::WebStringToString(command), caller_id);
 }
 
 // static
 void WebDevToolsAgent::setMessageLoopDispatchHandler(
     MessageLoopDispatchHandler handler) {
   DebuggerAgentManager::SetMessageLoopDispatchHandler(handler);
 }
 
 } // namespace WebKit