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

net/disk_cache/backend_impl.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 "net/disk_cache/backend_impl.h"
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 258 matching lines @@
   EntryImpl* cache_entry = MatchEntry(key, hash, false);
   if (!cache_entry) {
     stats_.OnEvent(Stats::OPEN_MISS);
     return false;
   }
 
   eviction_.OnOpenEntry(cache_entry);
   DCHECK(entry);
   *entry = cache_entry;
 
-  UMA_HISTOGRAM_TIMES(L"DiskCache.OpenTime", Time::Now() - start);
+  UMA_HISTOGRAM_TIMES("DiskCache.OpenTime", Time::Now() - start);
   stats_.OnEvent(Stats::OPEN_HIT);
   return true;
 }
 
 bool BackendImpl::CreateEntry(const std::string& key, Entry** entry) {
   if (disabled_ || key.empty())
     return false;
 
   Time start = Time::Now();
   uint32 hash = Hash(key);
@@ skipping 52 matching lines @@
   data_->header.num_entries++;
   DCHECK(data_->header.num_entries > 0);
   eviction_.OnCreateEntry(cache_entry);
   if (!parent.get())
     data_->table[hash & mask_] = entry_address.value();
 
   DCHECK(entry);
   *entry = NULL;
   cache_entry.swap(reinterpret_cast<EntryImpl**>(entry));
 
-  UMA_HISTOGRAM_TIMES(L"DiskCache.CreateTime", Time::Now() - start);
+  UMA_HISTOGRAM_TIMES("DiskCache.CreateTime", Time::Now() - start);
   stats_.OnEvent(Stats::CREATE_HIT);
   Trace("create entry hit ");
   return true;
 }
 
 bool BackendImpl::DoomEntry(const std::string& key) {
   if (disabled_)
     return false;
 
   Entry* entry;
@@ skipping 281 matching lines @@
   // Setting the index table length to an invalid value will force re-creation
   // of the cache files.
   data_->header.table_len = 1;
   disabled_ = true;
 
   if (!num_refs_)
     RestartCache();
 }
 
 void BackendImpl::ReportError(int error) {
-  static LinearHistogram counter(L"DiskCache.Error", 0, 49, 50);
+  static LinearHistogram counter("DiskCache.Error", 0, 49, 50);
   counter.SetFlags(kUmaTargetedHistogramFlag);
 
   // We transmit positive numbers, instead of direct error codes.
   DCHECK(error <= 0);
   counter.Add(error * -1);
 }
 
 void BackendImpl::OnEvent(Stats::Counters an_event) {
   stats_.OnEvent(an_event);
 }
 
 void BackendImpl::OnStatsTimer() {
   stats_.OnEvent(Stats::TIMER);
   int64 current = stats_.GetCounter(Stats::OPEN_ENTRIES);
   int64 time = stats_.GetCounter(Stats::TIMER);
 
   current = current * (time - 1) + num_refs_;
   current /= time;
   stats_.SetCounter(Stats::OPEN_ENTRIES, current);
   stats_.SetCounter(Stats::MAX_ENTRIES, max_refs_);
 
   static bool first_time = true;
   if (!data_)
     first_time = false;
   if (first_time) {
     first_time = false;
     int experiment = data_->header.experiment;
-    std::wstring entries(StringPrintf(L"DiskCache.Entries_%d", experiment));
-    std::wstring size(StringPrintf(L"DiskCache.Size_%d", experiment));
-    std::wstring max_size(StringPrintf(L"DiskCache.MaxSize_%d", experiment));
+    std::string entries(StringPrintf("DiskCache.Entries_%d", experiment));
+    std::string size(StringPrintf("DiskCache.Size_%d", experiment));
+    std::string max_size(StringPrintf("DiskCache.MaxSize_%d", experiment));
     UMA_HISTOGRAM_COUNTS(entries.c_str(), data_->header.num_entries);
     UMA_HISTOGRAM_COUNTS(size.c_str(), data_->header.num_bytes / (1024 * 1024));
     UMA_HISTOGRAM_COUNTS(max_size.c_str(), max_size_ / (1024 * 1024));
   }
 }
 
 void BackendImpl::IncrementIoCount() {
   num_pending_io_++;
 }
 
@@ skipping 458 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache