Convert devtools interfaces over to using WebString....

webkit/glue/webdevtoolsclient_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 "DOMWindow.h"
@@ skipping 23 matching lines @@
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webdevtoolsclient_delegate.h"
 #include "webkit/glue/webdevtoolsclient_impl.h"
 #include "webkit/glue/webview_impl.h"
 
 using namespace WebCore;
 using WebKit::WebFrame;
 using WebKit::WebScriptSource;
 using WebKit::WebString;
 
+static v8::Local<v8::String> ToV8String(const String& s) {
+  if (s.isNull())
+    return v8::Local<v8::String>();
+
+  return v8::String::New(reinterpret_cast<const uint16_t*>(s.characters()),
+                         s.length());
+}
+
 DEFINE_RPC_JS_BOUND_OBJ(DebuggerAgent, DEBUGGER_AGENT_STRUCT,
     DebuggerAgentDelegate, DEBUGGER_AGENT_DELEGATE_STRUCT)
 DEFINE_RPC_JS_BOUND_OBJ(ToolsAgent, TOOLS_AGENT_STRUCT,
     ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT)
 
 class ToolsAgentNativeDelegateImpl : public ToolsAgentNativeDelegate {
  public:
   struct ResourceContentRequestData {
     String mime_type;
     RefPtr<Node> frame;
@@ skipping 39 matching lines @@
  private:
   WebFrameImpl* frame_;
   HashMap<int, ResourceContentRequestData> resource_content_requests_;
   DISALLOW_COPY_AND_ASSIGN(ToolsAgentNativeDelegateImpl);
 };
 
 // static
 WebDevToolsClient* WebDevToolsClient::Create(
     WebView* view,
     WebDevToolsClientDelegate* delegate,
-    const std::string& application_locale) {
-  return new WebDevToolsClientImpl(static_cast<WebViewImpl*>(view),
-                                   delegate,
-                                   application_locale);
+    const WebString& application_locale) {
+  return new WebDevToolsClientImpl(
+      static_cast<WebViewImpl*>(view),
+      delegate,
+      webkit_glue::WebStringToString(application_locale));
 }
 
 WebDevToolsClientImpl::WebDevToolsClientImpl(
     WebViewImpl* web_view_impl,
     WebDevToolsClientDelegate* delegate,
-    const std::string& application_locale)
+    const String& application_locale)
     : web_view_impl_(web_view_impl),
       delegate_(delegate),
-      application_locale_(application_locale.c_str()),
+      application_locale_(application_locale),
       loaded_(false) {
   WebFrameImpl* frame = web_view_impl_->main_frame();
   v8::HandleScope scope;
   v8::Handle<v8::Context> frame_context = V8Proxy::context(frame->frame());
 
   debugger_agent_obj_.set(new JsDebuggerAgentBoundObj(
       this, frame_context, "RemoteDebuggerAgent"));
   tools_agent_obj_.set(
       new JsToolsAgentBoundObj(this, frame_context, "RemoteToolsAgent"));
 
@@ skipping 45 matching lines @@
   dev_tools_host_->AddProtoFunction(
       "hiddenPanels",
       WebDevToolsClientImpl::JsHiddenPanels);
   dev_tools_host_->Build();
 }
 
 WebDevToolsClientImpl::~WebDevToolsClientImpl() {
 }
 
 void WebDevToolsClientImpl::DispatchMessageFromAgent(
-      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 (ToolsAgentNativeDelegateDispatch::Dispatch(
           tools_agent_native_delegate_impl_.get(),
-          class_name,
-          method_name,
-          param1,
-          param2,
-          param3)) {
+          webkit_glue::WebStringToString(class_name),
+          webkit_glue::WebStringToString(method_name),
+          webkit_glue::WebStringToString(param1),
+          webkit_glue::WebStringToString(param2),
+          webkit_glue::WebStringToString(param3))) {
     return;
   }
 
-  Vector<std::string> v;
-  v.append(class_name);
-  v.append(method_name);
-  v.append(param1);
-  v.append(param2);
-  v.append(param3);
+  Vector<String> v;
+  v.append(webkit_glue::WebStringToString(class_name));
+  v.append(webkit_glue::WebStringToString(method_name));
+  v.append(webkit_glue::WebStringToString(param1));
+  v.append(webkit_glue::WebStringToString(param2));
+  v.append(webkit_glue::WebStringToString(param3));
   if (!loaded_) {
     pending_incoming_messages_.append(v);
     return;
   }
   ExecuteScript(v);
 }
 
 void WebDevToolsClientImpl::AddResourceSourceToFrame(int resource_id,
                                                      String mime_type,
                                                      Node* frame) {
   if (tools_agent_native_delegate_impl_->WaitingForResponse(resource_id,
                                                             frame)) {
     return;
   }
   tools_agent_obj_->GetResourceContent(resource_id, resource_id);
   tools_agent_native_delegate_impl_->RequestSent(resource_id, mime_type, frame);
 }
 
-void WebDevToolsClientImpl::ExecuteScript(const Vector<std::string>& v) {
+void WebDevToolsClientImpl::ExecuteScript(const Vector<String>& v) {
   WebFrameImpl* frame = web_view_impl_->main_frame();
   v8::HandleScope scope;
   v8::Handle<v8::Context> frame_context = V8Proxy::context(frame->frame());
   v8::Context::Scope context_scope(frame_context);
   v8::Handle<v8::Value> dispatch_function =
       frame_context->Global()->Get(v8::String::New("devtools$$dispatch"));
   ASSERT(dispatch_function->IsFunction());
   v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatch_function);
   v8::Handle<v8::Value> args[] = {
-    v8::String::New(v.at(0).c_str()),
-    v8::String::New(v.at(1).c_str()),
-    v8::String::New(v.at(2).c_str()),
-    v8::String::New(v.at(3).c_str()),
-    v8::String::New(v.at(4).c_str())
+    ToV8String(v.at(0)),
+    ToV8String(v.at(1)),
+    ToV8String(v.at(2)),
+    ToV8String(v.at(3)),
+    ToV8String(v.at(4)),
   };
   function->Call(frame_context->Global(), 5, args);
 }
 
-void WebDevToolsClientImpl::SendRpcMessage(const std::string& class_name,
-                                           const std::string& method_name,
-                                           const std::string& param1,
-                                           const std::string& param2,
-                                           const std::string& param3) {
-  delegate_->SendMessageToAgent(class_name, method_name, param1, param2,
-                                param3);
+void WebDevToolsClientImpl::SendRpcMessage(const String& class_name,
+                                           const String& method_name,
+                                           const String& param1,
+                                           const String& param2,
+                                           const String& param3) {
+  delegate_->SendMessageToAgent(
+      webkit_glue::StringToWebString(class_name),
+      webkit_glue::StringToWebString(method_name),
+      webkit_glue::StringToWebString(param1),
+      webkit_glue::StringToWebString(param2),
+      webkit_glue::StringToWebString(param3));
 }
 
 // static
 v8::Handle<v8::Value> WebDevToolsClientImpl::JsReset(
     const v8::Arguments& args) {
   WebDevToolsClientImpl* client = static_cast<WebDevToolsClientImpl*>(
       v8::External::Cast(*args.Data())->Value());
   WebFrameImpl* frame = client->web_view_impl_->main_frame();
   client->tools_agent_native_delegate_impl_.set(
       new ToolsAgentNativeDelegateImpl(frame));
@@ skipping 50 matching lines @@
     const v8::Arguments& args) {
   WebDevToolsClientImpl* client = static_cast<WebDevToolsClientImpl*>(
       v8::External::Cast(*args.Data())->Value());
   client->loaded_ = true;
 
   // Grant the devtools page the ability to have source view iframes.
   Page* page = V8Proxy::retrieveFrameForEnteredContext()->page();
   SecurityOrigin* origin = page->mainFrame()->domWindow()->securityOrigin();
   origin->grantUniversalAccess();
 
-  for (Vector<Vector<std::string> >::iterator it =
+  for (Vector<Vector<String> >::iterator it =
            client->pending_incoming_messages_.begin();
        it != client->pending_incoming_messages_.end();
        ++it) {
     client->ExecuteScript(*it);
   }
   client->pending_incoming_messages_.clear();
   return v8::Undefined();
 }
 
 // static
@@ skipping 68 matching lines @@
   Page* page = V8Proxy::retrieveFrameForEnteredContext()->page();
   return v8String(page->settings()->databasesEnabled() ? "" : "databases");
 }
 
 // static
 v8::Handle<v8::Value> WebDevToolsClientImpl::JsDebuggerCommand(
     const v8::Arguments& args) {
   WebDevToolsClientImpl* client = static_cast<WebDevToolsClientImpl*>(
       v8::External::Cast(*args.Data())->Value());
   String command = WebCore::toWebCoreStringWithNullCheck(args[0]);
-  std::string std_command = webkit_glue::StringToStdString(command);
+  WebString std_command = webkit_glue::StringToWebString(command);
   client->delegate_->SendDebuggerCommandToAgent(std_command);
   return v8::Undefined();
 }