Switch from the benighted PlatformThread to the shiny SimpleThread

base/stats_table_unittest.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 "base/multiprocess_test.h"
 #include "base/platform_thread.h"
+#include "base/simple_thread.h"
 #include "base/stats_table.h"
 #include "base/stats_counters.h"
 #include "base/string_util.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
@@ skipping 42 matching lines @@
 // CounterIncrement will be incremented each time.
 const std::wstring kCounterIncrement = L"CounterIncrement";
 // CounterDecrement will be decremented each time.
 const std::wstring kCounterDecrement = L"CounterDecrement";
 // CounterMixed will be incremented by odd numbered threads and
 // decremented by even threads.
 const std::wstring kCounterMixed = L"CounterMixed";
 // The number of thread loops that we will do.
 const int kThreadLoops = 1000;
 
-class StatsTableThread : public PlatformThread::Delegate {
+class StatsTableThread : public base::SimpleThread {
 public:
-  void ThreadMain();
-  PlatformThreadHandle thread_;
+  StatsTableThread(std::string name, int id)
+      : base::SimpleThread(name), id_(id) { }
+  virtual void Run();
+private:
   int id_;
 };
 
-void StatsTableThread::ThreadMain() {
+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);
   StatsCounter increment_counter(kCounterIncrement);
   StatsCounter decrement_counter(kCounterDecrement);
   for (int index = 0; index < kThreadLoops; index++) {
     StatsCounter mixed_counter(kCounterMixed);  // create this one in the loop
@@ skipping 16 matching lines @@
   const int kMaxThreads = 20;
   const int kMaxCounter = 5;
   StatsTable table(kTableName, kMaxThreads, kMaxCounter);
   StatsTable::set_current(&table);
 
   EXPECT_EQ(0, table.CountThreadsRegistered());
 
   // Spin up a set of threads to go bang on the various counters.
   // After we join the threads, we'll make sure the counters
   // contain the values we expected.
-  StatsTableThread threads[kMaxThreads];
+  StatsTableThread* threads[kMaxThreads];
 
   // Spawn the threads.
   for (int index = 0; index < kMaxThreads; index++) {
-    threads[index].id_ = index; 
-    bool created = 
-        PlatformThread::Create(0, &threads[index], &threads[index].thread_);
-    EXPECT_EQ(true, created);
-    EXPECT_NE(static_cast<PlatformThreadHandle>(0), threads[index].thread_);
+    threads[index] = new StatsTableThread("MultipleThreadsTest", index);
+    threads[index]->Start();
   }
 
   // Wait for the threads to finish.
   for (int index = 0; index < kMaxThreads; index++) {
-    PlatformThread::Join(threads[index].thread_);
+    threads[index]->Join();
+    delete threads[index];
   }
+
   StatsCounter zero_counter(kCounterZero);
   StatsCounter lucky13_counter(kCounter1313);
   StatsCounter increment_counter(kCounterIncrement);
   StatsCounter decrement_counter(kCounterDecrement);
   StatsCounter mixed_counter(kCounterMixed);
 
   // Verify the various counters are correct.
   std::wstring name;
   name = L"c:" + kCounterZero;
   EXPECT_EQ(0, table.GetCounterValue(name));
@@ skipping 235 matching lines @@
     StatsScope<StatsCounterTimer> timer(foo);
     StatsScope<StatsRate> timer2(bar);
     PlatformThread::Sleep(500);
   }
   EXPECT_LE(1000, table.GetCounterValue(L"t:foo"));
   EXPECT_LE(1000, table.GetCounterValue(L"t:bar"));
   EXPECT_EQ(2, table.GetCounterValue(L"c:bar"));
 }
 
 }  // namespace