Linux/ChromeOS Chromium style checker cleanup, chrome/browser edition.

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 99 matching lines @@
     WaitState old_state;
     {
       base::AutoLock auto_lock(custom_lock_);
       old_state = wait_state_;
       wait_state_ = new_state;
     }
     state_changed_.Broadcast();
     return old_state;
   }
 
-  void ActivateThreadWatching() {
+  virtual void ActivateThreadWatching() OVERRIDE {
     State old_state = UpdateState(ACTIVATED);
     EXPECT_EQ(old_state, INITIALIZED);
     ThreadWatcher::ActivateThreadWatching();
   }
 
-  void DeActivateThreadWatching() {
+  virtual void DeActivateThreadWatching() OVERRIDE {
     State old_state = UpdateState(DEACTIVATED);
     EXPECT_TRUE(old_state == ACTIVATED || old_state == SENT_PING ||
                 old_state == RECEIVED_PONG);
     ThreadWatcher::DeActivateThreadWatching();
   }
 
-  void PostPingMessage() {
+  virtual void PostPingMessage() OVERRIDE {
     State old_state = UpdateState(SENT_PING);
     EXPECT_TRUE(old_state == ACTIVATED || old_state == RECEIVED_PONG);
     ThreadWatcher::PostPingMessage();
   }
 
-  void OnPongMessage(uint64 ping_sequence_number) {
+  virtual void OnPongMessage(uint64 ping_sequence_number) OVERRIDE {
     State old_state = UpdateState(RECEIVED_PONG);
     EXPECT_TRUE(old_state == SENT_PING || old_state == DEACTIVATED);
     ThreadWatcher::OnPongMessage(ping_sequence_number);
   }
 
-  void OnCheckResponsiveness(uint64 ping_sequence_number) {
+  virtual void OnCheckResponsiveness(uint64 ping_sequence_number) OVERRIDE {
     ThreadWatcher::OnCheckResponsiveness(ping_sequence_number);
     {
       base::AutoLock auto_lock(custom_lock_);
       if (responsive_) {
         ++success_response_;
         check_response_state_ = SUCCESSFUL;
       } else {
         ++failed_response_;
         check_response_state_ = FAILED;
       }
@@ skipping 134 matching lines @@
   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());
     }
   }
 
-  ~ThreadWatcherTest() {
+  virtual ~ThreadWatcherTest() {
     ThreadWatcherList::DeleteAll();
     io_watcher_ = NULL;
     webkit_watcher_ = NULL;
     io_thread_.reset();
     webkit_thread_.reset();
     watchdog_thread_.reset();
     thread_watcher_list_ = NULL;
   }
 
  private:
@@ skipping 238 matching lines @@
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
                  base::Unretained(io_watcher_)));
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
                  base::Unretained(webkit_watcher_)));
 
   // Wait for the io_watcher_'s VeryLongMethod to finish.
   io_watcher_->WaitForWaitStateChange(kUnresponsiveTime * 10, ALL_DONE);
 }