Trying changes to see the perfomance impact on Mac....

chrome/browser/metrics/thread_watcher_unittest.cc

 // Copyright (c) 2010 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 0
-
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_ptr.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
+#include "build/build_config.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 enum State {
   INITIALIZED,        // Created ThreadWatch object.
   ACTIVATED,          // Thread watching activated.
@@ skipping 113 matching lines @@
         check_response_state_ = FAILED;
       }
     }
     // Broadcast to indicate we have checked responsiveness of the thread that
     // is watched.
     state_changed_.Broadcast();
     return responsive;
   }
 
   void VeryLongMethod(TimeDelta wait_time) {
-    DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::WATCHDOG));
+    DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
     TimeTicks end_time = TimeTicks::Now() + wait_time;
     {
       base::AutoLock auto_lock(custom_lock_);
       while (wait_state_ != STOPPED_WAITING && TimeTicks::Now() < end_time) {
         TimeDelta state_change_wait_time = end_time - TimeTicks::Now();
         // LOG(INFO) << "In VeryLongMethod: thread_name_: " << thread_name_ <<
         //     " wait:" << state_change_wait_time.InMilliseconds() <<
         //     " wait_state_:" << wait_state_;
         state_changed_.TimedWait(state_change_wait_time);
       }
     }
   }
 
   State WaitForStateChange(const TimeDelta& wait_time, State expected_state) {
-    DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::WATCHDOG));
+    DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
     UpdateWaitState(STARTED_WAITING);
 
     State exit_state;
     // Keep the thread that is running the tests waiting until ThreadWatcher
     // object's state changes to the expected_state or until wait_time elapses.
     for (int i = 0; i < 3; ++i) {
         TimeTicks end_time = TimeTicks::Now() + wait_time;
         {
           base::AutoLock auto_lock(custom_lock_);
           while (thread_watcher_state_ != expected_state &&
@@ skipping 14 matching lines @@
     }
     // LOG(INFO) << "In WaitForStateChange: thread_name_: " << thread_name_ <<
     //     " expected_state: " << expected_state <<
     //     " exit_state:" << exit_state;
     UpdateWaitState(STOPPED_WAITING);
     return exit_state;
   }
 
   CheckResponseState WaitForCheckResponse(const TimeDelta& wait_time,
                                           CheckResponseState expected_state) {
-    DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::WATCHDOG));
+    DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
     UpdateWaitState(STARTED_WAITING);
 
     CheckResponseState exit_state;
     // Keep the thread that is running the tests waiting until ThreadWatcher
     // object's check_response_state_ changes to the expected_state or until
     // wait_time elapses.
     for (int i = 0; i < 3; ++i) {
         TimeTicks end_time = TimeTicks::Now() + wait_time;
         {
           base::AutoLock auto_lock(custom_lock_);
@@ skipping 28 matching lines @@
   static const TimeDelta kSleepTime;
   static const TimeDelta kUnresponsiveTime;
   static const BrowserThread::ID io_thread_id;
   static const std::string io_thread_name;
   static const BrowserThread::ID webkit_thread_id;
   static const std::string webkit_thread_name;
   CustomThreadWatcher* io_watcher_;
   CustomThreadWatcher* webkit_watcher_;
 
   ThreadWatcherTest() {
-  }
-
- protected:
-  virtual void SetUp() {
     webkit_thread_.reset(new BrowserThread(BrowserThread::WEBKIT));
     io_thread_.reset(new BrowserThread(BrowserThread::IO));
-    watchdog_thread_.reset(new BrowserThread(BrowserThread::WATCHDOG));
+    watchdog_thread_.reset(new WatchDogThread());
     webkit_thread_->Start();
     io_thread_->Start();
     watchdog_thread_->Start();
 
     // Setup the registry for thread watchers.
     thread_watcher_list_ = new ThreadWatcherList();
 
     // Create thread watcher object for the IO thread.
     io_watcher_ = new CustomThreadWatcher(io_thread_id, io_thread_name,
                                           kSleepTime, kUnresponsiveTime);
 
     // Create thread watcher object for the WEBKIT thread.
     webkit_watcher_ = new CustomThreadWatcher(
         webkit_thread_id, webkit_thread_name, kSleepTime, kUnresponsiveTime);
   }
 
-  virtual void TearDown() {
+  ~ThreadWatcherTest() {
     // io_thread_->Stop();
     // webkit_thread_->Stop();
     // watchdog_thread_->Stop();
     io_thread_.reset();
     webkit_thread_.reset();
     watchdog_thread_.reset();
     delete thread_watcher_list_;
   }
 
  private:
   scoped_ptr<BrowserThread> webkit_thread_;
   scoped_ptr<BrowserThread> io_thread_;
-  scoped_ptr<BrowserThread> watchdog_thread_;
+  scoped_ptr<WatchDogThread> watchdog_thread_;
   ThreadWatcherList* thread_watcher_list_;
 };
 
 // Define static constants.
 const TimeDelta ThreadWatcherTest::kSleepTime =
     TimeDelta::FromMilliseconds(50);
 const TimeDelta ThreadWatcherTest::kUnresponsiveTime =
     TimeDelta::FromMilliseconds(500);
 const BrowserThread::ID ThreadWatcherTest::io_thread_id = BrowserThread::IO;
 const std::string ThreadWatcherTest::io_thread_name = "IO";
@@ skipping 17 matching lines @@
   // Check ThreadWatcher object of watched WEBKIT thread has correct data.
   EXPECT_EQ(webkit_thread_id, webkit_watcher_->thread_id());
   EXPECT_EQ(webkit_thread_name, webkit_watcher_->thread_name());
   EXPECT_EQ(kSleepTime, webkit_watcher_->sleep_time());
   EXPECT_EQ(kUnresponsiveTime, webkit_watcher_->unresponsive_time());
   EXPECT_FALSE(webkit_watcher_->active());
 }
 
 // Test ActivateThreadWatching and DeActivateThreadWatching of IO thread. This
 // method also checks that pong message was sent by the watched thread and pong
-// message was received by the WATCHDOG thread. It also checks that
+// message was received by the WatchDogThread. It also checks that
 // OnCheckResponsiveness has verified the ping-pong mechanism and the watched
 // thread is not hung.
 TEST_F(ThreadWatcherTest, ThreadResponding) {
   TimeTicks time_before_ping = TimeTicks::Now();
   // Activate watching IO thread.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  MessageLoop* message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::ActivateThreadWatching));
 
   // Activate would have started ping/pong messaging. Expect atleast one
   // ping/pong messaging sequence to happen.
   io_watcher_->WaitForStateChange(kSleepTime + TimeDelta::FromMinutes(1),
                                   RECEIVED_PONG);
   io_watcher_->WaitForStateChange(kSleepTime + TimeDelta::FromMinutes(1),
                                   SENT_PING);
   EXPECT_GT(io_watcher_->ping_sent_, static_cast<uint64>(0));
   EXPECT_GT(io_watcher_->pong_received_, static_cast<uint64>(0));
   EXPECT_TRUE(io_watcher_->active());
   EXPECT_GE(io_watcher_->ping_time_, time_before_ping);
   EXPECT_GE(io_watcher_->ping_sequence_number_, static_cast<uint64>(0));
 
   // Verify watched thread is responding with ping/pong messaging.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
   EXPECT_GT(io_watcher_->success_response_, static_cast<uint64>(0));
   EXPECT_EQ(io_watcher_->failed_response_, static_cast<uint64>(0));
 
   // DeActivate thread watching for shutdown.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::DeActivateThreadWatching));
 }
 
 // This test posts a task on watched thread that takes very long time (this is
 // to simulate hanging of watched thread). It then checks for
 // OnCheckResponsiveness raising an alert (OnCheckResponsiveness returns false
 // if the watched thread is not responding).
 TEST_F(ThreadWatcherTest, ThreadNotResponding) {
   // Simulate hanging of watched thread by making the watched thread wait for a
   // very long time by posting a task on watched thread that keeps it busy.
   BrowserThread::PostTask(
       io_thread_id,
       FROM_HERE,
       NewRunnableMethod(
           io_watcher_,
           &CustomThreadWatcher::VeryLongMethod,
           kUnresponsiveTime * 10));
 
   // Activate thread watching.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  MessageLoop* message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::ActivateThreadWatching));
 
   // Verify watched thread is not responding for ping messages.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), FAILED);
   EXPECT_EQ(io_watcher_->success_response_, static_cast<uint64>(0));
   EXPECT_GT(io_watcher_->failed_response_, static_cast<uint64>(0));
 
   // DeActivate thread watching for shutdown.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::DeActivateThreadWatching));
 }
 
 // Test watching of multiple threads with all threads not responding.
 TEST_F(ThreadWatcherTest, MultipleThreadsResponding) {
   // Check for WEBKIT thread to perform ping/pong messaging.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  MessageLoop* message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           webkit_watcher_, &ThreadWatcher::ActivateThreadWatching));
+
   // Check for IO thread to perform ping/pong messaging.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::ActivateThreadWatching));
 
   // Verify WEBKIT thread is responding with ping/pong messaging.
   webkit_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
   EXPECT_GT(webkit_watcher_->ping_sent_, static_cast<uint64>(0));
   EXPECT_GT(webkit_watcher_->pong_received_, static_cast<uint64>(0));
   EXPECT_GE(webkit_watcher_->ping_sequence_number_, static_cast<uint64>(0));
   EXPECT_GT(webkit_watcher_->success_response_, static_cast<uint64>(0));
   EXPECT_EQ(webkit_watcher_->failed_response_, static_cast<uint64>(0));
 
   // Verify IO thread is responding with ping/pong messaging.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
   EXPECT_GT(io_watcher_->ping_sent_, static_cast<uint64>(0));
   EXPECT_GT(io_watcher_->pong_received_, static_cast<uint64>(0));
   EXPECT_GE(io_watcher_->ping_sequence_number_, static_cast<uint64>(0));
   EXPECT_GT(io_watcher_->success_response_, static_cast<uint64>(0));
   EXPECT_EQ(io_watcher_->failed_response_, static_cast<uint64>(0));
 
   // DeActivate thread watching for shutdown.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
-      NewRunnableMethod(io_watcher_, &ThreadWatcher::DeActivateThreadWatching));
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+      NewRunnableMethod(
+          io_watcher_, &ThreadWatcher::DeActivateThreadWatching));
+
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           webkit_watcher_, &ThreadWatcher::DeActivateThreadWatching));
 }
 
 // Test watching of multiple threads with one of the threads not responding.
 TEST_F(ThreadWatcherTest, MultipleThreadsNotResponding) {
   // Simulate hanging of watched thread by making the watched thread wait for a
   // very long time by posting a task on watched thread that keeps it busy.
   BrowserThread::PostTask(
       io_thread_id,
       FROM_HERE,
       NewRunnableMethod(
           io_watcher_,
           &CustomThreadWatcher::VeryLongMethod,
           kUnresponsiveTime * 10));
 
   // Activate watching of WEBKIT thread.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  MessageLoop* message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           webkit_watcher_, &ThreadWatcher::ActivateThreadWatching));
 
   // Activate watching of IO thread.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::ActivateThreadWatching));
 
   // Verify WEBKIT thread is responding with ping/pong messaging.
   webkit_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
   EXPECT_GT(webkit_watcher_->success_response_, static_cast<uint64>(0));
   EXPECT_EQ(webkit_watcher_->failed_response_, static_cast<uint64>(0));
 
   // Verify IO thread is not responding for ping messages.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), FAILED);
   EXPECT_EQ(io_watcher_->success_response_, static_cast<uint64>(0));
   EXPECT_GT(io_watcher_->failed_response_, static_cast<uint64>(0));
 
   // DeActivate thread watching for shutdown.
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop = WatchDogThread::CurrentMessageLoop();
+  ASSERT_TRUE(message_loop != NULL);
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::DeActivateThreadWatching));
-  BrowserThread::PostTask(
-      BrowserThread::WATCHDOG,
+  message_loop->PostTask(
       FROM_HERE,
       NewRunnableMethod(
           webkit_watcher_, &ThreadWatcher::DeActivateThreadWatching));
 }
-
-#endif  // 0