Replace OVERRIDE and FINAL with override and final in content/public/[a-s]*

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 209 matching lines @@
   // 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;
+  virtual void DidStopLoading(RenderViewHost* render_view_host) override;
+  virtual 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();
 
   // Waits until the WebContents is destroyed.
   void Wait();
 
  private:
   // Overridden WebContentsObserver methods.
-  virtual void WebContentsDestroyed() OVERRIDE;
+  virtual 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();
 
   // Waits until the renderer process exits.
   void Wait();
 
  private:
   // Overridden RenderProcessHost::LifecycleObserver methods.
   virtual void RenderProcessExited(RenderProcessHost* host,
                                    base::ProcessHandle handle,
                                    base::TerminationStatus status,
-                                   int exit_code) OVERRIDE;
-  virtual void RenderProcessHostDestroyed(RenderProcessHost* host) OVERRIDE;
+                                   int exit_code) override;
+  virtual 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();
 
   // 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;
+                       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_