Rename DictionaryValue's SetStringFromUTF16() to SetString() (and overload).

chrome/browser/dom_ui/net_internals_ui.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.
 
 #include "chrome/browser/dom_ui/net_internals_ui.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <utility>
@@ skipping 71 matching lines @@
 // Serializes the specified event to a DictionaryValue.
 Value* EntryToDictionaryValue(net::NetLog::EventType type,
                               const base::TimeTicks& time,
                               const net::NetLog::Source& source,
                               net::NetLog::EventPhase phase,
                               net::NetLog::EventParameters* params) {
   DictionaryValue* entry_dict = new DictionaryValue();
 
   // Set the entry time. (Note that we send it as a string since integers
   // might overflow).
-  entry_dict->SetString(L"time", TickCountToString(time));
+  entry_dict->SetString("time", TickCountToString(time));
 
   // Set the entry source.
   DictionaryValue* source_dict = new DictionaryValue();
-  source_dict->SetInteger(L"id", source.id);
-  source_dict->SetInteger(L"type", static_cast<int>(source.type));
-  entry_dict->Set(L"source", source_dict);
+  source_dict->SetInteger("id", source.id);
+  source_dict->SetInteger("type", static_cast<int>(source.type));
+  entry_dict->Set("source", source_dict);
 
   // Set the event info.
-  entry_dict->SetInteger(L"type", static_cast<int>(type));
-  entry_dict->SetInteger(L"phase", static_cast<int>(phase));
+  entry_dict->SetInteger("type", static_cast<int>(type));
+  entry_dict->SetInteger("phase", static_cast<int>(phase));
 
   // Set the event-specific parameters.
   if (params)
-    entry_dict->Set(L"params", params->ToValue());
+    entry_dict->Set("params", params->ToValue());
 
   return entry_dict;
 }
 
 Value* ExperimentToValue(const ConnectionTester::Experiment& experiment) {
   DictionaryValue* dict = new DictionaryValue();
 
   if (experiment.url.is_valid())
-    dict->SetString(L"url", experiment.url.spec());
+    dict->SetString("url", experiment.url.spec());
 
-  dict->SetStringFromUTF16(
-      L"proxy_settings_experiment",
-      ConnectionTester::ProxySettingsExperimentDescription(
-          experiment.proxy_settings_experiment));
-  dict->SetStringFromUTF16(
-      L"host_resolver_experiment",
-      ConnectionTester::HostResolverExperimentDescription(
-          experiment.host_resolver_experiment));
+  dict->SetString("proxy_settings_experiment",
+                  ConnectionTester::ProxySettingsExperimentDescription(
+                      experiment.proxy_settings_experiment));
+  dict->SetString("host_resolver_experiment",
+                  ConnectionTester::HostResolverExperimentDescription(
+                      experiment.host_resolver_experiment));
   return dict;
 }
 
 class NetInternalsHTMLSource : public ChromeURLDataManager::DataSource {
  public:
   NetInternalsHTMLSource();
 
   // Called when the network layer has requested a resource underneath
   // the path we registered.
   virtual void StartDataRequest(const std::string& path,
@@ skipping 354 matching lines @@
     DictionaryValue* dict = new DictionaryValue();
 
     scoped_ptr<FileVersionInfo> version_info(
         chrome::GetChromeVersionInfo());
 
     if (version_info == NULL) {
       DLOG(ERROR) << "Unable to create FileVersionInfo object";
 
     } else {
       // We have everything we need to send the right values.
-      dict->SetString(L"version", version_info->file_version());
-      dict->SetString(L"cl", version_info->last_change());
-      dict->SetStringFromUTF16(L"version_mod",
-          platform_util::GetVersionStringModifier());
+      dict->SetString("version", WideToUTF16Hack(version_info->file_version()));
+      dict->SetString("cl", WideToUTF16Hack(version_info->last_change()));
+      dict->SetString("version_mod", platform_util::GetVersionStringModifier());
 
       if (version_info->is_official_build()) {
-        dict->SetString(L"official",
-            l10n_util::GetString(IDS_ABOUT_VERSION_OFFICIAL));
+        dict->SetString("official",
+            l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_OFFICIAL));
       } else {
-        dict->SetString(L"official",
-            l10n_util::GetString(IDS_ABOUT_VERSION_UNOFFICIAL));
+        dict->SetString("official",
+            l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_UNOFFICIAL));
       }
 
-      dict->SetString(L"command_line",
+      dict->SetString("command_line",
           CommandLine::ForCurrentProcess()->command_line_string());
     }
 
     CallJavascriptFunction(L"g_browser.receivedClientInfo",
                            dict);
   }
 
   // Tell the javascript about the relationship between load flag enums and
   // their symbolic name.
   {
@@ skipping 18 matching lines @@
 #undef NET_ERROR
 
     CallJavascriptFunction(L"g_browser.receivedNetErrorConstants", dict);
   }
 
   // Tell the javascript about the relationship between event phase enums and
   // their symbolic name.
   {
     DictionaryValue* dict = new DictionaryValue();
 
-    dict->SetInteger(L"PHASE_BEGIN", net::NetLog::PHASE_BEGIN);
-    dict->SetInteger(L"PHASE_END", net::NetLog::PHASE_END);
-    dict->SetInteger(L"PHASE_NONE", net::NetLog::PHASE_NONE);
+    dict->SetInteger("PHASE_BEGIN", net::NetLog::PHASE_BEGIN);
+    dict->SetInteger("PHASE_END", net::NetLog::PHASE_END);
+    dict->SetInteger("PHASE_NONE", net::NetLog::PHASE_NONE);
 
     CallJavascriptFunction(L"g_browser.receivedLogEventPhaseConstants", dict);
   }
 
   // Tell the javascript about the relationship between source type enums and
   // their symbolic name.
   {
     DictionaryValue* dict = new DictionaryValue();
 
 #define SOURCE_TYPE(label, value) dict->SetInteger(ASCIIToWide(# label), value);
@@ skipping 72 matching lines @@
       context->proxy_service()->proxy_retry_info();
 
   ListValue* list = new ListValue();
 
   for (net::ProxyRetryInfoMap::const_iterator it = bad_proxies_map.begin();
        it != bad_proxies_map.end(); ++it) {
     const std::string& proxy_uri = it->first;
     const net::ProxyRetryInfo& retry_info = it->second;
 
     DictionaryValue* dict = new DictionaryValue();
-    dict->SetString(L"proxy_uri", proxy_uri);
-    dict->SetString(L"bad_until", TickCountToString(retry_info.bad_until));
+    dict->SetString("proxy_uri", proxy_uri);
+    dict->SetString("bad_until", TickCountToString(retry_info.bad_until));
 
     list->Append(dict);
   }
 
   CallJavascriptFunction(L"g_browser.receivedBadProxies", list);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearBadProxies(
     const Value* value) {
   URLRequestContext* context = context_getter_->GetURLRequestContext();
   context->proxy_service()->ClearBadProxiesCache();
 
   // Cause the renderer to be notified of the new values.
   OnGetBadProxies(NULL);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnGetHostResolverCache(
     const Value* value) {
 
   net::HostCache* cache =
       GetHostResolverCache(context_getter_->GetURLRequestContext());
 
   if (!cache) {
     CallJavascriptFunction(L"g_browser.receivedHostResolverCache", NULL);
     return;
   }
 
   DictionaryValue* dict = new DictionaryValue();
 
-  dict->SetInteger(L"capacity", static_cast<int>(cache->max_entries()));
+  dict->SetInteger("capacity", static_cast<int>(cache->max_entries()));
   dict->SetInteger(
-      L"ttl_success_ms",
+      "ttl_success_ms",
       static_cast<int>(cache->success_entry_ttl().InMilliseconds()));
   dict->SetInteger(
-      L"ttl_failure_ms",
+      "ttl_failure_ms",
       static_cast<int>(cache->failure_entry_ttl().InMilliseconds()));
 
   ListValue* entry_list = new ListValue();
 
   for (net::HostCache::EntryMap::const_iterator it =
        cache->entries().begin();
        it != cache->entries().end();
        ++it) {
     const net::HostCache::Key& key = it->first;
     const net::HostCache::Entry* entry = it->second.get();
 
     DictionaryValue* entry_dict = new DictionaryValue();
 
-    entry_dict->SetString(L"hostname", key.hostname);
-    entry_dict->SetInteger(L"address_family",
+    entry_dict->SetString("hostname", key.hostname);
+    entry_dict->SetInteger("address_family",
         static_cast<int>(key.address_family));
-    entry_dict->SetString(L"expiration", TickCountToString(entry->expiration));
+    entry_dict->SetString("expiration", TickCountToString(entry->expiration));
 
     if (entry->error != net::OK) {
-      entry_dict->SetInteger(L"error", entry->error);
+      entry_dict->SetInteger("error", entry->error);
     } else {
       // Append all of the resolved addresses.
       ListValue* address_list = new ListValue();
       const struct addrinfo* current_address = entry->addrlist.head();
       while (current_address) {
         address_list->Append(Value::CreateStringValue(
             net::NetAddressToStringWithPort(current_address)));
         current_address = current_address->ai_next;
       }
-      entry_dict->Set(L"addresses", address_list);
+      entry_dict->Set("addresses", address_list);
     }
 
     entry_list->Append(entry_dict);
   }
 
-  dict->Set(L"entries", entry_list);
+  dict->Set("entries", entry_list);
 
   CallJavascriptFunction(L"g_browser.receivedHostResolverCache", dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnClearHostResolverCache(
     const Value* value) {
   net::HostCache* cache =
       GetHostResolverCache(context_getter_->GetURLRequestContext());
 
   if (cache)
@@ skipping 51 matching lines @@
   if (disk_cache) {
     // Extract the statistics key/value pairs from the backend.
     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(ASCIIToWide(stats[i].first),
                       Value::CreateStringValue(stats[i].second));
     }
   }
 
-  info_dict->Set(L"stats", stats_dict);
+  info_dict->Set("stats", stats_dict);
 
   CallJavascriptFunction(L"g_browser.receivedHttpCacheInfo", info_dict);
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::OnAddEntry(
     net::NetLog::EventType type,
     const base::TimeTicks& time,
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
@@ skipping 14 matching lines @@
       L"g_browser.receivedStartConnectionTestExperiment",
       ExperimentToValue(experiment));
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnCompletedConnectionTestExperiment(
     const ConnectionTester::Experiment& experiment,
     int result) {
   DictionaryValue* dict = new DictionaryValue();
 
-  dict->Set(L"experiment", ExperimentToValue(experiment));
-  dict->SetInteger(L"result", result);
+  dict->Set("experiment", ExperimentToValue(experiment));
+  dict->SetInteger("result", result);
 
   CallJavascriptFunction(
       L"g_browser.receivedCompletedConnectionTestExperiment",
       dict);
 }
 
 void
 NetInternalsMessageHandler::IOThreadImpl::OnCompletedConnectionTestSuite() {
   CallJavascriptFunction(
       L"g_browser.receivedCompletedConnectionTestSuite",
@@ skipping 50 matching lines @@
   NetInternalsHTMLSource* html_source = new NetInternalsHTMLSource();
 
   // Set up the chrome://net-internals/ source.
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(
           Singleton<ChromeURLDataManager>::get(),
           &ChromeURLDataManager::AddDataSource,
           make_scoped_refptr(html_source)));
 }