Port DictionaryValue to use string16 instead of wstring.

chrome/browser/metrics/metrics_log.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.
 
 #include "chrome/browser/metrics/metrics_log.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/md5.h"
@@ skipping 365 matching lines @@
   if (plugin_stats_list) {
     OPEN_ELEMENT_FOR_SCOPE("plugins");
     for (ListValue::const_iterator iter = plugin_stats_list->begin();
          iter != plugin_stats_list->end(); ++iter) {
       if (!(*iter)->IsType(Value::TYPE_DICTIONARY)) {
         NOTREACHED();
         continue;
       }
       DictionaryValue* plugin_dict = static_cast<DictionaryValue*>(*iter);
 
-      std::wstring plugin_name;
-      plugin_dict->GetString(prefs::kStabilityPluginName, &plugin_name);
+      string16 plugin_name;
+      plugin_dict->GetString(WideToUTF16Hack(prefs::kStabilityPluginName),
+                             &plugin_name);
 
       OPEN_ELEMENT_FOR_SCOPE("pluginstability");
       // Use "filename" instead of "name", otherwise we need to update the
       // UMA servers.
-      WriteAttribute("filename", CreateBase64Hash(WideToUTF8(plugin_name)));
+      WriteAttribute("filename", CreateBase64Hash(UTF16ToUTF8(plugin_name)));
 
       int launches = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginLaunches, &launches);
+      plugin_dict->GetInteger(WideToUTF16Hack(prefs::kStabilityPluginLaunches),
+                              &launches);
       WriteIntAttribute("launchcount", launches);
 
       int instances = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginInstances, &instances);
+      plugin_dict->GetInteger(WideToUTF16Hack(prefs::kStabilityPluginInstances),
+                              &instances);
       WriteIntAttribute("instancecount", instances);
 
       int crashes = 0;
-      plugin_dict->GetInteger(prefs::kStabilityPluginCrashes, &crashes);
+      plugin_dict->GetInteger(WideToUTF16Hack(prefs::kStabilityPluginCrashes),
+                              &crashes);
       WriteIntAttribute("crashcount", crashes);
     }
 
     pref->ClearPref(prefs::kStabilityPluginStats);
   }
 }
 
 void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) {
   // The server refuses data that doesn't have certain values.  crashcount and
   // launchcount are currently "required" in the "stability" group.
@@ skipping 147 matching lines @@
 
   if (profile_metrics)
     WriteAllProfilesMetrics(*profile_metrics);
 }
 
 void MetricsLog::WriteAllProfilesMetrics(
     const DictionaryValue& all_profiles_metrics) {
   const std::wstring profile_prefix(prefs::kProfilePrefix);
   for (DictionaryValue::key_iterator i = all_profiles_metrics.begin_keys();
        i != all_profiles_metrics.end_keys(); ++i) {
-    const std::wstring& key_name = *i;
+    const string16 key_name16 = *i;
+    const std::wstring& key_name = UTF16ToWideHack(key_name16);
     if (key_name.compare(0, profile_prefix.size(), profile_prefix) == 0) {
       DictionaryValue* profile;
-      if (all_profiles_metrics.GetDictionary(key_name, &profile))
+      if (all_profiles_metrics.GetDictionary(key_name16, &profile))
         WriteProfileMetrics(key_name.substr(profile_prefix.size()), *profile);
     }
   }
 }
 
 void MetricsLog::WriteProfileMetrics(const std::wstring& profileidhash,
                                      const DictionaryValue& profile_metrics) {
   OPEN_ELEMENT_FOR_SCOPE("userprofile");
   WriteAttribute("profileidhash", WideToUTF8(profileidhash));
   for (DictionaryValue::key_iterator i = profile_metrics.begin_keys();
        i != profile_metrics.end_keys(); ++i) {
     Value* value;
     if (profile_metrics.Get(*i, &value)) {
-      DCHECK(*i != L"id");
+      DCHECK(*i != ASCIIToUTF16("id"));
       switch (value->GetType()) {
         case Value::TYPE_STRING: {
           std::string string_value;
           if (value->GetAsString(&string_value)) {
             OPEN_ELEMENT_FOR_SCOPE("profileparam");
-            WriteAttribute("name", WideToUTF8(*i));
+            WriteAttribute("name", UTF16ToUTF8(*i));
             WriteAttribute("value", string_value);
           }
           break;
         }
 
         case Value::TYPE_BOOLEAN: {
           bool bool_value;
           if (value->GetAsBoolean(&bool_value)) {
             OPEN_ELEMENT_FOR_SCOPE("profileparam");
-            WriteAttribute("name", WideToUTF8(*i));
+            WriteAttribute("name", UTF16ToUTF8(*i));
             WriteIntAttribute("value", bool_value ? 1 : 0);
           }
           break;
         }
 
         case Value::TYPE_INTEGER: {
           int int_value;
           if (value->GetAsInteger(&int_value)) {
             OPEN_ELEMENT_FOR_SCOPE("profileparam");
-            WriteAttribute("name", WideToUTF8(*i));
+            WriteAttribute("name", UTF16ToUTF8(*i));
             WriteIntAttribute("value", int_value);
           }
           break;
         }
 
         default:
           NOTREACHED();
           break;
       }
     }
@@ skipping 59 matching lines @@
 
   for (size_t i = 0; i < histogram.bucket_count(); i++) {
     if (snapshot.counts(i)) {
       OPEN_ELEMENT_FOR_SCOPE("histogrambucket");
       WriteIntAttribute("min", histogram.ranges(i));
       WriteIntAttribute("max", histogram.ranges(i + 1));
       WriteIntAttribute("count", snapshot.counts(i));
     }
   }
 }