Replace OVERRIDE and FINAL with override and final in content/browser/web_contents

content/browser/web_contents/web_contents_impl_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 "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/media/audio_stream_monitor.h"
@@ skipping 27 matching lines @@
 
 namespace content {
 namespace {
 
 const char kTestWebUIUrl[] = "chrome://blah";
 
 class WebContentsImplTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   virtual WebUIController* CreateWebUIControllerForURL(
-      WebUI* web_ui, const GURL& url) const OVERRIDE {
+      WebUI* web_ui, const GURL& url) const override {
     if (!UseWebUI(url))
       return NULL;
     return new WebUIController(web_ui);
   }
 
   virtual WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
-      const GURL& url) const OVERRIDE {
+      const GURL& url) const override {
     return WebUI::kNoWebUI;
   }
 
   virtual bool UseWebUIForURL(BrowserContext* browser_context,
-                              const GURL& url) const OVERRIDE {
+                              const GURL& url) const override {
     return UseWebUI(url);
   }
 
   virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
-                                      const GURL& url) const OVERRIDE {
+                                      const GURL& url) const override {
     return UseWebUI(url);
   }
 
  private:
   bool UseWebUI(const GURL& url) const {
     return url == GURL(kTestWebUIUrl);
   }
 };
 
 class TestInterstitialPage;
 
 class TestInterstitialPageDelegate : public InterstitialPageDelegate {
  public:
   explicit TestInterstitialPageDelegate(TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {}
-  virtual void CommandReceived(const std::string& command) OVERRIDE;
-  virtual std::string GetHTMLContents() OVERRIDE { return std::string(); }
-  virtual void OnDontProceed() OVERRIDE;
-  virtual void OnProceed() OVERRIDE;
+  virtual void CommandReceived(const std::string& command) override;
+  virtual std::string GetHTMLContents() override { return std::string(); }
+  virtual void OnDontProceed() override;
+  virtual void OnProceed() override;
  private:
   TestInterstitialPage* interstitial_page_;
 };
 
 class TestInterstitialPage : public InterstitialPageImpl {
  public:
   enum InterstitialState {
     INVALID = 0,    // Hasn't yet been initialized.
     UNDECIDED,      // Initialized, but no decision taken yet.
     OKED,           // Proceed was called.
@@ skipping 84 matching lines @@
 
   void CommandReceived() {
     command_received_count_++;
   }
 
   void set_delegate(Delegate* delegate) {
     delegate_ = delegate;
   }
 
  protected:
-  virtual WebContentsView* CreateWebContentsView() OVERRIDE {
+  virtual WebContentsView* CreateWebContentsView() override {
     return NULL;
   }
 
  private:
   InterstitialState* state_;
   bool* deleted_;
   int command_received_count_;
   Delegate* delegate_;
 };
 
@@ skipping 16 matching lines @@
       : interstitial_page_(interstitial_page) {
     DCHECK(interstitial_page_);
     interstitial_page_->set_delegate(this);
   }
   virtual ~TestInterstitialPageStateGuard() {
     if (interstitial_page_)
       interstitial_page_->ClearStates();
   }
 
   virtual void TestInterstitialPageDeleted(
-      TestInterstitialPage* interstitial) OVERRIDE {
+      TestInterstitialPage* interstitial) override {
     DCHECK(interstitial_page_ == interstitial);
     interstitial_page_ = NULL;
   }
 
  private:
   TestInterstitialPage* interstitial_page_;
 };
 
 class WebContentsImplTestBrowserClient : public TestContentBrowserClient {
  public:
   WebContentsImplTestBrowserClient()
       : assign_site_for_url_(false) {}
 
   virtual ~WebContentsImplTestBrowserClient() {}
 
-  virtual bool ShouldAssignSiteForURL(const GURL& url) OVERRIDE {
+  virtual bool ShouldAssignSiteForURL(const GURL& url) override {
     return assign_site_for_url_;
   }
 
   void set_assign_site_for_url(bool assign) {
     assign_site_for_url_ = assign;
   }
 
  private:
   bool assign_site_for_url_;
 };
@@ skipping 15 matching lines @@
 };
 
 class TestWebContentsObserver : public WebContentsObserver {
  public:
   explicit TestWebContentsObserver(WebContents* contents)
       : WebContentsObserver(contents) {
   }
   virtual ~TestWebContentsObserver() {}
 
   virtual void DidFinishLoad(RenderFrameHost* render_frame_host,
-                             const GURL& validated_url) OVERRIDE {
+                             const GURL& validated_url) override {
     last_url_ = validated_url;
   }
   virtual void DidFailLoad(RenderFrameHost* render_frame_host,
                            const GURL& validated_url,
                            int error_code,
-                           const base::string16& error_description) OVERRIDE {
+                           const base::string16& error_description) override {
     last_url_ = validated_url;
   }
 
   const GURL& last_url() const { return last_url_; }
 
  private:
   GURL last_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebContentsObserver);
 };
 
 // Pretends to be a normal browser that receives toggles and transitions to/from
 // a fullscreened state.
 class FakeFullscreenDelegate : public WebContentsDelegate {
  public:
   FakeFullscreenDelegate() : fullscreened_contents_(NULL) {}
   virtual ~FakeFullscreenDelegate() {}
 
   virtual void ToggleFullscreenModeForTab(WebContents* web_contents,
-                                          bool enter_fullscreen) OVERRIDE {
+                                          bool enter_fullscreen) override {
     fullscreened_contents_ = enter_fullscreen ? web_contents : NULL;
   }
 
   virtual bool IsFullscreenForTabOrPending(const WebContents* web_contents)
-      const OVERRIDE {
+      const override {
     return fullscreened_contents_ && web_contents == fullscreened_contents_;
   }
 
  private:
   WebContents* fullscreened_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeFullscreenDelegate);
 };
 
 class FakeValidationMessageDelegate : public WebContentsDelegate {
  public:
   FakeValidationMessageDelegate()
       : hide_validation_message_was_called_(false) {}
   virtual ~FakeValidationMessageDelegate() {}
 
-  virtual void HideValidationMessage(WebContents* web_contents) OVERRIDE {
+  virtual void HideValidationMessage(WebContents* web_contents) override {
     hide_validation_message_was_called_ = true;
   }
 
   bool hide_validation_message_was_called() const {
     return hide_validation_message_was_called_;
   }
 
  private:
   bool hide_validation_message_was_called_;
 
@@ skipping 2110 matching lines @@
     int count = contents_zoom_changed_call_count_;
     contents_zoom_changed_call_count_ = 0;
     return count;
   }
 
   bool last_zoom_in() const {
     return last_zoom_in_;
   }
 
   // WebContentsDelegate:
-  virtual void ContentsZoomChange(bool zoom_in) OVERRIDE {
+  virtual void ContentsZoomChange(bool zoom_in) override {
     contents_zoom_changed_call_count_++;
     last_zoom_in_ = zoom_in;
   }
 
  private:
   int contents_zoom_changed_call_count_;
   bool last_zoom_in_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentsZoomChangedDelegate);
 };
@@ skipping 307 matching lines @@
 
   // Destroy the video only player.  No power save blockers should remain.
   rfh->OnMessageReceived(
       FrameHostMsg_MediaPausedNotification(0, kPlayerVideoOnlyId));
   EXPECT_FALSE(contents()->has_video_power_save_blocker_for_testing());
   EXPECT_FALSE(contents()->has_audio_power_save_blocker_for_testing());
 }
 #endif
 
 }  // namespace content