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

chrome/browser/sessions/session_backend.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/sessions/session_backend.h"
 
 #include <limits>
 
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 79 matching lines @@
       header[1] != kFileCurrentVersion)
     return false;
 
   ScopedVector<SessionCommand> read_commands;
   SessionCommand* command;
   while ((command = ReadCommand()) && !errored_)
     read_commands->push_back(command);
   if (!errored_)
     read_commands->swap(*commands);
   if (type == BaseSessionService::TAB_RESTORE) {
-    UMA_HISTOGRAM_TIMES(L"TabRestore.read_session_file_time",
+    UMA_HISTOGRAM_TIMES("TabRestore.read_session_file_time",
                         TimeTicks::Now() - start_time);
   } else {
-    UMA_HISTOGRAM_TIMES(L"SessionRestore.read_session_file_time",
+    UMA_HISTOGRAM_TIMES("SessionRestore.read_session_file_time",
                         TimeTicks::Now() - start_time);
   }
   return !errored_;
 }
 
 SessionCommand* SessionFileReader::ReadCommand() {
   // Make sure there is enough in the buffer for the size of the next command.
   if (available_count_ < sizeof(size_type)) {
     if (!FillBuffer())
       return NULL;
@@ skipping 138 matching lines @@
   current_session_file_.reset(NULL);
 
   const FilePath current_session_path = GetCurrentSessionPath();
   const FilePath last_session_path = GetLastSessionPath();
   if (file_util::PathExists(last_session_path))
     file_util::Delete(last_session_path, false);
   if (file_util::PathExists(current_session_path)) {
     int64 file_size;
     if (file_util::GetFileSize(current_session_path, &file_size)) {
       if (type_ == BaseSessionService::TAB_RESTORE) {
-        UMA_HISTOGRAM_COUNTS(L"TabRestore.last_session_file_size",
+        UMA_HISTOGRAM_COUNTS("TabRestore.last_session_file_size",
                              static_cast<int>(file_size / 1024));
       } else {
-        UMA_HISTOGRAM_COUNTS(L"SessionRestore.last_session_file_size",
+        UMA_HISTOGRAM_COUNTS("SessionRestore.last_session_file_size",
                              static_cast<int>(file_size / 1024));
       }
     }
     last_session_valid_ = file_util::Move(current_session_path,
                                           last_session_path);
   }
 
   if (file_util::PathExists(current_session_path))
     file_util::Delete(current_session_path, false);
 
   // Create and open the file for the current session.
   ResetFile();
 }
 
 bool SessionBackend::AppendCommandsToFile(net::FileStream* file,
     const std::vector<SessionCommand*>& commands) {
   for (std::vector<SessionCommand*>::const_iterator i = commands.begin();
        i != commands.end(); ++i) {
     int wrote;
     const size_type content_size = static_cast<size_type>((*i)->size());
     const size_type total_size =  content_size + sizeof(id_type);
     if (type_ == BaseSessionService::TAB_RESTORE)
-      UMA_HISTOGRAM_COUNTS(L"TabRestore.command_size", total_size);
+      UMA_HISTOGRAM_COUNTS("TabRestore.command_size", total_size);
     else
-      UMA_HISTOGRAM_COUNTS(L"SessionRestore.command_size", total_size);
+      UMA_HISTOGRAM_COUNTS("SessionRestore.command_size", total_size);
     wrote = file->Write(reinterpret_cast<const char*>(&total_size),
                         sizeof(total_size), NULL);
     if (wrote != sizeof(total_size)) {
       NOTREACHED() << "error writing";
       return false;
     }
     id_type command_id = (*i)->id();
     wrote = file->Write(reinterpret_cast<char*>(&command_id),
                         sizeof(command_id), NULL);
     if (wrote != sizeof(command_id)) {
@@ skipping 43 matching lines @@
 }
 
 FilePath SessionBackend::GetCurrentSessionPath() {
   FilePath path = path_to_dir_;
   if (type_ == BaseSessionService::TAB_RESTORE)
     path = path.AppendASCII(kCurrentTabSessionFileName);
   else
     path = path.AppendASCII(kCurrentSessionFileName);
   return path;
 }