Convert devtools interfaces over to using WebString....

webkit/glue/devtools/debugger_agent_manager.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 "Frame.h"
 #include "PageGroupLoadDeferrer.h"
 #include "V8Proxy.h"
 #include <wtf/HashSet.h>
@@ skipping 124 matching lines @@
     // Note that we do not empty handlers while in dispatch - we schedule
     // continue and do removal once we are out of the dispatch. Also there is
     // no need to send continue command in this case since removing message
     // handler will cause debugger unload and all breakpoints will be cleared.
     if (!in_host_dispatch_handler_) {
       v8::Debug::SetMessageHandler2(NULL);
       v8::Debug::SetHostDispatchHandler(NULL);
     }
   } else {
     // Remove all breakpoints set by the agent.
-    std::wstring clear_breakpoint_group_cmd(StringPrintf(
-        L"{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\","
-            L"\"arguments\":{\"groupId\":%d}}",
-        host_id));
-    SendCommandToV8(WideToUTF16(clear_breakpoint_group_cmd),
-                    new CallerIdWrapper());
+    String clear_breakpoint_group_cmd = String::format(
+        "{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\","
+            "\"arguments\":{\"groupId\":%d}}",
+        host_id);
+    SendCommandToV8(clear_breakpoint_group_cmd, new CallerIdWrapper());
 
     if (is_on_breakpoint) {
       // Force continue if detach happened in nessted message loop while
       // debugger was paused on a breakpoint(as long as there are other
       // attached agents v8 will wait for explicit'continue' message).
       SendContinueCommandToV8();
     }
   }
 }
 
 // static
 void DebuggerAgentManager::DebugBreak(DebuggerAgentImpl* debugger_agent) {
 #if USE(V8)
   DCHECK(DebuggerAgentForHostId(debugger_agent->webdevtools_agent()->host_id())
              == debugger_agent);
   if (in_utility_context_) {
     debug_break_delayed_ = true;
   } else {
     v8::Debug::DebugBreak();
   }
 #endif
 }
 
 // static
 void DebuggerAgentManager::OnV8DebugMessage(const v8::Debug::Message& message) {
   v8::HandleScope scope;
-  v8::String::Utf8Value value(message.GetJSON());
-  std::string out(*value, value.length());
+  v8::String::Value value(message.GetJSON());
+  String out(reinterpret_cast<const UChar*>(*value), value.length());
 
   // If caller_data is not NULL the message is a response to a debugger command.
   if (v8::Debug::ClientData* caller_data = message.GetClientData()) {
     CallerIdWrapper* wrapper = static_cast<CallerIdWrapper*>(caller_data);
     if (wrapper->caller_is_mananager()) {
       // Just ignore messages sent by this manager.
       return;
     }
     DebuggerAgentImpl* debugger_agent =
         DebuggerAgentForHostId(wrapper->caller_id());
@@ skipping 43 matching lines @@
 
   if (!message.WillStartRunning()) {
     // Autocontinue execution on break and exception  events if there is no
     // handler.
     SendContinueCommandToV8();
   }
 }
 
 // static
 void DebuggerAgentManager::ExecuteDebuggerCommand(
-    const std::string& command,
+    const String& command,
     int caller_id) {
-  SendCommandToV8(UTF8ToUTF16(command), new CallerIdWrapper(caller_id));
+  SendCommandToV8(command, new CallerIdWrapper(caller_id));
 }
 
 // static
 void DebuggerAgentManager::SetMessageLoopDispatchHandler(
     WebDevToolsAgent::MessageLoopDispatchHandler handler) {
   message_loop_dispatch_handler_ = handler;
 }
 
 // static
 void DebuggerAgentManager::SetHostId(WebFrameImpl* webframe, int host_id) {
@@ skipping 13 matching lines @@
 }
 
 // static
 void DebuggerAgentManager::OnNavigate() {
   if (in_host_dispatch_handler_) {
     DebuggerAgentManager::SendContinueCommandToV8();
   }
 }
 
 // static
-void DebuggerAgentManager::SendCommandToV8(const string16& cmd,
+void DebuggerAgentManager::SendCommandToV8(const String& cmd,
                                            v8::Debug::ClientData* data) {
 #if USE(V8)
-  v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.data()),
+  v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.characters()),
                          cmd.length(),
                          data);
 #endif
 }
 
 void DebuggerAgentManager::SendContinueCommandToV8() {
-  std::wstring continue_cmd(
-      L"{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
-  SendCommandToV8(WideToUTF16(continue_cmd), new CallerIdWrapper());
+  String continue_cmd(
+      "{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
+  SendCommandToV8(continue_cmd, new CallerIdWrapper());
 }
 
 // static
 DebuggerAgentImpl* DebuggerAgentManager::FindAgentForCurrentV8Context() {
   if (!attached_agents_map_) {
     return NULL;
   }
   DCHECK(!attached_agents_map_->isEmpty());
 
   WebCore::Frame* frame = WebCore::V8Proxy::retrieveFrameForEnteredContext();
@@ skipping 10 matching lines @@
   return NULL;
 }
 
 // static
 DebuggerAgentImpl* DebuggerAgentManager::DebuggerAgentForHostId(int host_id) {
   if (!attached_agents_map_) {
     return NULL;
   }
   return attached_agents_map_->get(host_id);
 }