Remove deprecated wstring Get(As)String() methods from Value, etc.

chrome/browser/debugger/extension_ports_remote_service.cc

 // Copyright (c) 2010 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.
 
 // Implementation of the ExtensionPortsRemoteService.
 
 // Inspired significantly from debugger_remote_service
 // and ../automation/extension_port_container.
 
 #include "chrome/browser/debugger/extension_ports_remote_service.h"
@@ skipping 56 matching lines @@
 //    "result": 0,  (Always 0)
 //    "data": <message body - arbitrary JSON>
 //   }
 //
 // The "disconnect" command from the external client, and
 // "onDisconnect" notification from the ExtensionMessageService, are
 // similar: with the message port ID in the destination field, but no
 // "data" field in this case.
 
 // Commands:
-static const std::string kConnect = "connect";
-static const std::string kDisconnect = "disconnect";
-static const std::string kPostMessage = "postMessage";
+const char kConnect[] = "connect";
+const char kDisconnect[] = "disconnect";
+const char kPostMessage[] = "postMessage";
 // Events:
-static const std::string kOnMessage = "onMessage";
-static const std::string kOnDisconnect = "onDisconnect";
+const char kOnMessage[] = "onMessage";
+const char kOnDisconnect[] = "onDisconnect";
 
 // Constants for the JSON message fields.
 // The type is wstring because the constant is used to get a
 // DictionaryValue field (which requires a wide string).
 
 // Mandatory.
-static const std::wstring kCommandWide = L"command";
+const char kCommandKey[] = "command";
 
 // Always present in messages sent to the external client.
-static const std::wstring kResultWide = L"result";
+const char kResultKey[] = "result";
 
 // Field for command-specific parameters. Not strictly necessary, but
 // makes it more similar to the remote debugger protocol, which should
 // allow easier reuse of client code.
-static const std::wstring kDataWide = L"data";
+const char kDataKey[] = "data";
 
 // Fields within the "data" dictionary:
 
 // Required for "connect":
-static const std::wstring kExtensionIdWide = L"extensionId";
+const char kExtensionIdKey[] = "extensionId";
 // Optional in "connect":
-static const std::wstring kChannelNameWide = L"channelName";
-static const std::wstring kTabIdWide = L"tabId";
+const char kChannelNameKey[] = "channelName";
+const char kTabIdKey[] = "tabId";
 
 // Present under "data" in replies to a successful "connect" .
-static const std::wstring kPortIdWide = L"portId";
+const char kPortIdKey[] = "portId";
 
 }  // namespace
 
 const std::string ExtensionPortsRemoteService::kToolName = "ExtensionPorts";
 
 ExtensionPortsRemoteService::ExtensionPortsRemoteService(
     DevToolsProtocolHandler* delegate)
     : delegate_(delegate), service_(NULL) {
   // We need an ExtensionMessageService instance. It hangs off of
   // |profile|. But we do not have a particular tab or RenderViewHost
@@ skipping 33 matching lines @@
     // Bad JSON
     NOTREACHED();
     return;
   }
   DictionaryValue* content;
   if (!request->IsType(Value::TYPE_DICTIONARY)) {
     NOTREACHED();  // Broken protocol :(
     return;
   }
   content = static_cast<DictionaryValue*>(request.get());
-  if (!content->HasKey(kCommandWide)) {
+  if (!content->HasKey(kCommandKey)) {
     NOTREACHED();  // Broken protocol :(
     return;
   }
   std::string command;
   DictionaryValue response;
 
-  content->GetString(kCommandWide, &command);
-  response.SetString(kCommandWide, command);
+  content->GetString(kCommandKey, &command);
+  response.SetString(kCommandKey, command);
 
   if (!service_) {
     // This happens if we failed to obtain an ExtensionMessageService
     // during initialization.
     NOTREACHED();
-    response.SetInteger(kResultWide, RESULT_NO_SERVICE);
+    response.SetInteger(kResultKey, RESULT_NO_SERVICE);
     SendResponse(response, message.tool(), message.destination());
     return;
   }
 
   int destination = -1;
   if (destinationString.size() != 0)
     base::StringToInt(destinationString, &destination);
 
   if (command == kConnect) {
     if (destination != -1)  // destination should be empty for this command.
-      response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+      response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     else
       ConnectCommand(content, &response);
   } else if (command == kDisconnect) {
     if (destination == -1)  // Destination required for this command.
-      response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+      response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     else
       DisconnectCommand(destination, &response);
   } else if (command == kPostMessage) {
     if (destination == -1)  // Destination required for this command.
-      response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+      response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     else
       PostMessageCommand(destination, content, &response);
   } else {
     // Unknown command
     NOTREACHED();
-    response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+    response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
   }
   SendResponse(response, message.tool(), message.destination());
 }
 
 void ExtensionPortsRemoteService::OnConnectionLost() {
   LOG(INFO) << "OnConnectionLost";
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   DCHECK(service_);
   for (PortIdSet::iterator it = openPortIds_.begin();
       it != openPortIds_.end();
@@ skipping 50 matching lines @@
     NOTREACHED() << function_name << " shouldn't be called.";
   }
 }
 
 void ExtensionPortsRemoteService::OnExtensionMessage(
     const std::string& message, int port_id) {
   LOG(INFO) << "Message event: from port " << port_id
             << ", < " << message << ">";
   // Transpose the information into a JSON message for the external client.
   DictionaryValue content;
-  content.SetString(kCommandWide, kOnMessage);
-  content.SetInteger(kResultWide, RESULT_OK);
+  content.SetString(kCommandKey, kOnMessage);
+  content.SetInteger(kResultKey, RESULT_OK);
   // Turn the stringified message body back into JSON.
   Value* data = base::JSONReader::Read(message, false);
   if (!data) {
     NOTREACHED();
     return;
   }
-  content.Set(kDataWide, data);
+  content.Set(kDataKey, data);
   SendResponse(content, kToolName, base::IntToString(port_id));
 }
 
 void ExtensionPortsRemoteService::OnExtensionPortDisconnected(int port_id) {
   LOG(INFO) << "Disconnect event for port " << port_id;
   openPortIds_.erase(port_id);
   DictionaryValue content;
-  content.SetString(kCommandWide, kOnDisconnect);
-  content.SetInteger(kResultWide, RESULT_OK);
+  content.SetString(kCommandKey, kOnDisconnect);
+  content.SetInteger(kResultKey, RESULT_OK);
   SendResponse(content, kToolName, base::IntToString(port_id));
 }
 
 void ExtensionPortsRemoteService::ConnectCommand(
     DictionaryValue* content, DictionaryValue* response) {
   // Parse out the parameters.
   DictionaryValue* data;
-  if (!content->GetDictionary(kDataWide, &data)) {
-    response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
+  if (!content->GetDictionary(kDataKey, &data)) {
+    response->SetInteger(kResultKey, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string extension_id;
-  if (!data->GetString(kExtensionIdWide, &extension_id)) {
-    response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
+  if (!data->GetString(kExtensionIdKey, &extension_id)) {
+    response->SetInteger(kResultKey, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string channel_name = "";
-  data->GetString(kChannelNameWide, &channel_name);  // optional.
+  data->GetString(kChannelNameKey, &channel_name);  // optional.
   int tab_id = -1;
-  data->GetInteger(kTabIdWide, &tab_id);  // optional.
+  data->GetInteger(kTabIdKey, &tab_id);  // optional.
   int port_id;
   if (tab_id != -1) {  // Resolve the tab ID.
     const InspectableTabProxy::ControllersMap& navcon_map =
         delegate_->inspectable_tab_proxy()->controllers_map();
     InspectableTabProxy::ControllersMap::const_iterator it =
         navcon_map.find(tab_id);
     TabContents* tab_contents = NULL;
     if (it != navcon_map.end())
       tab_contents = it->second->tab_contents();
     if (!tab_contents) {
       LOG(INFO) << "tab not found: " << tab_id;
-      response->SetInteger(kResultWide, RESULT_TAB_NOT_FOUND);
+      response->SetInteger(kResultKey, RESULT_TAB_NOT_FOUND);
       return;
     }
     // Ask the ExtensionMessageService to open the channel.
     LOG(INFO) << "Connect: extension_id <" << extension_id
               << ">, channel_name <" << channel_name << ">"
               << ", tab " << tab_id;
     DCHECK(service_);
     port_id = service_->OpenSpecialChannelToTab(
         extension_id, channel_name, tab_contents, this);
   } else {  // no tab: channel to an extension' background page / toolstrip.
     // Ask the ExtensionMessageService to open the channel.
     LOG(INFO) << "Connect: extension_id <" << extension_id
               << ">, channel_name <" << channel_name << ">";
     DCHECK(service_);
     port_id = service_->OpenSpecialChannelToExtension(
         extension_id, channel_name, "null", this);
   }
   if (port_id == -1) {
     // Failure: probably the extension ID doesn't exist.
     LOG(INFO) << "Connect failed";
-    response->SetInteger(kResultWide, RESULT_CONNECT_FAILED);
+    response->SetInteger(kResultKey, RESULT_CONNECT_FAILED);
     return;
   }
   LOG(INFO) << "Connected: port " << port_id;
   openPortIds_.insert(port_id);
   // Reply to external client with the port ID assigned to the new channel.
   DictionaryValue* reply_data = new DictionaryValue();
-  reply_data->SetInteger(kPortIdWide, port_id);
-  response->Set(kDataWide, reply_data);
-  response->SetInteger(kResultWide, RESULT_OK);
+  reply_data->SetInteger(kPortIdKey, port_id);
+  response->Set(kDataKey, reply_data);
+  response->SetInteger(kResultKey, RESULT_OK);
 }
 
 void ExtensionPortsRemoteService::DisconnectCommand(
     int port_id, DictionaryValue* response) {
   LOG(INFO) << "Disconnect port " << port_id;
   PortIdSet::iterator portEntry = openPortIds_.find(port_id);
   if (portEntry == openPortIds_.end()) {  // unknown port ID.
     LOG(INFO) << "unknown port: " << port_id;
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_PORT);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_PORT);
     return;
   }
   DCHECK(service_);
   service_->CloseChannel(port_id);
   openPortIds_.erase(portEntry);
-  response->SetInteger(kResultWide, RESULT_OK);
+  response->SetInteger(kResultKey, RESULT_OK);
 }
 
 void ExtensionPortsRemoteService::PostMessageCommand(
     int port_id, DictionaryValue* content, DictionaryValue* response) {
   Value* data;
-  if (!content->Get(kDataWide, &data)) {
-    response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
+  if (!content->Get(kDataKey, &data)) {
+    response->SetInteger(kResultKey, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string message;
   // Stringified the JSON message body.
   base::JSONWriter::Write(data, false, &message);
   LOG(INFO) << "postMessage: port " << port_id
             << ", message: <" << message << ">";
   PortIdSet::iterator portEntry = openPortIds_.find(port_id);
   if (portEntry == openPortIds_.end()) {  // Unknown port ID.
     LOG(INFO) << "unknown port: " << port_id;
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_PORT);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_PORT);
     return;
   }
   // Post the message through the ExtensionMessageService.
   DCHECK(service_);
   service_->PostMessageFromRenderer(port_id, message);
   // Confirm to the external client that we sent its message.
-  response->SetInteger(kResultWide, RESULT_OK);
+  response->SetInteger(kResultKey, RESULT_OK);
 }