Standardize usage of virtual/override/final in components/

components/dom_distiller/content/distiller_page_web_contents_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/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "components/dom_distiller/content/distiller_page_web_contents.h"
 #include "components/dom_distiller/content/web_contents_main_frame_observer.h"
@@ skipping 20 matching lines @@
 using testing::Not;
 
 namespace dom_distiller {
 
 const char* kSimpleArticlePath = "/simple_article.html";
 const char* kVideoArticlePath = "/video_article.html";
 
 class DistillerPageWebContentsTest : public ContentBrowserTest {
  public:
   // ContentBrowserTest:
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     AddComponentsResources();
     SetUpTestServer();
     ContentBrowserTest::SetUpOnMainThread();
   }
 
   void DistillPage(const base::Closure& quit_closure, const std::string& url) {
     quit_closure_ = quit_closure;
     distiller_page_->DistillPage(
         embedded_test_server()->GetURL(url),
         dom_distiller::proto::DomDistillerOptions(),
@@ skipping 44 matching lines @@
   TestDistillerPageWebContents(
       content::BrowserContext* browser_context,
       const gfx::Size& render_view_size,
       scoped_ptr<SourcePageHandleWebContents> optional_web_contents_handle,
       bool expect_new_web_contents)
       : DistillerPageWebContents(browser_context, render_view_size,
                                  optional_web_contents_handle.Pass()),
         expect_new_web_contents_(expect_new_web_contents),
         new_web_contents_created_(false) {}
 
-  virtual void CreateNewWebContents(const GURL& url) override {
+  void CreateNewWebContents(const GURL& url) override {
     ASSERT_EQ(true, expect_new_web_contents_);
     new_web_contents_created_ = true;
     // DistillerPageWebContents::CreateNewWebContents resets the scoped_ptr to
     // the WebContents, so intentionally leak WebContents here, since it is
     // owned by the shell.
     content::WebContents* web_contents = web_contents_.release();
     web_contents->GetLastCommittedURL();
     DistillerPageWebContents::CreateNewWebContents(url);
   }
 
-  virtual ~TestDistillerPageWebContents() {
+  ~TestDistillerPageWebContents() override {
     if (!expect_new_web_contents_) {
       // Intentionally leaking WebContents, since it is owned by the shell.
       content::WebContents* web_contents = web_contents_.release();
       web_contents->GetLastCommittedURL();
     }
   }
 
   bool new_web_contents_created() { return new_web_contents_created_; }
 
  private:
   bool expect_new_web_contents_;
   bool new_web_contents_created_;
 };
 
 // Helper class to know how far in the loading process the current WebContents
 // has come. It will call the callback either after
 // DidCommitProvisionalLoadForFrame or DocumentLoadedInFrame is called for the
 // main frame, based on the value of |wait_for_document_loaded|.
 class WebContentsMainFrameHelper : public content::WebContentsObserver {
  public:
   WebContentsMainFrameHelper(content::WebContents* web_contents,
                              const base::Closure& callback,
                              bool wait_for_document_loaded)
       : WebContentsObserver(web_contents),
         callback_(callback),
         wait_for_document_loaded_(wait_for_document_loaded) {}
 
-  virtual void DidCommitProvisionalLoadForFrame(
+  void DidCommitProvisionalLoadForFrame(
       content::RenderFrameHost* render_frame_host,
       const GURL& url,
       ui::PageTransition transition_type) override {
     if (wait_for_document_loaded_)
       return;
     if (!render_frame_host->GetParent())
       callback_.Run();
   }
 
-  virtual void DocumentLoadedInFrame(
+  void DocumentLoadedInFrame(
       content::RenderFrameHost* render_frame_host) override {
     if (wait_for_document_loaded_) {
       if (!render_frame_host->GetParent())
         callback_.Run();
     }
   }
 
  private:
   base::Closure callback_;
   bool wait_for_document_loaded_;
@@ skipping 346 matching lines @@
     std::string html = viewer::GetUnsafePartialArticleHtml(page_proto.get(),
         DistilledPagePrefs::LIGHT, DistilledPagePrefs::SERIF);
     EXPECT_THAT(html, HasSubstr(some_title));
     EXPECT_THAT(html, HasSubstr(no_content));
     EXPECT_THAT(html, Not(HasSubstr(no_title)));
     EXPECT_THAT(html, Not(HasSubstr(some_content)));
   }
 }
 
 }  // namespace dom_distiller