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

chrome/browser/safe_browsing/safe_browsing_service.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/safe_browsing/safe_browsing_service.h"
 
 #include "base/command_line.h"
 #include "base/histogram.h"
 #include "base/logging.h"
@@ skipping 166 matching lines @@
   DCHECK(MessageLoop::current() == io_loop_);
   if (!enabled_ || !database_)
     return true;
 
   if (new_safe_browsing_)
     return CheckUrlNew(url, client);
 
   if (!resetting_) {
     Time start_time = Time::Now();
     bool need_check = database_->NeedToCheckUrl(url);
-    UMA_HISTOGRAM_TIMES(L"SB.BloomFilter", Time::Now() - start_time);
+    UMA_HISTOGRAM_TIMES("SB.BloomFilter", Time::Now() - start_time);
     if (!need_check)
       return true;  // The url is definitely safe.
   }
 
   // The url may or may not be safe, need to go to the database to be sure.
   SafeBrowsingCheck* check = new SafeBrowsingCheck();
   check->url = url;
   check->client = client;
   check->result = URL_SAFE;
   check->need_get_hash = false;
@@ skipping 18 matching lines @@
   }
 
   std::string list;
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> full_hits;
   base::Time check_start = base::Time::Now();
   bool prefix_match = database_->ContainsUrl(url, &list, &prefix_hits,
                                              &full_hits,
                                              protocol_manager_->last_update());
   
-  UMA_HISTOGRAM_TIMES(L"SB2.FilterCheck", base::Time::Now() - check_start);
+  UMA_HISTOGRAM_TIMES("SB2.FilterCheck", base::Time::Now() - check_start);
 
   if (!prefix_match)
     return true;  // URL is okay.
 
   // Needs to be asynchronous, since we could be in the constructor of a
   // ResourceDispatcherHost event handler which can't pause there.
   SafeBrowsingCheck* check = new SafeBrowsingCheck();
   check->url = url;
   check->client = client;
   check->result = URL_SAFE;
@@ skipping 139 matching lines @@
 }
 
 void SafeBrowsingService::OnCheckDone(SafeBrowsingCheck* check) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   // If we've been shutdown during the database lookup, this check will already
   // have been deleted (in OnIOShutdown).
   if (!enabled_ || checks_.find(check) == checks_.end())
     return;
 
-  UMA_HISTOGRAM_TIMES(L"SB.Database", Time::Now() - check->start);
+  UMA_HISTOGRAM_TIMES("SB.Database", Time::Now() - check->start);
   if (check->client && check->need_get_hash) {
     // We have a partial match so we need to query Google for the full hash.
     // Clean up will happen in HandleGetHashResults.
 
     // See if we have a GetHash request already in progress for this particular
     // prefix. If so, we just append ourselves to the list of interested parties
     // when the results arrive. We only do this for checks involving one prefix,
     // since that is the common case (multiple prefixes will issue the request
     // as normal).
     if (check->prefix_hits.size() == 1) {
@@ skipping 60 matching lines @@
 void SafeBrowsingService::HandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes,
     bool can_cache) {
   if (checks_.find(check) == checks_.end())
     return;
 
   DCHECK(enabled_);
 
   if (new_safe_browsing_)
-    UMA_HISTOGRAM_LONG_TIMES(L"SB2.Network", Time::Now() - check->start);
+    UMA_HISTOGRAM_LONG_TIMES("SB2.Network", Time::Now() - check->start);
   else
-    UMA_HISTOGRAM_LONG_TIMES(L"SB.Network", Time::Now() - check->start);
+    UMA_HISTOGRAM_LONG_TIMES("SB.Network", Time::Now() - check->start);
 
   std::vector<SBPrefix> prefixes = check->prefix_hits;
   OnHandleGetHashResults(check, full_hashes);  // 'check' is deleted here.
 
   if (can_cache) {
     if (!new_safe_browsing_) {
       db_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
           this, &SafeBrowsingService::CacheHashResults, prefixes, full_hashes));
     } else if (database_) {
       // Cache the GetHash results in memory:
@@ skipping 224 matching lines @@
   if (safe_browsing_util::IsMalwareList(list_name)) {
     return URL_MALWARE;
   }
 
   SB_DLOG(INFO) << "Unknown safe browsing list " << list_name;
   return URL_SAFE;
 }
 
 void SafeBrowsingService::LogPauseDelay(TimeDelta time) {
   if (new_safe_browsing_)
-    UMA_HISTOGRAM_LONG_TIMES(L"SB2.Delay", time);
+    UMA_HISTOGRAM_LONG_TIMES("SB2.Delay", time);
   else
-    UMA_HISTOGRAM_LONG_TIMES(L"SB.Delay", time);
+    UMA_HISTOGRAM_LONG_TIMES("SB.Delay", time);
 }
 
 void SafeBrowsingService::CacheHashResults(
   const std::vector<SBPrefix>& prefixes,
   const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK(MessageLoop::current() == db_thread_->message_loop());
   GetDatabase()->CacheHashResults(prefixes, full_hashes);
 }
 
 void SafeBrowsingService::OnSuspend(base::SystemMonitor*) {
@@ skipping 14 matching lines @@
   DCHECK(MessageLoop::current() == db_thread_->message_loop());
   // We don't call GetDatabase() here, since we want to avoid unnecessary calls
   // to Open, Reset, etc, or reload the bloom filter while we're coming out of
   // a suspended state.
   if (database_)
     database_->HandleResume();
 }
 
 void SafeBrowsingService::RunQueuedClients() {
   DCHECK(MessageLoop::current() == io_loop_);
-  HISTOGRAM_COUNTS(L"SB.QueueDepth", queued_checks_.size());
+  HISTOGRAM_COUNTS("SB.QueueDepth", queued_checks_.size());
   while (!queued_checks_.empty()) {
     QueuedCheck check = queued_checks_.front();
-    HISTOGRAM_TIMES(L"SB.QueueDelay", Time::Now() - check.start);
+    HISTOGRAM_TIMES("SB.QueueDelay", Time::Now() - check.start);
     CheckUrl(check.url, check.client);
     queued_checks_.pop_front();
   }
 }
 
 void SafeBrowsingService::ReportMalware(const GURL& malware_url,
                                         const GURL& page_url,
                                         const GURL& referrer_url) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   // We need to access the database cache on the io_loop_ which is only allowed
   // in the new SafeBrowsing database system.
   if (!new_safe_browsing_ || !enabled_ || !database_)
     return;
 
   // Check if 'page_url' is already blacklisted (exists in our cache). Only
   // report if it's not there.
   std::string list;
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> full_hits;
   database_->ContainsUrl(page_url, &list, &prefix_hits, &full_hits,
                          protocol_manager_->last_update());
 
   if (full_hits.empty())
     protocol_manager_->ReportMalware(malware_url, page_url, referrer_url);
 }