Convert devtools interfaces over to using WebString....

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"
@@ skipping 34 matching lines @@
 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::WebFrame;
+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,
@@ skipping 79 matching lines @@
 
 void WebDevToolsAgentImpl::DidCommitLoadForFrame(
     WebViewImpl* webview,
     WebFrame* frame,
     bool is_new_navigation) {
   if (!attached_) {
     return;
   }
   WebDataSource* ds = frame->dataSource();
   const WebURLRequest& request = ds->request();
-  GURL url = ds->hasUnreachableURL() ?
+  WebURL url = ds->hasUnreachableURL() ?
       ds->unreachableURL() :
       request.url();
   if (webview->mainFrame() == frame) {
     ResetInspectorFrontendProxy();
     tools_agent_delegate_stub_->FrameNavigate(
-        url.possibly_invalid_spec());
+        webkit_glue::WebURLToKURL(url).string());
     SetApuAgentEnabledInUtilityContext(utility_context_, apu_agent_enabled_);
   }
   UnhideResourcesPanelIfNecessary();
 }
 
 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_);
@@ skipping 70 matching lines @@
   } else {
     ic->stopTimelineProfiler();
     if (!resource_tracking_was_enabled_) {
       ic->disableResourceTracking(false);
     }
     resource_tracking_was_enabled_ = false;
   }
 }
 
 void WebDevToolsAgentImpl::DispatchMessageFromClient(
-    const std::string& class_name,
-    const std::string& method_name,
-    const std::string& param1,
-    const std::string& param2,
-    const std::string& param3) {
+    const WebString& class_name,
+    const WebString& method_name,
+    const WebString& param1,
+    const WebString& param2,
+    const WebString& param3) {
   if (ToolsAgentDispatch::Dispatch(
-      this, class_name, method_name, param1, param2, param3)) {
+      this,
+      webkit_glue::WebStringToString(class_name),
+      webkit_glue::WebStringToString(method_name),
+      webkit_glue::WebStringToString(param1),
+      webkit_glue::WebStringToString(param2),
+      webkit_glue::WebStringToString(param3))) {
     return;
   }
 
   if (!attached_) {
     return;
   }
 
   if (debugger_agent_impl_.get() &&
       DebuggerAgentDispatch::Dispatch(
-          debugger_agent_impl_.get(), class_name, method_name,
-          param1, param2, param3)) {
+          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;
   }
   InspectorController* ic = web_view_impl_->page()->inspectorController();
   ic->inspect(node);
 }
 
 void WebDevToolsAgentImpl::SendRpcMessage(
-    const std::string& class_name,
-    const std::string& method_name,
-    const std::string& param1,
-    const std::string& param2,
-    const std::string& param3) {
-  delegate_->SendMessageToClient(class_name, method_name, param1, param2,
-      param3);
+    const String& class_name,
+    const String& method_name,
+    const String& param1,
+    const String& param2,
+    const String& param3) {
+  delegate_->SendMessageToClient(
+      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",
@@ skipping 85 matching lines @@
     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
 void WebDevToolsAgent::ExecuteDebuggerCommand(
-    const std::string& command,
+    const WebString& command,
     int caller_id) {
-  DebuggerAgentManager::ExecuteDebuggerCommand(command, caller_id);
+  DebuggerAgentManager::ExecuteDebuggerCommand(
+      webkit_glue::WebStringToString(command), caller_id);
 }
 
 // static
 void WebDevToolsAgent::SetMessageLoopDispatchHandler(
     MessageLoopDispatchHandler handler) {
   DebuggerAgentManager::SetMessageLoopDispatchHandler(handler);
 }