Standardize usage of virtual/override/final in content/

content/public/test/test_utils.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_TEST_TEST_UTILS_H_
 #define CONTENT_PUBLIC_TEST_TEST_UTILS_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 130 matching lines @@
 
   // Set up to wait for a complex condition. The condition is met when
   // |callback| returns |true|. The callback is invoked whenever a notification
   // of |notification_type| from any source is received.
   WindowedNotificationObserver(int notification_type,
                                const ConditionTestCallback& callback);
   WindowedNotificationObserver(
       int notification_type,
       const ConditionTestCallbackWithoutSourceAndDetails& callback);
 
-  virtual ~WindowedNotificationObserver();
+  ~WindowedNotificationObserver() override;
 
   // Adds an additional notification type to wait for. The condition will be met
   // if any of the registered notification types from their respective sources
   // is received.
   void AddNotificationType(int notification_type,
                            const NotificationSource& source);
 
   // Wait until the specified condition is met. If the condition is already met
   // (that is, the expected notification has already been received or the
   // given callback returns |true| already), Wait() returns immediately.
   void Wait();
 
   // Returns NotificationService::AllSources() if we haven't observed a
   // notification yet.
   const NotificationSource& source() const {
     return source_;
   }
 
   const NotificationDetails& details() const {
     return details_;
   }
 
   // NotificationObserver:
-  virtual void Observe(int type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details) override;
+  void Observe(int type,
+               const NotificationSource& source,
+               const NotificationDetails& details) override;
 
  private:
   bool seen_;
   bool running_;
   NotificationRegistrar registrar_;
 
   ConditionTestCallback callback_;
 
   NotificationSource source_;
   NotificationDetails details_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedNotificationObserver);
 };
 
 // Unit tests can use code which runs in the utility process by having it run on
 // an in-process utility thread. This eliminates having two code paths in
 // production code to deal with unit tests, and also helps with the binary
 // separation on Windows since chrome.dll doesn't need to call into Blink code
 // for some utility code to handle the single process case.
 // Include this class as a member variable in your test harness if you take
 // advantage of this functionality to ensure that the in-process utility thread
 // is torn down correctly. See http://crbug.com/316919 for more information.
 // Note: this class should be declared after the TestBrowserThreadBundle and
 // ShadowingAtExitManager (if it exists) as it will need to be run before they
 // are torn down.
 class InProcessUtilityThreadHelper : public BrowserChildProcessObserver {
  public:
   InProcessUtilityThreadHelper();
-  virtual ~InProcessUtilityThreadHelper();
+  ~InProcessUtilityThreadHelper() override;
 
  private:
-  virtual void BrowserChildProcessHostConnected(
-      const ChildProcessData& data) override;
-  virtual void BrowserChildProcessHostDisconnected(
+  void BrowserChildProcessHostConnected(const ChildProcessData& data) override;
+  void BrowserChildProcessHostDisconnected(
       const ChildProcessData& data) override;
 
   int child_thread_count_;
   scoped_refptr<MessageLoopRunner> runner_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessUtilityThreadHelper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_TEST_TEST_UTILS_H_