Use string for Histogram names since these are all ASCII anyway.

Wide-character literals cause problems between platforms.

Review URL: http://codereview.chromium.org/28046

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@10276 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 27 insertions, 30 deletions

diff --git a/net/base/connection_type_histograms.cc b/net/base/connection_type_histograms.cc
index a5c6610..6e4a929 100644
--- a/net/base/connection_type_histograms.cc
+++ b/net/base/connection_type_histograms.cc
@@ -22,10 +22,10 @@ namespace net {
 // expansion.
 void UpdateConnectionTypeHistograms(ConnectionType type) {
   static bool had_connection_type[NUM_OF_CONNECTION_TYPES];
-  static LinearHistogram counter1(L"Net.HadConnectionType",
+  static LinearHistogram counter1("Net.HadConnectionType",
                                   1, NUM_OF_CONNECTION_TYPES,
                                   NUM_OF_CONNECTION_TYPES + 1);
-  static LinearHistogram counter2(L"Net.ConnectionTypeCount",
+  static LinearHistogram counter2("Net.ConnectionTypeCount",
                                   1, NUM_OF_CONNECTION_TYPES,
                                   NUM_OF_CONNECTION_TYPES + 1);
 
diff --git a/net/base/file_stream_win.cc b/net/base/file_stream_win.cc
index 1ab71df..0a6c201 100644
--- a/net/base/file_stream_win.cc
+++ b/net/base/file_stream_win.cc
@@ -78,7 +78,7 @@ FileStream::AsyncContext::~AsyncContext() {
   }
   if (waited) {
     // We want to see if we block the message loop for too long.
-    UMA_HISTOGRAM_TIMES(L"AsyncIO.FileStreamClose", base::Time::Now() - start);
+    UMA_HISTOGRAM_TIMES("AsyncIO.FileStreamClose", base::Time::Now() - start);
   }
 }
 
@@ -288,4 +288,3 @@ int FileStream::Write(
 }
 
 }  // namespace net
-
diff --git a/net/base/mime_sniffer.cc b/net/base/mime_sniffer.cc
index da117e2..d982f85 100644
--- a/net/base/mime_sniffer.cc
+++ b/net/base/mime_sniffer.cc
@@ -103,7 +103,7 @@ namespace {
 
 class SnifferHistogram : public LinearHistogram {
  public:
-  SnifferHistogram(const wchar_t* name, int array_size)
+  SnifferHistogram(const char* name, int array_size)
       : LinearHistogram(name, 0, array_size - 1, array_size) {
     SetFlags(kUmaTargetedHistogramFlag);
   }
@@ -273,7 +273,7 @@ static bool SniffForHTML(const char* content, size_t size,
     if (!IsAsciiWhitespace(*pos))
       break;
   }
-  static SnifferHistogram counter(L"mime_sniffer.kSniffableTags2",
+  static SnifferHistogram counter("mime_sniffer.kSniffableTags2",
                                   arraysize(kSniffableTags));
   // |pos| now points to first non-whitespace character (or at end).
   return CheckForMagicNumbers(pos, end - pos,
@@ -284,7 +284,7 @@ static bool SniffForHTML(const char* content, size_t size,
 static bool SniffForMagicNumbers(const char* content, size_t size,
                                  std::string* result) {
   // Check our big table of Magic Numbers
-  static SnifferHistogram counter(L"mime_sniffer.kMagicNumbers2",
+  static SnifferHistogram counter("mime_sniffer.kMagicNumbers2",
                                   arraysize(kMagicNumbers));
   return CheckForMagicNumbers(content, size,
                               kMagicNumbers, arraysize(kMagicNumbers),
@@ -320,7 +320,7 @@ static bool SniffXML(const char* content, size_t size, std::string* result) {
   // We want to skip XML processing instructions (of the form "<?xml ...")
   // and stop at the first "plain" tag, then make a decision on the mime-type
   // based on the name (or possibly attributes) of that tag.
-  static SnifferHistogram counter(L"mime_sniffer.kMagicXML2",
+  static SnifferHistogram counter("mime_sniffer.kMagicXML2",
                                   arraysize(kMagicXML));
   const int kMaxTagIterations = 5;
   for (int i = 0; i < kMaxTagIterations && pos < end; ++i) {
@@ -387,7 +387,7 @@ static char kByteLooksBinary[] = {
 
 static bool LooksBinary(const char* content, size_t size) {
   // First, we look for a BOM.
-  static SnifferHistogram counter(L"mime_sniffer.kByteOrderMark2",
+  static SnifferHistogram counter("mime_sniffer.kByteOrderMark2",
                                   arraysize(kByteOrderMark));
   std::string unused;
   if (CheckForMagicNumbers(content, size,
@@ -421,7 +421,7 @@ static bool IsUnknownMimeType(const std::string& mime_type) {
     // Firefox rejects a mime type if it is exactly */*
     "*/*",
   };
-  static SnifferHistogram counter(L"mime_sniffer.kUnknownMimeTypes2",
+  static SnifferHistogram counter("mime_sniffer.kUnknownMimeTypes2",
                                   arraysize(kUnknownMimeTypes) + 1);
   for (size_t i = 0; i < arraysize(kUnknownMimeTypes); ++i) {
     if (mime_type == kUnknownMimeTypes[i]) {
@@ -439,7 +439,7 @@ static bool IsUnknownMimeType(const std::string& mime_type) {
 
 bool ShouldSniffMimeType(const GURL& url, const std::string& mime_type) {
   static SnifferHistogram should_sniff_counter(
-      L"mime_sniffer.ShouldSniffMimeType2", 3);
+      "mime_sniffer.ShouldSniffMimeType2", 3);
   // We are willing to sniff the mime type for HTTP, HTTPS, and FTP
   bool sniffable_scheme = url.is_empty() ||
                           url.SchemeIs("http") ||
@@ -463,7 +463,7 @@ bool ShouldSniffMimeType(const GURL& url, const std::string& mime_type) {
     "text/xml",
     "application/xml",
   };
-  static SnifferHistogram counter(L"mime_sniffer.kSniffableTypes2",
+  static SnifferHistogram counter("mime_sniffer.kSniffableTypes2",
                                   arraysize(kSniffableTypes) + 1);
   for (size_t i = 0; i < arraysize(kSniffableTypes); ++i) {
     if (mime_type == kSniffableTypes[i]) {
@@ -555,4 +555,3 @@ bool SniffMimeType(const char* content, size_t content_size,
 }
 
 }  // namespace net
-
diff --git a/net/base/sdch_filter.cc b/net/base/sdch_filter.cc
index 37d5871..9309de6 100644
--- a/net/base/sdch_filter.cc
+++ b/net/base/sdch_filter.cc
@@ -31,7 +31,7 @@ SdchFilter::~SdchFilter() {
   static int filter_use_count = 0;
   ++filter_use_count;
   if (META_REFRESH_RECOVERY == decoding_status_) {
-    UMA_HISTOGRAM_COUNTS(L"Sdch.FilterUseBeforeDisabling", filter_use_count);
+    UMA_HISTOGRAM_COUNTS("Sdch.FilterUseBeforeDisabling", filter_use_count);
   }
 
   if (vcdiff_streaming_decoder_.get()) {
@@ -53,46 +53,46 @@ SdchFilter::~SdchFilter() {
     // considered (per suggestion from Jake Brutlag).
     if (10 >= duration.InMinutes()) {
       if (DECODING_IN_PROGRESS == decoding_status_) {
-        UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Decode_Latency_F", duration,
+        UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Decode_Latency_F", duration,
                                     base::TimeDelta::FromMilliseconds(20),
                                     base::TimeDelta::FromMinutes(10), 100);
-        UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Decode_1st_To_Last",
+        UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Decode_1st_To_Last",
                                     read_times_.back() - read_times_[0],
                                     base::TimeDelta::FromMilliseconds(20),
                                     base::TimeDelta::FromMinutes(10), 100);
         if (read_times_.size() > 3) {
-          UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Decode_3rd_To_4th",
+          UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Decode_3rd_To_4th",
                                       read_times_[3] - read_times_[2],
                                       base::TimeDelta::FromMilliseconds(10),
                                       base::TimeDelta::FromSeconds(3), 100);
-          UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Decode_2nd_To_3rd",
+          UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Decode_2nd_To_3rd",
                                       read_times_[2] - read_times_[1],
                                       base::TimeDelta::FromMilliseconds(10),
                                       base::TimeDelta::FromSeconds(3), 100);
         }
-        UMA_HISTOGRAM_COUNTS_100(L"Sdch.Network_Decode_Reads",
+        UMA_HISTOGRAM_COUNTS_100("Sdch.Network_Decode_Reads",
                                  read_times_.size());
-        UMA_HISTOGRAM_COUNTS(L"Sdch.Network_Decode_Bytes_Read", output_bytes_);
+        UMA_HISTOGRAM_COUNTS("Sdch.Network_Decode_Bytes_Read", output_bytes_);
       } else if (PASS_THROUGH == decoding_status_) {
-        UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Pass-through_Latency_F",
+        UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Pass-through_Latency_F",
                                     duration,
                                     base::TimeDelta::FromMilliseconds(20),
                                     base::TimeDelta::FromMinutes(10), 100);
-        UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Pass-through_1st_To_Last",
+        UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Pass-through_1st_To_Last",
                                     read_times_.back() - read_times_[0],
                                     base::TimeDelta::FromMilliseconds(20),
                                     base::TimeDelta::FromMinutes(10), 100);
         if (read_times_.size() > 3) {
-          UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Pass-through_3rd_To_4th",
+          UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Pass-through_3rd_To_4th",
                                       read_times_[3] - read_times_[2],
                                       base::TimeDelta::FromMilliseconds(10),
                                       base::TimeDelta::FromSeconds(3), 100);
-          UMA_HISTOGRAM_CLIPPED_TIMES(L"Sdch.Network_Pass-through_2nd_To_3rd",
+          UMA_HISTOGRAM_CLIPPED_TIMES("Sdch.Network_Pass-through_2nd_To_3rd",
                                       read_times_[2] - read_times_[1],
                                       base::TimeDelta::FromMilliseconds(10),
                                       base::TimeDelta::FromSeconds(3), 100);
         }
-        UMA_HISTOGRAM_COUNTS_100(L"Sdch.Network_Pass-through_Reads",
+        UMA_HISTOGRAM_COUNTS_100("Sdch.Network_Pass-through_Reads",
                                  read_times_.size());
       }
     }
diff --git a/net/base/sdch_manager.cc b/net/base/sdch_manager.cc
index 1f1ff0a..de17905 100644
--- a/net/base/sdch_manager.cc
+++ b/net/base/sdch_manager.cc
@@ -32,7 +32,7 @@ SdchManager* SdchManager::Global() {
 
 // static
 void SdchManager::SdchErrorRecovery(ProblemCodes problem) {
-  static LinearHistogram histogram(L"Sdch.ProblemCodes_2", MIN_PROBLEM_CODE,
+  static LinearHistogram histogram("Sdch.ProblemCodes_2", MIN_PROBLEM_CODE,
                                    MAX_PROBLEM_CODE - 1, MAX_PROBLEM_CODE);
   histogram.SetFlags(kUmaTargetedHistogramFlag);
   histogram.Add(problem);
@@ -263,7 +263,7 @@ bool SdchManager::AddSdchDictionary(const std::string& dictionary_text,
     return false;
   }
 
-  UMA_HISTOGRAM_COUNTS(L"Sdch.Dictionary size loaded", dictionary_text.size());
+  UMA_HISTOGRAM_COUNTS("Sdch.Dictionary size loaded", dictionary_text.size());
   DLOG(INFO) << "Loaded dictionary with client hash " << client_hash <<
       " and server hash " << server_hash;
   Dictionary* dictionary =
@@ -304,7 +304,7 @@ void SdchManager::GetAvailDictionaryList(const GURL& target_url,
   }
   // Watch to see if we have corrupt or numerous dictionaries.
   if (count > 0)
-    UMA_HISTOGRAM_COUNTS(L"Sdch.Advertisement_Count", count);
+    UMA_HISTOGRAM_COUNTS("Sdch.Advertisement_Count", count);
 }
 
 SdchManager::Dictionary::Dictionary(const std::string& dictionary_text,
diff --git a/net/base/x509_certificate.cc b/net/base/x509_certificate.cc
index 4a7a9e4..3565567 100644
--- a/net/base/x509_certificate.cc
+++ b/net/base/x509_certificate.cc
@@ -139,7 +139,7 @@ X509Certificate* X509Certificate::CreateFromHandle(OSCertHandle cert_handle,
       // We've found a certificate with the same fingerprint in our cache.  We
       // own the |cert_handle|, which makes it our job to free it.
       FreeOSCertHandle(cert_handle);
-      DHISTOGRAM_COUNTS(L"X509CertificateReuseCount", 1);
+      DHISTOGRAM_COUNTS("X509CertificateReuseCount", 1);
       return cached_cert;
     }
     // Kick out the old certificate from our cache.  The new one is better.
@@ -193,4 +193,3 @@ bool X509Certificate::IsEV(int status) const {
 #endif
 
 }  // namespace net
-