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

net/base/sdch_filter.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 <limits.h>
 #include <ctype.h>
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 13 matching lines @@
       dest_buffer_excess_index_(0),
       source_bytes_(0),
       output_bytes_(0),
       possible_pass_through_(false) {
 }
 
 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()) {
     if (!vcdiff_streaming_decoder_->FinishDecoding()) {
       decoding_status_ = DECODING_ERROR;
       SdchManager::SdchErrorRecovery(SdchManager::INCOMPLETE_SDCH_CONTENT);
       // Make it possible for the user to hit reload, and get non-sdch content.
       // Note this will "wear off" quickly enough, and is just meant to assure
       // in some rare case that the user is not stuck.
       SdchManager::BlacklistDomain(url());
     }
   }
 
   if (!was_cached()
       && base::Time() != connect_time()
       && read_times_.size() > 0) {
     base::TimeDelta duration = read_times_.back() - connect_time();
     // We clip our logging at 10 minutes to prevent anamolous data from being
     // 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());
       }
     }
   }
 
   if (dictionary_)
     dictionary_->Release();
 }
 
 bool SdchFilter::InitDecoding(Filter::FilterType filter_type) {
@@ skipping 214 matching lines @@
   memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_,
          amount);
   dest_buffer_excess_index_ += amount;
   if (dest_buffer_excess_.size() <= dest_buffer_excess_index_) {
     DCHECK(dest_buffer_excess_.size() == dest_buffer_excess_index_);
     dest_buffer_excess_.clear();
     dest_buffer_excess_index_ = 0;
   }
   return amount;
 }