Convert wstring to std::string in net_internals_ui.cc.

chrome/browser/ui/webui/net_internals_ui.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/webui/net_internals_ui.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 #include <utility>
@@ skipping 144 matching lines @@
   NetInternalsMessageHandler();
   virtual ~NetInternalsMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui) OVERRIDE;
   virtual void RegisterMessages() OVERRIDE;
 
   // Calls g_browser.receive in the renderer, passing in |command| and |arg|.
   // Takes ownership of |arg|.  If the renderer is displaying a log file, the
   // message will be ignored.
-  void SendJavascriptCommand(const std::wstring& command, Value* arg);
+  void SendJavascriptCommand(const std::string& command, Value* arg);
 
   // NotificationObserver implementation.
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   // Javascript message handlers.
   void OnRendererReady(const ListValue* list);
   void OnEnableHttpThrottling(const ListValue* list);
 #ifdef OS_CHROMEOS
@@ skipping 166 matching lines @@
       const ConnectionTester::Experiment& experiment);
   virtual void OnCompletedConnectionTestExperiment(
       const ConnectionTester::Experiment& experiment,
       int result);
   virtual void OnCompletedConnectionTestSuite();
 
   // Helper that calls g_browser.receive in the renderer, passing in |command|
   // and |arg|.  Takes ownership of |arg|.  If the renderer is displaying a log
   // file, the message will be ignored.  Note that this can be called from any
   // thread.
-  void SendJavascriptCommand(const std::wstring& command, Value* arg);
+  void SendJavascriptCommand(const std::string& command, Value* arg);
 
   // Helper that runs |method| with |arg|, and deletes |arg| on completion.
   void DispatchToMessageHandler(ListValue* arg, MessageHandler method);
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<IOThreadImpl>;
 
   ~IOThreadImpl();
 
@@ skipping 185 matching lines @@
       "enableHttpThrottling",
       base::Bind(&NetInternalsMessageHandler::OnEnableHttpThrottling,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback(
       "getPrerenderInfo",
       base::Bind(&NetInternalsMessageHandler::OnGetPrerenderInfo,
                  base::Unretained(this)));
 }
 
 void NetInternalsMessageHandler::SendJavascriptCommand(
-    const std::wstring& command,
+    const std::string& command,
     Value* arg) {
-  scoped_ptr<Value> command_value(
-      Value::CreateStringValue(WideToASCII(command)));
+  scoped_ptr<Value> command_value(Value::CreateStringValue(command));
   scoped_ptr<Value> value(arg);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (value.get()) {
     web_ui_->CallJavascriptFunction("g_browser.receive",
                                     *command_value.get(),
                                     *value.get());
   } else {
     web_ui_->CallJavascriptFunction("g_browser.receive",
                                     *command_value.get());
   }
 }
 
 void NetInternalsMessageHandler::Observe(int type,
                                          const NotificationSource& source,
                                          const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(type, chrome::NOTIFICATION_PREF_CHANGED);
 
   std::string* pref_name = Details<std::string>(details).ptr();
   if (*pref_name == prefs::kHttpThrottlingEnabled) {
     SendJavascriptCommand(
-        L"receivedHttpThrottlingEnabledPrefChanged",
+        "receivedHttpThrottlingEnabledPrefChanged",
         Value::CreateBooleanValue(*http_throttling_enabled_));
   }
 }
 
 void NetInternalsMessageHandler::OnRendererReady(const ListValue* list) {
   IOThreadImpl::CallbackHelper(&IOThreadImpl::OnRendererReady, proxy_, list);
 
   SendJavascriptCommand(
-      L"receivedHttpThrottlingEnabledPrefChanged",
+      "receivedHttpThrottlingEnabledPrefChanged",
       Value::CreateBooleanValue(*http_throttling_enabled_));
 }
 
 void NetInternalsMessageHandler::OnEnableHttpThrottling(const ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool enable = false;
   if (!list->GetBoolean(0, &enable)) {
     NOTREACHED();
     return;
@@ skipping 15 matching lines @@
 
   DictionaryValue* value = NULL;
   prerender::PrerenderManager* prerender_manager = prerender_manager_.get();
   if (!prerender_manager) {
     value = new DictionaryValue();
     value->SetBoolean("enabled", false);
     value->SetBoolean("omnibox_enabled", false);
   } else {
     value = prerender_manager->GetAsValue();
   }
-  SendJavascriptCommand(L"receivedPrerenderInfo", value);
+  SendJavascriptCommand("receivedPrerenderInfo", value);
 }
 
 
 #ifdef OS_CHROMEOS
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsMessageHandler::SystemLogsGetter
 //
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 75 matching lines @@
     if (!log_it->second.empty()) {
       result->SetString("log", log_it->second);
     } else {
       result->SetString("log", "<no relevant lines found>");
     }
   } else {
     result->SetString("log", "<invalid log name>");
   }
   result->SetString("cellId", request.cell_id);
 
-  handler_->SendJavascriptCommand(L"getSystemLogCallback", result);
+  handler_->SendJavascriptCommand("getSystemLogCallback", result);
 }
 #endif
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsMessageHandler::IOThreadImpl
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsMessageHandler::IOThreadImpl::IOThreadImpl(
     const base::WeakPtr<NetInternalsMessageHandler>& handler,
@@ skipping 50 matching lines @@
   for (size_t i = 0; i < passive_entries.size(); ++i) {
     const ChromeNetLog::Entry& e = passive_entries[i];
     dict_list->Append(net::NetLog::EntryToDictionaryValue(e.type,
                                                           e.time,
                                                           e.source,
                                                           e.phase,
                                                           e.params,
                                                           false));
   }
 
-  SendJavascriptCommand(L"receivedPassiveLogEntries", dict_list);
+  SendJavascriptCommand("receivedPassiveLogEntries", dict_list);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnWebUIDeleted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   was_webui_deleted_ = true;
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnRendererReady(
     const ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!is_observing_log_) << "notifyReady called twice";
 
-  SendJavascriptCommand(L"receivedConstants",
+  SendJavascriptCommand("receivedConstants",
                         NetInternalsUI::GetConstants());
 
   // Register with network stack to observe events.
   is_observing_log_ = true;
   ChromeNetLog::EntryList entries;
   AddAsObserverAndGetAllPassivelyCapturedEvents(io_thread_->net_log(),
                                                 &entries);
   SendPassiveLogEntries(entries);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetProxySettings(
     const ListValue* list) {
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::ProxyService* proxy_service = context->proxy_service();
 
   DictionaryValue* dict = new DictionaryValue();
   if (proxy_service->fetched_config().is_valid())
     dict->Set("original", proxy_service->fetched_config().ToValue());
   if (proxy_service->config().is_valid())
     dict->Set("effective", proxy_service->config().ToValue());
 
-  SendJavascriptCommand(L"receivedProxySettings", dict);
+  SendJavascriptCommand("receivedProxySettings", dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnReloadProxySettings(
     const ListValue* list) {
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   context->proxy_service()->ForceReloadProxyConfig();
 
   // Cause the renderer to be notified of the new values.
   OnGetProxySettings(NULL);
 }
@@ skipping 13 matching lines @@
     const net::ProxyRetryInfo& retry_info = it->second;
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("proxy_uri", proxy_uri);
     dict->SetString("bad_until",
                     net::NetLog::TickCountToString(retry_info.bad_until));
 
     dict_list->Append(dict);
   }
 
-  SendJavascriptCommand(L"receivedBadProxies", dict_list);
+  SendJavascriptCommand("receivedBadProxies", dict_list);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearBadProxies(
     const ListValue* list) {
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   context->proxy_service()->ClearBadProxiesCache();
 
   // Cause the renderer to be notified of the new values.
   OnGetBadProxies(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetHostResolverInfo(
     const ListValue* list) {
   net::URLRequestContext* context = context_getter_->GetURLRequestContext();
   net::HostCache* cache = GetHostResolverCache(context);
 
   if (!cache) {
-    SendJavascriptCommand(L"receivedHostResolverInfo", NULL);
+    SendJavascriptCommand("receivedHostResolverInfo", NULL);
     return;
   }
 
   DictionaryValue* dict = new DictionaryValue();
 
   dict->SetInteger(
       "default_address_family",
       static_cast<int>(context->host_resolver()->GetDefaultAddressFamily()));
 
   DictionaryValue* cache_info_dict = new DictionaryValue();
@@ skipping 38 matching lines @@
       }
       entry_dict->Set("addresses", address_list);
     }
 
     entry_list->Append(entry_dict);
   }
 
   cache_info_dict->Set("entries", entry_list);
   dict->Set("cache", cache_info_dict);
 
-  SendJavascriptCommand(L"receivedHostResolverInfo", dict);
+  SendJavascriptCommand("receivedHostResolverInfo", dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearHostResolverCache(
     const ListValue* list) {
   net::HostCache* cache =
       GetHostResolverCache(context_getter_->GetURLRequestContext());
 
   if (cache)
     cache->clear();
 
@@ skipping 63 matching lines @@
           std::string b64;
           base::Base64Encode(hash_str, &b64);
           part += b64;
           parts.push_back(part);
         }
         result->SetString("public_key_hashes", JoinString(parts, ','));
       }
     }
   }
 
-  SendJavascriptCommand(L"receivedHSTSResult", result);
+  SendJavascriptCommand("receivedHSTSResult", result);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnHSTSAdd(
     const ListValue* list) {
   // |list| should be: [<domain to query>, <include subdomains>, <cert pins>].
   std::string domain;
   CHECK(list->GetString(0, &domain));
   if (!IsStringASCII(domain)) {
     // Silently fail. The user will get a helpful error if they query for the
     // name.
@@ skipping 67 matching lines @@
     std::vector<std::pair<std::string, std::string> > stats;
     disk_cache->GetStats(&stats);
     for (size_t i = 0; i < stats.size(); ++i) {
       stats_dict->Set(stats[i].first,
                       Value::CreateStringValue(stats[i].second));
     }
   }
 
   info_dict->Set("stats", stats_dict);
 
-  SendJavascriptCommand(L"receivedHttpCacheInfo", info_dict);
+  SendJavascriptCommand("receivedHttpCacheInfo", info_dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSocketPoolInfo(
     const ListValue* list) {
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
   Value* socket_pool_info = NULL;
   if (http_network_session)
     socket_pool_info = http_network_session->SocketPoolInfoToValue();
 
-  SendJavascriptCommand(L"receivedSocketPoolInfo", socket_pool_info);
+  SendJavascriptCommand("receivedSocketPoolInfo", socket_pool_info);
 }
 
 
 void NetInternalsMessageHandler::IOThreadImpl::OnFlushSocketPools(
     const ListValue* list) {
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
   if (http_network_session)
     http_network_session->CloseAllConnections();
@@ skipping 11 matching lines @@
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdySessionInfo(
     const ListValue* list) {
   net::HttpNetworkSession* http_network_session =
       GetHttpNetworkSession(context_getter_->GetURLRequestContext());
 
   Value* spdy_info = NULL;
   if (http_network_session) {
     spdy_info = http_network_session->SpdySessionPoolInfoToValue();
   }
 
-  SendJavascriptCommand(L"receivedSpdySessionInfo", spdy_info);
+  SendJavascriptCommand("receivedSpdySessionInfo", spdy_info);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyStatus(
     const ListValue* list) {
   DictionaryValue* status_dict = new DictionaryValue();
 
   status_dict->Set("spdy_enabled",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::spdy_enabled()));
   status_dict->Set("use_alternate_protocols",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::use_alternate_protocols()));
   status_dict->Set("force_spdy_over_ssl",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::force_spdy_over_ssl()));
   status_dict->Set("force_spdy_always",
                    Value::CreateBooleanValue(
                        net::HttpStreamFactory::force_spdy_always()));
 
   // The next_protos may not be specified for certain configurations of SPDY.
   Value* next_protos_value = net::HttpStreamFactory::next_protos() ?
       Value::CreateStringValue(*net::HttpStreamFactory::next_protos()) :
       Value::CreateStringValue("");
 
   status_dict->Set("next_protos", next_protos_value);
 
-  SendJavascriptCommand(L"receivedSpdyStatus", status_dict);
+  SendJavascriptCommand("receivedSpdyStatus", status_dict);
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnGetSpdyAlternateProtocolMappings(
     const ListValue* list) {
   ListValue* dict_list = new ListValue();
 
   const net::HttpServerProperties& http_server_properties =
       *context_getter_->GetURLRequestContext()->http_server_properties();
 
   const net::AlternateProtocolMap& map =
       http_server_properties.alternate_protocol_map();
 
   for (net::AlternateProtocolMap::const_iterator it = map.begin();
        it != map.end(); ++it) {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("host_port_pair", it->first.ToString());
     dict->SetString("alternate_protocol", it->second.ToString());
     dict_list->Append(dict);
   }
 
-  SendJavascriptCommand(L"receivedSpdyAlternateProtocolMappings", dict_list);
+  SendJavascriptCommand("receivedSpdyAlternateProtocolMappings", dict_list);
 }
 
 #ifdef OS_WIN
 void NetInternalsMessageHandler::IOThreadImpl::OnGetServiceProviders(
     const ListValue* list) {
 
   DictionaryValue* service_providers = new DictionaryValue();
 
   WinsockLayeredServiceProviderList layered_providers;
   GetWinsockLayeredServiceProviders(&layered_providers);
@@ skipping 19 matching lines @@
     DictionaryValue* namespace_dict = new DictionaryValue();
     namespace_dict->SetString("name", namespace_providers[i].name);
     namespace_dict->SetBoolean("active", namespace_providers[i].active);
     namespace_dict->SetInteger("version", namespace_providers[i].version);
     namespace_dict->SetInteger("type", namespace_providers[i].type);
 
     namespace_list->Append(namespace_dict);
   }
   service_providers->Set("namespace_providers", namespace_list);
 
-  SendJavascriptCommand(L"receivedServiceProviders", service_providers);
+  SendJavascriptCommand("receivedServiceProviders", service_providers);
 }
 #endif
 
 #ifdef OS_CHROMEOS
 void NetInternalsMessageHandler::OnRefreshSystemLogs(const ListValue* list) {
   DCHECK(syslogs_getter_.get());
   syslogs_getter_->DeleteSystemLogs();
   syslogs_getter_->LoadSystemLogs();
 }
 
@@ skipping 40 matching lines @@
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&IOThreadImpl::PostPendingEntries, this),
         kNetLogEventDelayMilliseconds);
   }
   pending_entries_->Append(entry);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::PostPendingEntries() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  SendJavascriptCommand(L"receivedLogEntries", pending_entries_.release());
+  SendJavascriptCommand("receivedLogEntries", pending_entries_.release());
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnStartConnectionTestSuite() {
-  SendJavascriptCommand(L"receivedStartConnectionTestSuite", NULL);
+  SendJavascriptCommand("receivedStartConnectionTestSuite", NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnStartConnectionTestExperiment(
     const ConnectionTester::Experiment& experiment) {
   SendJavascriptCommand(
-      L"receivedStartConnectionTestExperiment",
+      "receivedStartConnectionTestExperiment",
       ExperimentToValue(experiment));
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnCompletedConnectionTestExperiment(
     const ConnectionTester::Experiment& experiment,
     int result) {
   DictionaryValue* dict = new DictionaryValue();
 
   dict->Set("experiment", ExperimentToValue(experiment));
   dict->SetInteger("result", result);
 
   SendJavascriptCommand(
-      L"receivedCompletedConnectionTestExperiment",
+      "receivedCompletedConnectionTestExperiment",
       dict);
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnCompletedConnectionTestSuite() {
   SendJavascriptCommand(
-      L"receivedCompletedConnectionTestSuite",
+      "receivedCompletedConnectionTestSuite",
       NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::DispatchToMessageHandler(
     ListValue* arg, MessageHandler method) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   (this->*method)(arg);
   delete arg;
 }
 
 // Note that this can be called from ANY THREAD.
 void NetInternalsMessageHandler::IOThreadImpl::SendJavascriptCommand(
-    const std::wstring& command,
+    const std::string& command,
     Value* arg) {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     if (handler_ && !was_webui_deleted_) {
       // We check |handler_| in case it was deleted on the UI thread earlier
       // while we were running on the IO thread.
       handler_->SendJavascriptCommand(command, arg);
     } else {
       delete arg;
     }
     return;
@@ skipping 168 matching lines @@
   return constants_dict;
 }
 
 NetInternalsUI::NetInternalsUI(TabContents* contents) : ChromeWebUI(contents) {
   AddMessageHandler((new NetInternalsMessageHandler())->Attach(this));
 
   // Set up the chrome://net-internals/ source.
   GetProfile()->GetChromeURLDataManager()->AddDataSource(
       CreateNetInternalsHTMLSource());
 }