base: string_util.h -> utf_string_conversions.h fix.

base/stats_table_unittest.cc

 // Copyright (c) 2009 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.
 
+#if defined(OS_WIN)
+#include <process.h>
+#include <windows.h>
+#endif
+
 #include "base/multiprocess_test.h"
 #include "base/platform_thread.h"
 #include "base/simple_thread.h"
 #include "base/shared_memory.h"
 #include "base/stats_table.h"
 #include "base/stats_counters.h"
-#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
-#if defined(OS_WIN)
-#include <process.h>
-#include <windows.h>
-#endif
-
 namespace base {
 
 class StatsTableTest : public MultiProcessTest {
  public:
   void DeleteShmem(std::string name) {
     base::SharedMemory mem;
     mem.Delete(UTF8ToWide(name));
   }
 };
 
 // Open a StatsTable and verify that we can write to each of the
 // locations in the table.
 TEST_F(StatsTableTest, VerifySlots) {
   const std::string kTableName = "VerifySlotsStatTable";
   const int kMaxThreads = 1;
   const int kMaxCounter = 5;
   DeleteShmem(kTableName);
   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
 
   // Register a single thread.
   std::string thread_name = "mainThread";
   int slot_id = table.RegisterThread(thread_name);
   EXPECT_NE(slot_id, 0);
 
   // Fill up the table with counters.
   std::string counter_base_name = "counter";
-  for (int index=0; index < kMaxCounter; index++) {
+  for (int index = 0; index < kMaxCounter; index++) {
     std::string counter_name = counter_base_name;
     StringAppendF(&counter_name, "counter.ctr%d", index);
     int counter_id = table.FindCounter(counter_name);
     EXPECT_GT(counter_id, 0);
   }
 
   // Try to allocate an additional thread.  Verify it fails.
   slot_id = table.RegisterThread("too many threads");
   EXPECT_EQ(slot_id, 0);
 
@@ skipping 12 matching lines @@
 const std::string kCounterIncrement = "CounterIncrement";
 // CounterDecrement will be decremented each time.
 const std::string kCounterDecrement = "CounterDecrement";
 // CounterMixed will be incremented by odd numbered threads and
 // decremented by even threads.
 const std::string kCounterMixed = "CounterMixed";
 // The number of thread loops that we will do.
 const int kThreadLoops = 1000;
 
 class StatsTableThread : public base::SimpleThread {
-public:
+ public:
   StatsTableThread(std::string name, int id)
       : base::SimpleThread(name), id_(id) { }
   virtual void Run();
-private:
+ private:
   int id_;
 };
 
 void StatsTableThread::Run() {
   // Each thread will open the shared memory and set counters
   // concurrently in a loop.  We'll use some pauses to
   // mixup the thread scheduling.
 
   StatsCounter zero_counter(kCounterZero);
   StatsCounter lucky13_counter(kCounter1313);
@@ skipping 304 matching lines @@
     PlatformThread::Sleep(500);
   }
   EXPECT_LE(1000, table.GetCounterValue("t:foo"));
   EXPECT_LE(1000, table.GetCounterValue("t:bar"));
   EXPECT_EQ(2, table.GetCounterValue("c:bar"));
 
   DeleteShmem(kTableName);
 }
 
 }  // namespace base