Remove unused WEBKIT_DEPRECATED thread

chrome/browser/metrics/thread_watcher_unittest.cc

 // Copyright (c) 2012 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 <math.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 220 matching lines @@
     return exit_state;
   }
 };
 
 class ThreadWatcherTest : public ::testing::Test {
  public:
   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;
+  static const BrowserThread::ID db_thread_id;
+  static const std::string db_thread_name;
   static const std::string crash_on_hang_seconds;
   static const std::string crash_on_hang_thread_names;
   static const std::string thread_names_and_live_threshold;
   static const std::string crash_on_hang_thread_data;
   CustomThreadWatcher* io_watcher_;
-  CustomThreadWatcher* webkit_watcher_;
+  CustomThreadWatcher* db_watcher_;
   ThreadWatcherList* thread_watcher_list_;
 
   ThreadWatcherTest()
       : setup_complete_(&lock_),
         initialized_(false) {
-    webkit_thread_.reset(new content::TestBrowserThread(
-        BrowserThread::WEBKIT_DEPRECATED));
+    db_thread_.reset(new content::TestBrowserThread(BrowserThread::DB));
     io_thread_.reset(new content::TestBrowserThread(BrowserThread::IO));
     watchdog_thread_.reset(new WatchDogThread());
-    webkit_thread_->Start();
+    db_thread_->Start();
     io_thread_->Start();
     watchdog_thread_->Start();
 
     WatchDogThread::PostTask(
         FROM_HERE,
         base::Bind(&ThreadWatcherTest::SetUpObjects, base::Unretained(this)));
 
     WaitForSetUp(TimeDelta::FromMinutes(1));
   }
 
   void SetUpObjects() {
     DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
     // 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);
     EXPECT_EQ(io_watcher_, thread_watcher_list_->Find(io_thread_id));
 
-    // Create thread watcher object for the WEBKIT thread.
-    webkit_watcher_ = new CustomThreadWatcher(
-        webkit_thread_id, webkit_thread_name, kSleepTime, kUnresponsiveTime);
-    EXPECT_EQ(webkit_watcher_, thread_watcher_list_->Find(webkit_thread_id));
+    // Create thread watcher object for the DB thread.

[jam, 2013/07/19 15:33:25]

are you sure that the DB thread wasn't watched on purpose, i.e. because it's
slow?

it might be best to separate adding watching to it in another cl, and sending
that to ramant

[jam, 2013/07/19 20:41:00]

argh, i missed that this was a test! nvm

+    db_watcher_ = new CustomThreadWatcher(
+        db_thread_id, db_thread_name, kSleepTime, kUnresponsiveTime);
+    EXPECT_EQ(db_watcher_, thread_watcher_list_->Find(db_thread_id));
 
     {
       base::AutoLock lock(lock_);
       initialized_ = true;
     }
     setup_complete_.Signal();
   }
 
   void WaitForSetUp(TimeDelta wait_time) {
     DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
     TimeTicks end_time = TimeTicks::Now() + wait_time;
     {
       base::AutoLock auto_lock(lock_);
       while (!initialized_ && TimeTicks::Now() < end_time)
         setup_complete_.TimedWait(end_time - TimeTicks::Now());
     }
   }
 
   virtual ~ThreadWatcherTest() {
     ThreadWatcherList::DeleteAll();
     io_watcher_ = NULL;
-    webkit_watcher_ = NULL;
+    db_watcher_ = NULL;
     io_thread_.reset();
-    webkit_thread_.reset();
+    db_thread_.reset();
     watchdog_thread_.reset();
     thread_watcher_list_ = NULL;
   }
 
  private:
   base::Lock lock_;
   base::ConditionVariable setup_complete_;
   bool initialized_;
-  scoped_ptr<content::TestBrowserThread> webkit_thread_;
+  scoped_ptr<content::TestBrowserThread> db_thread_;
   scoped_ptr<content::TestBrowserThread> io_thread_;
   scoped_ptr<WatchDogThread> watchdog_thread_;
 };
 
 // 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";
-const BrowserThread::ID ThreadWatcherTest::webkit_thread_id =
-    BrowserThread::WEBKIT_DEPRECATED;
-const std::string ThreadWatcherTest::webkit_thread_name = "WEBKIT";
+const BrowserThread::ID ThreadWatcherTest::db_thread_id = BrowserThread::DB;
+const std::string ThreadWatcherTest::db_thread_name = "DB";
 const std::string ThreadWatcherTest::crash_on_hang_thread_names = "UI,IO";
 const std::string ThreadWatcherTest::thread_names_and_live_threshold =
     "UI:4,IO:4";
 const std::string ThreadWatcherTest::crash_on_hang_thread_data =
     "UI:5:12,IO:5:12,FILE:5:12";
 
 TEST_F(ThreadWatcherTest, ThreadNamesOnlyArgs) {
   // Setup command_line arguments.
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kCrashOnHangThreads,
@@ skipping 93 matching lines @@
 // Test registration. When thread_watcher_list_ goes out of scope after
 // TearDown, all thread watcher objects will be deleted.
 TEST_F(ThreadWatcherTest, Registration) {
   // Check ThreadWatcher object has all correct parameters.
   EXPECT_EQ(io_thread_id, io_watcher_->thread_id());
   EXPECT_EQ(io_thread_name, io_watcher_->thread_name());
   EXPECT_EQ(kSleepTime, io_watcher_->sleep_time());
   EXPECT_EQ(kUnresponsiveTime, io_watcher_->unresponsive_time());
   EXPECT_FALSE(io_watcher_->active());
 
-  // 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());
+  // Check ThreadWatcher object of watched DB thread has correct data.
+  EXPECT_EQ(db_thread_id, db_watcher_->thread_id());
+  EXPECT_EQ(db_thread_name, db_watcher_->thread_name());
+  EXPECT_EQ(kSleepTime, db_watcher_->sleep_time());
+  EXPECT_EQ(kUnresponsiveTime, db_watcher_->unresponsive_time());
+  EXPECT_FALSE(db_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 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.
@@ skipping 58 matching lines @@
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
   // Wait for the io_watcher_'s VeryLongMethod to finish.
   io_watcher_->WaitForWaitStateChange(kUnresponsiveTime * 10, ALL_DONE);
 }
 
 // Test watching of multiple threads with all threads not responding.
 TEST_F(ThreadWatcherTest, MultipleThreadsResponding) {
-  // Check for WEBKIT thread to perform ping/pong messaging.
+  // Check for DB thread to perform ping/pong messaging.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
-                 base::Unretained(webkit_watcher_)));
+                 base::Unretained(db_watcher_)));
 
   // Check for IO thread to perform ping/pong messaging.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
-  // Verify WEBKIT thread is responding with ping/pong messaging.
-  webkit_watcher_->WaitForCheckResponse(
+  // Verify DB thread is responding with ping/pong messaging.
+  db_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));
+  EXPECT_GT(db_watcher_->ping_sent_, static_cast<uint64>(0));
+  EXPECT_GT(db_watcher_->pong_received_, static_cast<uint64>(0));
+  EXPECT_GE(db_watcher_->ping_sequence_number_, static_cast<uint64>(0));
+  EXPECT_GT(db_watcher_->success_response_, static_cast<uint64>(0));
+  EXPECT_EQ(db_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.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
-                 base::Unretained(webkit_watcher_)));
+                 base::Unretained(db_watcher_)));
 }
 
 // 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.
   // It is safe ot use base::Unretained because test is waiting for the method
   // to finish.
   BrowserThread::PostTask(
       io_thread_id,
       FROM_HERE,
       base::Bind(&CustomThreadWatcher::VeryLongMethod,
                  base::Unretained(io_watcher_),
                  kUnresponsiveTime * 10));
 
-  // Activate watching of WEBKIT thread.
+  // Activate watching of DB thread.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
-                 base::Unretained(webkit_watcher_)));
+                 base::Unretained(db_watcher_)));
 
   // Activate watching of IO thread.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
-  // Verify WEBKIT thread is responding with ping/pong messaging.
-  webkit_watcher_->WaitForCheckResponse(
+  // Verify DB thread is responding with ping/pong messaging.
+  db_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));
+  EXPECT_GT(db_watcher_->success_response_, static_cast<uint64>(0));
+  EXPECT_EQ(db_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.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
                  base::Unretained(io_watcher_)));
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
-                 base::Unretained(webkit_watcher_)));
+                 base::Unretained(db_watcher_)));
 
   // Wait for the io_watcher_'s VeryLongMethod to finish.
   io_watcher_->WaitForWaitStateChange(kUnresponsiveTime * 10, ALL_DONE);
 }