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

chrome/browser/jankometer.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 "chrome/browser/jankometer.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 48 matching lines @@
   JankWatchdog(const TimeDelta& duration,
                const std::string& thread_watched_name,
                bool enabled)
       : Watchdog(duration, thread_watched_name, enabled),
         thread_name_watched_(thread_watched_name),
         alarm_count_(0) {
   }
 
   virtual ~JankWatchdog() {}
 
-  virtual void Alarm() {
+  virtual void Alarm() OVERRIDE {
     // Put break point here if you want to stop threads and look at what caused
     // the jankiness.
     alarm_count_++;
     Watchdog::Alarm();
   }
 
  private:
   std::string thread_name_watched_;
   int alarm_count_;
 
@@ skipping 170 matching lines @@
     helper_.StartProcessingTimers(queueing_time);
   }
 
   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
     helper_.EndProcessingTimers();
   }
 
  private:
   friend class base::RefCountedThreadSafe<IOJankObserver>;
 
-  ~IOJankObserver() {}
+  virtual ~IOJankObserver() {}
 
   JankObserverHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(IOJankObserver);
 };
 
 //------------------------------------------------------------------------------
 class UIJankObserver : public base::RefCountedThreadSafe<UIJankObserver>,
                        public MessageLoop::TaskObserver,
                        public MessageLoopForUI::Observer {
@@ skipping 59 matching lines @@
   }
 #elif defined(USE_AURA)
   virtual base::EventStatus WillProcessEvent(
       const base::NativeEvent& event) OVERRIDE {
     return base::EVENT_CONTINUE;
   }
 
   virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
   }
 #elif defined(TOOLKIT_GTK)
-  virtual void WillProcessEvent(GdkEvent* event) {
+  virtual void WillProcessEvent(GdkEvent* event) OVERRIDE {
     if (!helper_.MessageWillBeMeasured())
       return;
     // TODO(evanm): we want to set queueing_time_ using
     // gdk_event_get_time, but how do you convert that info
     // into a delta?
     // guint event_time = gdk_event_get_time(event);
     base::TimeDelta queueing_time = base::TimeDelta::FromMilliseconds(0);
     helper_.StartProcessingTimers(queueing_time);
   }
 
-  virtual void DidProcessEvent(GdkEvent* event) {
+  virtual void DidProcessEvent(GdkEvent* event) OVERRIDE {
     helper_.EndProcessingTimers();
   }
 #endif
 
  private:
   friend class base::RefCountedThreadSafe<UIJankObserver>;
 
-  ~UIJankObserver() {}
+  virtual ~UIJankObserver() {}
 
   JankObserverHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(UIJankObserver);
 };
 
 // These objects are created by InstallJankometer and leaked.
 const scoped_refptr<UIJankObserver>* ui_observer = NULL;
 const scoped_refptr<IOJankObserver>* io_observer = NULL;
 
@@ skipping 46 matching lines @@
     delete ui_observer;
     ui_observer = NULL;
   }
   if (io_observer) {
     // IO thread can't be running when we remove observers.
     DCHECK((!g_browser_process) || !(g_browser_process->io_thread()));
     delete io_observer;
     io_observer = NULL;
   }
 }