Port DictionaryValue to use string16 instead of wstring.

chrome/browser/metrics/metrics_service.cc

 // Copyright (c) 2006-2008 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.
 
 
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
@@ skipping 1657 matching lines @@
   DCHECK(plugins);
 
   for (ListValue::iterator value_iter = plugins->begin();
        value_iter != plugins->end(); ++value_iter) {
     if (!(*value_iter)->IsType(Value::TYPE_DICTIONARY)) {
       NOTREACHED();
       continue;
     }
 
     DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*value_iter);
-    std::wstring plugin_name;
-    plugin_dict->GetString(prefs::kStabilityPluginName, &plugin_name);
+    string16 plugin_name;
+    plugin_dict->GetString(WideToUTF16Hack(prefs::kStabilityPluginName),
+                           &plugin_name);
     if (plugin_name.empty()) {
       NOTREACHED();
       continue;
     }
 
-    if (child_process_stats_buffer_.find(plugin_name) ==
+    if (child_process_stats_buffer_.find(UTF16ToWideHack(plugin_name)) ==
         child_process_stats_buffer_.end())
       continue;
 
-    ChildProcessStats stats = child_process_stats_buffer_[plugin_name];
+    ChildProcessStats stats =
+        child_process_stats_buffer_[UTF16ToWideHack(plugin_name)];
     if (stats.process_launches) {
       int launches = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches);
+      plugin_dict->GetInteger(WideToUTF16Hack(prefs::kStabilityPluginLaunches),
+                              &launches);
       launches += stats.process_launches;
-      plugin_dict->SetInteger(prefs::kStabilityPluginLaunches, launches);
+      plugin_dict->SetInteger(WideToUTF16Hack(prefs::kStabilityPluginLaunches),
+                              launches);
     }
     if (stats.process_crashes) {
       int crashes = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes);
+      plugin_dict->GetInteger(WideToUTF16Hack(prefs::kStabilityPluginCrashes),
+                              &crashes);
       crashes += stats.process_crashes;
-      plugin_dict->SetInteger(prefs::kStabilityPluginCrashes, crashes);
+      plugin_dict->SetInteger(WideToUTF16Hack(prefs::kStabilityPluginCrashes),
+                              crashes);
     }
     if (stats.instances) {
       int instances = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances);
+      plugin_dict->GetInteger(WideToUTF16Hack(prefs::kStabilityPluginInstances),
+                              &instances);
       instances += stats.instances;
-      plugin_dict->SetInteger(prefs::kStabilityPluginInstances, instances);
+      plugin_dict->SetInteger(WideToUTF16Hack(prefs::kStabilityPluginInstances),
+                              instances);
     }
 
-    child_process_stats_buffer_.erase(plugin_name);
+    child_process_stats_buffer_.erase(UTF16ToWideHack(plugin_name));
   }
 
   // Now go through and add dictionaries for plugins that didn't already have
   // reports in Local State.
   for (std::map<std::wstring, ChildProcessStats>::iterator cache_iter =
            child_process_stats_buffer_.begin();
        cache_iter != child_process_stats_buffer_.end(); ++cache_iter) {
     std::wstring plugin_name = cache_iter->first;
     ChildProcessStats stats = cache_iter->second;
     DictionaryValue* plugin_dict = new DictionaryValue;
 
-    plugin_dict->SetString(prefs::kStabilityPluginName, plugin_name);
-    plugin_dict->SetInteger(prefs::kStabilityPluginLaunches,
+    plugin_dict->SetString(WideToUTF16Hack(prefs::kStabilityPluginName),
+                           WideToUTF16Hack(plugin_name));
+    plugin_dict->SetInteger(WideToUTF16Hack(prefs::kStabilityPluginLaunches),
                             stats.process_launches);
-    plugin_dict->SetInteger(prefs::kStabilityPluginCrashes,
+    plugin_dict->SetInteger(WideToUTF16Hack(prefs::kStabilityPluginCrashes),
                             stats.process_crashes);
-    plugin_dict->SetInteger(prefs::kStabilityPluginInstances,
+    plugin_dict->SetInteger(WideToUTF16Hack(prefs::kStabilityPluginInstances),
                             stats.instances);
     plugins->Append(plugin_dict);
   }
   child_process_stats_buffer_.clear();
 }
 
 bool MetricsService::CanLogNotification(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   // We simply don't log anything to UMA if there is a single off the record
@@ skipping 91 matching lines @@
   // The id is most likely an email address. We shouldn't send it to the server.
   const std::wstring id_hash =
       UTF8ToWide(MetricsLog::CreateBase64Hash(WideToUTF8(profile->GetID())));
   DCHECK(id_hash.find('.') == std::string::npos);
 
   DictionaryValue* prof_prefs = prefs->GetMutableDictionary(
       prefs::kProfileMetrics);
   DCHECK(prof_prefs);
   const std::wstring pref_key = std::wstring(prefs::kProfilePrefix) + id_hash +
       L"." + key;
-  prof_prefs->SetInteger(pref_key.c_str(), value);
+  prof_prefs->SetInteger(WideToUTF16Hack(pref_key), value);
 }
 
 static bool IsSingleThreaded() {
   static PlatformThreadId thread_id = 0;
   if (!thread_id)
     thread_id = PlatformThread::CurrentId();
   return PlatformThread::CurrentId() == thread_id;
 }