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

content/browser/web_contents/web_contents_impl_browsertest.cc

 // Copyright 2013 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/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/public/browser/load_notification_details.h"
@@ skipping 47 matching lines @@
 class LoadStopNotificationObserver : public WindowedNotificationObserver {
  public:
   LoadStopNotificationObserver(NavigationController* controller)
       : WindowedNotificationObserver(NOTIFICATION_LOAD_STOP,
                                      Source<NavigationController>(controller)),
         session_index_(-1),
         controller_(NULL) {
   }
   virtual void Observe(int type,
                        const NotificationSource& source,
-                       const NotificationDetails& details) OVERRIDE {
+                       const NotificationDetails& details) override {
     if (type == NOTIFICATION_LOAD_STOP) {
       const Details<LoadNotificationDetails> load_details(details);
       url_ = load_details->url;
       session_index_ = load_details->session_index;
       controller_ = load_details->controller;
     }
     WindowedNotificationObserver::Observe(type, source, details);
   }
 
   GURL url_;
   int session_index_;
   NavigationController* controller_;
 };
 
 // Starts a new navigation as soon as the current one commits, but does not
 // wait for it to complete.  This allows us to observe DidStopLoading while
 // a pending entry is present.
 class NavigateOnCommitObserver : public WebContentsObserver {
  public:
   NavigateOnCommitObserver(Shell* shell, GURL url)
       : WebContentsObserver(shell->web_contents()),
         shell_(shell),
         url_(url),
         done_(false) {
   }
 
   // WebContentsObserver:
   virtual void NavigationEntryCommitted(
-      const LoadCommittedDetails& load_details) OVERRIDE {
+      const LoadCommittedDetails& load_details) override {
     if (!done_) {
       done_ = true;
       shell_->Stop();
       shell_->LoadURL(url_);
     }
   }
 
   Shell* shell_;
   GURL url_;
   bool done_;
 };
 
 class RenderViewSizeDelegate : public WebContentsDelegate {
  public:
   void set_size_insets(const gfx::Size& size_insets) {
     size_insets_ = size_insets;
   }
 
   // WebContentsDelegate:
   virtual gfx::Size GetSizeForNewRenderView(
-      WebContents* web_contents) const OVERRIDE {
+      WebContents* web_contents) const override {
     gfx::Size size(web_contents->GetContainerBounds().size());
     size.Enlarge(size_insets_.width(), size_insets_.height());
     return size;
   }
 
  private:
   gfx::Size size_insets_;
 };
 
 class RenderViewSizeObserver : public WebContentsObserver {
  public:
   RenderViewSizeObserver(Shell* shell, const gfx::Size& wcv_new_size)
       : WebContentsObserver(shell->web_contents()),
         shell_(shell),
         wcv_new_size_(wcv_new_size) {
   }
 
   // WebContentsObserver:
-  virtual void RenderViewCreated(RenderViewHost* rvh) OVERRIDE {
+  virtual void RenderViewCreated(RenderViewHost* rvh) override {
     rwhv_create_size_ = rvh->GetView()->GetViewBounds().size();
   }
 
   virtual void DidStartNavigationToPendingEntry(
       const GURL& url,
-      NavigationController::ReloadType reload_type) OVERRIDE {
+      NavigationController::ReloadType reload_type) override {
     ResizeWebContentsView(shell_, wcv_new_size_, false);
   }
 
   gfx::Size rwhv_create_size() const { return rwhv_create_size_; }
 
  private:
   Shell* shell_;  // Weak ptr.
   gfx::Size wcv_new_size_;
   gfx::Size rwhv_create_size_;
 };
 
 class LoadingStateChangedDelegate : public WebContentsDelegate {
  public:
   LoadingStateChangedDelegate()
       : loadingStateChangedCount_(0)
       , loadingStateToDifferentDocumentCount_(0) {
   }
 
   // WebContentsDelegate:
   virtual void LoadingStateChanged(WebContents* contents,
-                                   bool to_different_document) OVERRIDE {
+                                   bool to_different_document) override {
       loadingStateChangedCount_++;
       if (to_different_document)
         loadingStateToDifferentDocumentCount_++;
   }
 
   int loadingStateChangedCount() const { return loadingStateChangedCount_; }
   int loadingStateToDifferentDocumentCount() const {
     return loadingStateToDifferentDocumentCount_;
   }
 
@@ skipping 203 matching lines @@
 
 // Observer class to track the creation of RenderFrameHost objects. It is used
 // in subsequent tests.
 class RenderFrameCreatedObserver : public WebContentsObserver {
  public:
   RenderFrameCreatedObserver(Shell* shell)
       : WebContentsObserver(shell->web_contents()),
         last_rfh_(NULL) {
   }
 
-  virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) OVERRIDE {
+  virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) override {
     last_rfh_ = render_frame_host;
   }
 
   RenderFrameHost* last_rfh() const { return last_rfh_; }
 
  private:
   RenderFrameHost* last_rfh_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameCreatedObserver);
 };
@@ skipping 84 matching lines @@
                                          public WebContentsObserver {
   LoadProgressDelegateAndObserver(Shell* shell)
       : WebContentsObserver(shell->web_contents()),
         did_start_loading(false),
         did_stop_loading(false) {
     web_contents()->SetDelegate(this);
   }
 
   // WebContentsDelegate:
   virtual void LoadProgressChanged(WebContents* source,
-                                   double progress) OVERRIDE {
+                                   double progress) override {
     EXPECT_TRUE(did_start_loading);
     EXPECT_FALSE(did_stop_loading);
     progresses.push_back(progress);
   }
 
   // WebContentsObserver:
-  virtual void DidStartLoading(RenderViewHost* render_view_host) OVERRIDE {
+  virtual void DidStartLoading(RenderViewHost* render_view_host) override {
     EXPECT_FALSE(did_start_loading);
     EXPECT_EQ(0U, progresses.size());
     EXPECT_FALSE(did_stop_loading);
     did_start_loading = true;
   }
 
-  virtual void DidStopLoading(RenderViewHost* render_view_host) OVERRIDE {
+  virtual void DidStopLoading(RenderViewHost* render_view_host) override {
     EXPECT_TRUE(did_start_loading);
     EXPECT_GE(progresses.size(), 1U);
     EXPECT_FALSE(did_stop_loading);
     did_stop_loading = true;
   }
 
   bool did_start_loading;
   std::vector<double> progresses;
   bool did_stop_loading;
 };
@@ skipping 18 matching lines @@
   ASSERT_GE(progresses.size(), 1U)
       << "There should be at least one progress update";
   EXPECT_EQ(1.0, *progresses.rbegin());
 }
 
 struct FirstVisuallyNonEmptyPaintObserver : public WebContentsObserver {
   FirstVisuallyNonEmptyPaintObserver(Shell* shell)
       : WebContentsObserver(shell->web_contents()),
         did_fist_visually_non_empty_paint_(false) {}
 
-  virtual void DidFirstVisuallyNonEmptyPaint() OVERRIDE {
+  virtual void DidFirstVisuallyNonEmptyPaint() override {
     did_fist_visually_non_empty_paint_ = true;
     on_did_first_visually_non_empty_paint_.Run();
   }
 
   void WaitForDidFirstVisuallyNonEmptyPaint() {
     if (did_fist_visually_non_empty_paint_)
       return;
     base::RunLoop run_loop;
     on_did_first_visually_non_empty_paint_ = run_loop.QuitClosure();
     run_loop.Run();
@@ skipping 17 matching lines @@
       new FirstVisuallyNonEmptyPaintObserver(shell()));
 
   NavigateToURL(shell(), embedded_test_server()->GetURL("/title1.html"));
 
   observer->WaitForDidFirstVisuallyNonEmptyPaint();
   ASSERT_TRUE(observer->did_fist_visually_non_empty_paint_);
 }
 
 }  // namespace content