Standardize usage of virtual/override/final in chrome/browser/extensions/

chrome/browser/extensions/content_verifier_browsertest.cc

 // Copyright 2014 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/scoped_observer.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/content_verify_job.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 
 namespace extensions {
 
 namespace {
 
 // Helper for observing extension unloads.
 class UnloadObserver : public ExtensionRegistryObserver {
  public:
   explicit UnloadObserver(ExtensionRegistry* registry) : observer_(this) {
     observer_.Add(registry);
   }
-  virtual ~UnloadObserver() {}
+  ~UnloadObserver() override {}
 
   void WaitForUnload(const ExtensionId& id) {
     if (ContainsKey(observed_, id))
       return;
 
     ASSERT_TRUE(loop_runner_.get() == NULL);
     awaited_id_ = id;
     loop_runner_ = new content::MessageLoopRunner();
     loop_runner_->Run();
   }
 
-  virtual void OnExtensionUnloaded(
-      content::BrowserContext* browser_context,
-      const Extension* extension,
-      UnloadedExtensionInfo::Reason reason) override {
+  void OnExtensionUnloaded(content::BrowserContext* browser_context,
+                           const Extension* extension,
+                           UnloadedExtensionInfo::Reason reason) override {
     observed_.insert(extension->id());
     if (awaited_id_ == extension->id())
       loop_runner_->Quit();
   }
 
  private:
   ExtensionId awaited_id_;
   std::set<ExtensionId> observed_;
   scoped_refptr<content::MessageLoopRunner> loop_runner_;
   ScopedObserver<ExtensionRegistry, UnloadObserver> observer_;
 };
 
 // Helper for forcing ContentVerifyJob's to return an error.
 class JobDelegate : public ContentVerifyJob::TestDelegate {
  public:
   JobDelegate() : fail_next_read_(false), fail_next_done_(false) {}
 
   virtual ~JobDelegate() {}
 
   void set_id(const ExtensionId& id) { id_ = id; }
   void fail_next_read() { fail_next_read_ = true; }
   void fail_next_done() { fail_next_done_ = true; }
 
-  virtual ContentVerifyJob::FailureReason BytesRead(const ExtensionId& id,
-                                                    int count,
-                                                    const char* data) override {
+  ContentVerifyJob::FailureReason BytesRead(const ExtensionId& id,
+                                            int count,
+                                            const char* data) override {
     if (id == id_ && fail_next_read_) {
       fail_next_read_ = false;
       return ContentVerifyJob::HASH_MISMATCH;
     }
     return ContentVerifyJob::NONE;
   }
 
-  virtual ContentVerifyJob::FailureReason DoneReading(
-      const ExtensionId& id) override {
+  ContentVerifyJob::FailureReason DoneReading(const ExtensionId& id) override {
     if (id == id_ && fail_next_done_) {
       fail_next_done_ = false;
       return ContentVerifyJob::HASH_MISMATCH;
     }
     return ContentVerifyJob::NONE;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(JobDelegate);
 
@@ skipping 11 matching lines @@
   void ExpectJobResult(const std::string& extension_id,
                        const base::FilePath& relative_path,
                        bool expected_to_fail);
 
   // Wait to see expected jobs. Returns true if we saw all jobs finish as
   // expected, or false if any job completed with non-expected success/failure
   // status.
   bool WaitForExpectedJobs();
 
   // ContentVerifyJob::TestObserver interface
-  virtual void JobStarted(const std::string& extension_id,
-                          const base::FilePath& relative_path) override;
+  void JobStarted(const std::string& extension_id,
+                  const base::FilePath& relative_path) override;
 
-  virtual void JobFinished(const std::string& extension_id,
-                           const base::FilePath& relative_path,
-                           bool failed) override;
+  void JobFinished(const std::string& extension_id,
+                   const base::FilePath& relative_path,
+                   bool failed) override;
 
  private:
   typedef std::pair<std::string, base::FilePath> ExtensionFile;
   typedef std::map<ExtensionFile, bool> ExpectedJobs;
   ExpectedJobs expected_jobs_;
   scoped_refptr<content::MessageLoopRunner> loop_runner_;
   bool saw_expected_job_results_;
 };
 
 void JobObserver::ExpectJobResult(const std::string& extension_id,
@@ skipping 41 matching lines @@
   }
 }
 
 }  // namespace
 
 class ContentVerifierTest : public ExtensionBrowserTest {
  public:
   ContentVerifierTest() {}
   virtual ~ContentVerifierTest() {}
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(
         switches::kExtensionContentVerification,
         switches::kExtensionContentVerificationEnforce);
   }
 
   // Setup our unload observer and JobDelegate, and install a test extension.
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     ExtensionBrowserTest::SetUpOnMainThread();
   }
 
-  virtual void TearDownOnMainThread() override {
+  void TearDownOnMainThread() override {
     ContentVerifyJob::SetDelegateForTests(NULL);
     ContentVerifyJob::SetObserverForTests(NULL);
     ExtensionBrowserTest::TearDownOnMainThread();
   }
 
   virtual void OpenPageAndWaitForUnload() {
     unload_observer_.reset(
         new UnloadObserver(ExtensionRegistry::Get(profile())));
     const Extension* extension = InstallExtensionFromWebstore(
         test_data_dir_.AppendASCII("content_verifier/v1.crx"), 1);
@@ skipping 53 matching lines @@
 
   ASSERT_TRUE(extension);
   ASSERT_EQ(extension->id(), id);
 
   EXPECT_TRUE(job_observer.WaitForExpectedJobs());
 
   ContentVerifyJob::SetObserverForTests(NULL);
 }
 
 }  // namespace extensions