Standardize usage of virtual/override/final in content/

content/public/test/browser_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_BROWSER_TEST_UTILS_H_
 #define CONTENT_PUBLIC_TEST_BROWSER_TEST_UTILS_H_
 
 #include <queue>
 #include <string>
 #include <vector>
@@ skipping 210 matching lines @@
 
 // Watches title changes on a WebContents, blocking until an expected title is
 // set.
 class TitleWatcher : public WebContentsObserver {
  public:
   // |web_contents| must be non-NULL and needs to stay alive for the
   // entire lifetime of |this|. |expected_title| is the title that |this|
   // will wait for.
   TitleWatcher(WebContents* web_contents,
                const base::string16& expected_title);
-  virtual ~TitleWatcher();
+  ~TitleWatcher() override;
 
   // Adds another title to watch for.
   void AlsoWaitForTitle(const base::string16& expected_title);
 
   // Waits until the title matches either expected_title or one of the titles
   // added with AlsoWaitForTitle. Returns the value of the most recently
   // observed matching title.
   const base::string16& WaitAndGetTitle() WARN_UNUSED_RESULT;
 
  private:
   // Overridden WebContentsObserver methods.
-  virtual void DidStopLoading(RenderViewHost* render_view_host) override;
-  virtual void TitleWasSet(NavigationEntry* entry, bool explicit_set) override;
+  void DidStopLoading(RenderViewHost* render_view_host) override;
+  void TitleWasSet(NavigationEntry* entry, bool explicit_set) override;
 
   void TestTitle();
 
   std::vector<base::string16> expected_titles_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   // The most recently observed expected title, if any.
   base::string16 observed_title_;
 
   DISALLOW_COPY_AND_ASSIGN(TitleWatcher);
 };
 
 // Watches a WebContents and blocks until it is destroyed.
 class WebContentsDestroyedWatcher : public WebContentsObserver {
  public:
   explicit WebContentsDestroyedWatcher(WebContents* web_contents);
-  virtual ~WebContentsDestroyedWatcher();
+  ~WebContentsDestroyedWatcher() override;
 
   // Waits until the WebContents is destroyed.
   void Wait();
 
  private:
   // Overridden WebContentsObserver methods.
-  virtual void WebContentsDestroyed() override;
+  void WebContentsDestroyed() override;
 
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDestroyedWatcher);
 };
 
 // Watches a RenderProcessHost and waits for specified destruction events.
 class RenderProcessHostWatcher : public RenderProcessHostObserver {
  public:
   enum WatchType {
     WATCH_FOR_PROCESS_EXIT,
     WATCH_FOR_HOST_DESTRUCTION
   };
 
   RenderProcessHostWatcher(RenderProcessHost* render_process_host,
                            WatchType type);
   // Waits for the render process that contains the specified web contents.
   RenderProcessHostWatcher(WebContents* web_contents, WatchType type);
-  virtual ~RenderProcessHostWatcher();
+  ~RenderProcessHostWatcher() override;
 
   // Waits until the renderer process exits.
   void Wait();
 
  private:
   // Overridden RenderProcessHost::LifecycleObserver methods.
-  virtual void RenderProcessExited(RenderProcessHost* host,
-                                   base::TerminationStatus status,
-                                   int exit_code) override;
-  virtual void RenderProcessHostDestroyed(RenderProcessHost* host) override;
+  void RenderProcessExited(RenderProcessHost* host,
+                           base::TerminationStatus status,
+                           int exit_code) override;
+  void RenderProcessHostDestroyed(RenderProcessHost* host) override;
 
   RenderProcessHost* render_process_host_;
   WatchType type_;
 
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostWatcher);
 };
 
 // Watches for responses from the DOMAutomationController and keeps them in a
 // queue. Useful for waiting for a message to be received.
 class DOMMessageQueue : public NotificationObserver {
  public:
   // Constructs a DOMMessageQueue and begins listening for messages from the
   // DOMAutomationController. Do not construct this until the browser has
   // started.
   DOMMessageQueue();
-  virtual ~DOMMessageQueue();
+  ~DOMMessageQueue() override;
 
   // Removes all messages in the message queue.
   void ClearQueue();
 
   // Wait for the next message to arrive. |message| will be set to the next
   // message. Returns true on success.
   bool WaitForMessage(std::string* message) WARN_UNUSED_RESULT;
 
   // Overridden NotificationObserver methods.
-  virtual void Observe(int type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details) override;
+  void Observe(int type,
+               const NotificationSource& source,
+               const NotificationDetails& details) override;
 
  private:
   NotificationRegistrar registrar_;
   std::queue<std::string> message_queue_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(DOMMessageQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_TEST_BROWSER_TEST_UTILS_H_