Remove use of wide characters in stats table identifiers.

base/stats_counters.h

 // 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.
 
 
 #ifndef BASE_STATS_COUNTERS_H__
 #define BASE_STATS_COUNTERS_H__
 
 #include <string>
 #include "base/stats_table.h"
@@ skipping 56 matching lines @@
 #define DSIMPLE_STATS_COUNTER(name) do {} while (0)
 #define DRATE_COUNTER(name, duration) do {} while (0)
 
 #endif  // NDEBUG
 
 //------------------------------------------------------------------------------
 // StatsCounter represents a counter in the StatsTable class.
 class StatsCounter {
  public:
   // Create a StatsCounter object.
-  explicit StatsCounter(const std::wstring& name)
+  explicit StatsCounter(const std::string& name)
        : counter_id_(-1) {
     // We prepend the name with 'c:' to indicate that it is a counter.
-    name_ = L"c:";
+    name_ = "c:";
     name_.append(name);
   };
 
   virtual ~StatsCounter() {}
 
   // Sets the counter to a specific value.
   void Set(int value) {
     int* loc = GetPtr();
     if (loc) *loc = value;
   }
@@ skipping 48 matching lines @@
   // Returns the cached address of this counter location.
   int* GetPtr() {
     StatsTable* table = StatsTable::current();
     if (!table)
       return NULL;
 
     // If counter_id_ is -1, then we haven't looked it up yet.
     if (counter_id_ == -1) {
       counter_id_ = table->FindCounter(name_);
       if (table->GetSlot() == 0) {
-        if (!table->RegisterThread(L"")) {
+        if (!table->RegisterThread("")) {
           // There is no room for this thread.  This thread
           // cannot use counters.
           counter_id_ = 0;
           return NULL;
         }
       }
     }
 
     // If counter_id_ is > 0, then we have a valid counter.
     if (counter_id_ > 0)
       return table->GetLocation(counter_id_, table->GetSlot());
 
     // counter_id_ was zero, which means the table is full.
     return NULL;
   }
 
-  std::wstring name_;
+  std::string name_;
   // The counter id in the table.  We initialize to -1 (an invalid value)
   // and then cache it once it has been looked up.  The counter_id is
   // valid across all threads and processes.
   int32 counter_id_;
 };
 
 
 // A StatsCounterTimer is a StatsCounter which keeps a timer during
 // the scope of the StatsCounterTimer.  On destruction, it will record
 // its time measurement.
 class StatsCounterTimer : protected StatsCounter {
  public:
   // Constructs and starts the timer.
-  explicit StatsCounterTimer(const std::wstring& name) {
+  explicit StatsCounterTimer(const std::string& name) {
     // we prepend the name with 't:' to indicate that it is a timer.
-    name_ = L"t:";
+    name_ = "t:";
     name_.append(name);
   }
 
   // Start the timer.
   void Start() {
     if (!Enabled())
       return;
     start_time_ = base::TimeTicks::Now();
     stop_time_ = base::TimeTicks();
   }
@@ skipping 30 matching lines @@
   base::TimeTicks start_time_;
   base::TimeTicks stop_time_;
 };
 
 // A StatsRate is a timer that keeps a count of the number of intervals added so
 // that several statistics can be produced:
 //    min, max, avg, count, total
 class StatsRate : public StatsCounterTimer {
  public:
   // Constructs and starts the timer.
-  explicit StatsRate(const wchar_t* name)
+  explicit StatsRate(const char* name)
       : StatsCounterTimer(name),
       counter_(name),
-      largest_add_(std::wstring(L" ").append(name).append(L"MAX").c_str()) {
+      largest_add_(std::string(" ").append(name).append("MAX").c_str()) {
   }
 
   virtual void Add(int value) {
     counter_.Increment();
     StatsCounterTimer::Add(value);
     if (value > largest_add_.value())
       largest_add_.Set(value);
   }
 
  private:
@@ skipping 17 matching lines @@
   void Stop() {
     timer_.Stop();
   }
 
  private:
   T& timer_;
 };
 
 #endif  // BASE_STATS_COUNTERS_H__