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

chrome/browser/safe_browsing/protocol_manager.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/protocol_manager.h"
 
 #include "base/file_version_info.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 311 matching lines @@
       } else if (update_state_ == SECOND_REQUEST) {
         next_update_sec_ = base::RandInt(15 * 60, 45 * 60);
       }
 
       // We need to request a new set of keys for MAC.
       if (re_key)
         HandleReKey();
 
       // New chunks to download.
       if (!chunk_urls.empty()) {
-        UMA_HISTOGRAM_COUNTS(L"SB2.UpdateUrls", chunk_urls.size());
+        UMA_HISTOGRAM_COUNTS("SB2.UpdateUrls", chunk_urls.size());
         for (size_t i = 0; i < chunk_urls.size(); ++i)
           chunk_request_urls_.push_back(chunk_urls[i]);
       }
 
       // Handle the case were the SafeBrowsing service tells us to dump our
       // database.
       if (reset) {
         sb_service_->ResetDatabase();
         delete chunk_deletes;
         return true;
       }
 
       // Chunks to delete from our storage.
       if (!chunk_deletes->empty())
         sb_service_->HandleChunkDelete(chunk_deletes);
       else
         delete chunk_deletes;
 
       break;
     }
     case CHUNK_REQUEST: {
       if (sb_service_->new_safe_browsing())
-        UMA_HISTOGRAM_TIMES(L"SB2.ChunkRequest",
+        UMA_HISTOGRAM_TIMES("SB2.ChunkRequest",
                             base::Time::Now() - chunk_request_start_);
 
       const ChunkUrl chunk_url = chunk_request_urls_.front();
       bool re_key = false;
       std::deque<SBChunk>* chunks = new std::deque<SBChunk>;
-      UMA_HISTOGRAM_COUNTS(L"SB2.ChunkSize", length);
+      UMA_HISTOGRAM_COUNTS("SB2.ChunkSize", length);
       update_size_ += length;
       if (!parser.ParseChunk(data, length,
                              client_key_, chunk_url.mac,
                              &re_key, chunks)) {
 #ifndef NDEBUG
         std::string data_str;
         data_str.assign(data, length);
         std::string encoded_chunk;
         net::Base64Encode(data, &encoded_chunk);
         SB_DLOG(INFO) << "ParseChunk error for chunk: " << chunk_url.url
@@ skipping 186 matching lines @@
   request_->set_upload_data("text/plain", list_data);
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnChunkInserted() {
   chunk_pending_to_write_ = false;
 
   if (chunk_request_urls_.empty()) {
     // Don't pollute old implementation histograms with new implemetation data.
     if (sb_service_->new_safe_browsing())
-      UMA_HISTOGRAM_LONG_TIMES(L"SB2.Update", Time::Now() - last_update_);
+      UMA_HISTOGRAM_LONG_TIMES("SB2.Update", Time::Now() - last_update_);
     else
-      UMA_HISTOGRAM_LONG_TIMES(L"SB.Update", Time::Now() - last_update_);
+      UMA_HISTOGRAM_LONG_TIMES("SB.Update", Time::Now() - last_update_);
     UpdateFinished(true);
   } else {
     IssueChunkRequest();
   }
 }
 
 void SafeBrowsingProtocolManager::ReportMalware(const GURL& malware_url,
                                                 const GURL& page_url,
                                                 const GURL& referrer_url) {
   std::string report_str = StringPrintf(
@@ skipping 39 matching lines @@
   wrapped_key_.clear();
   IssueKeyRequest();
 }
 
 void SafeBrowsingProtocolManager::HandleGetHashError() {
   int next = GetNextBackOffTime(&gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = Time::Now() + TimeDelta::FromSeconds(next);
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
-  UMA_HISTOGRAM_COUNTS(L"SB2.UpdateSize", update_size_);
+  UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   sb_service_->UpdateFinished(success);
 }