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

chrome/browser/net/dns_host_info.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.
 
 // See header file for description of class
 
 #include "chrome/browser/net/dns_host_info.h"
 
 #include <math.h>
 
@@ skipping 71 matching lines @@
   SetMotivation(motivation);
   GetDuration();  // Set time_
   DLogResultsStats("DNS Prefetch in queue");
 }
 
 void DnsHostInfo::SetAssignedState() {
   DCHECK(QUEUED == state_);
   state_ = ASSIGNED;
   queue_duration_ = GetDuration();
   DLogResultsStats("DNS Prefetch assigned");
-  UMA_HISTOGRAM_TIMES(L"DNS.PrefetchQueue", queue_duration_);
+  UMA_HISTOGRAM_TIMES("DNS.PrefetchQueue", queue_duration_);
 }
 
 void DnsHostInfo::SetPendingDeleteState() {
   DCHECK(ASSIGNED == state_  || ASSIGNED_BUT_MARKED == state_);
   state_ = ASSIGNED_BUT_MARKED;
 }
 
 void DnsHostInfo::SetFoundState() {
   DCHECK(ASSIGNED == state_);
   state_ = FOUND;
   resolve_duration_ = GetDuration();
   if (kMaxNonNetworkDnsLookupDuration <= resolve_duration_) {
-    UMA_HISTOGRAM_LONG_TIMES(L"DNS.PrefetchFoundNameL", resolve_duration_);
+    UMA_HISTOGRAM_LONG_TIMES("DNS.PrefetchFoundNameL", resolve_duration_);
     // Record potential beneficial time, and maybe we'll get a cache hit.
     // We keep the maximum, as the warming we did earlier may still be
     // helping with a cache upstream in DNS resolution.
     benefits_remaining_ = std::max(resolve_duration_, benefits_remaining_);
   }
   sequence_number_ = sequence_counter++;
   DLogResultsStats("DNS PrefetchFound");
 }
 
 void DnsHostInfo::SetNoSuchNameState() {
   DCHECK(ASSIGNED == state_);
   state_ = NO_SUCH_NAME;
   resolve_duration_ = GetDuration();
   if (kMaxNonNetworkDnsLookupDuration <= resolve_duration_) {
-    DHISTOGRAM_TIMES(L"DNS.PrefetchNotFoundName", resolve_duration_);
+    DHISTOGRAM_TIMES("DNS.PrefetchNotFoundName", resolve_duration_);
     // Record potential beneficial time, and maybe we'll get a cache hit.
     benefits_remaining_ = std::max(resolve_duration_, benefits_remaining_);
   }
   sequence_number_ = sequence_counter++;
   DLogResultsStats("DNS PrefetchNotFound");
 }
 
 void DnsHostInfo::SetStartedState() {
   DCHECK(PENDING == state_);
   state_ = STARTED;
@@ skipping 38 matching lines @@
 // Compare the actual navigation DNS latency found in navigation_info, to the
 // previously prefetched info.
 DnsBenefit DnsHostInfo::AccruePrefetchBenefits(DnsHostInfo* navigation_info) {
   DCHECK(FINISHED == navigation_info->state_ ||
          FINISHED_UNRESOLVED == navigation_info->state_);
   DCHECK(0 == navigation_info->hostname_.compare(hostname_.data()));
 
   if ((0 == benefits_remaining_.InMilliseconds()) ||
       (FOUND != state_ && NO_SUCH_NAME != state_)) {
     if (FINISHED == navigation_info->state_)
-      UMA_HISTOGRAM_LONG_TIMES(L"DNS.IndependentNavigation",
+      UMA_HISTOGRAM_LONG_TIMES("DNS.IndependentNavigation",
                                navigation_info->resolve_duration_);
     else
-      UMA_HISTOGRAM_LONG_TIMES(L"DNS.IndependentFailedNavigation",
+      UMA_HISTOGRAM_LONG_TIMES("DNS.IndependentFailedNavigation",
                                navigation_info->resolve_duration_);
     return PREFETCH_NO_BENEFIT;
   }
 
   TimeDelta benefit = benefits_remaining_ - navigation_info->resolve_duration_;
   navigation_info->benefits_remaining_ = benefits_remaining_;
   benefits_remaining_ = TimeDelta();  // We used up all our benefits here.
 
   navigation_info->motivation_ = motivation_;
   if (LEARNED_REFERAL_MOTIVATED == motivation_ ||
       STATIC_REFERAL_MOTIVATED == motivation_)
     navigation_info->referring_hostname_ = referring_hostname_;
 
   if (navigation_info->resolve_duration_ > kMaxNonNetworkDnsLookupDuration) {
     // Our precache effort didn't help since HTTP stack hit the network.
-    UMA_HISTOGRAM_LONG_TIMES(L"DNS.PrefetchCacheEvictionL", resolve_duration_);
+    UMA_HISTOGRAM_LONG_TIMES("DNS.PrefetchCacheEvictionL", resolve_duration_);
     DLogResultsStats("DNS PrefetchCacheEviction");
     return PREFETCH_CACHE_EVICTION;
   }
 
   if (NO_SUCH_NAME == state_) {
-    UMA_HISTOGRAM_LONG_TIMES(L"DNS.PrefetchNegativeHitL", benefit);
+    UMA_HISTOGRAM_LONG_TIMES("DNS.PrefetchNegativeHitL", benefit);
     DLogResultsStats("DNS PrefetchNegativeHit");
     return PREFETCH_NAME_NONEXISTANT;
   }
 
   DCHECK_EQ(FOUND, state_);
   if (LEARNED_REFERAL_MOTIVATED == motivation_ ||
       STATIC_REFERAL_MOTIVATED == motivation_) {
-    UMA_HISTOGRAM_TIMES(L"DNS.PrefetchReferredPositiveHit", benefit);
+    UMA_HISTOGRAM_TIMES("DNS.PrefetchReferredPositiveHit", benefit);
     DLogResultsStats("DNS PrefetchReferredPositiveHit");
   } else {
-    UMA_HISTOGRAM_LONG_TIMES(L"DNS.PrefetchPositiveHitL", benefit);
+    UMA_HISTOGRAM_LONG_TIMES("DNS.PrefetchPositiveHitL", benefit);
     DLogResultsStats("DNS PrefetchPositiveHit");
   }
   return PREFETCH_NAME_FOUND;
 }
 
 void DnsHostInfo::DLogResultsStats(const char* message) const {
   if (!detailed_logging_enabled)
     return;
   DLOG(INFO) << "\t" << message <<  "\tq="
       << queue_duration().InMilliseconds() << "ms,\tr="
@@ skipping 175 matching lines @@
 
     case LEARNED_REFERAL_MOTIVATED:
       return RemoveJs(referring_hostname_);
 
     default:
       return "";
   }
 }
 
 }  // namespace chrome_browser_net
-