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

chrome/browser/extensions/updater/extension_updater_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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 194 matching lines @@
  public:
   NotificationsObserver() {
     for (size_t i = 0; i < arraysize(kNotificationsObserved); ++i) {
       count_[i] = 0;
       registrar_.Add(this,
                      kNotificationsObserved[i],
                      content::NotificationService::AllSources());
     }
   }
 
-  virtual ~NotificationsObserver() {
+  ~NotificationsObserver() override {
     for (size_t i = 0; i < arraysize(kNotificationsObserved); ++i) {
       registrar_.Remove(this,
                         kNotificationsObserved[i],
                         content::NotificationService::AllSources());
     }
   }
 
   size_t StartedCount() { return count_[0]; }
   size_t UpdatedCount() { return count_[1]; }
 
   bool Updated(const std::string& id) {
     return updated_.find(id) != updated_.end();
   }
 
   void Wait() {
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
     quit_closure_ = runner->QuitClosure();
     runner->Run();
     quit_closure_.Reset();
   }
 
  private:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     if (!quit_closure_.is_null())
       quit_closure_.Run();
     for (size_t i = 0; i < arraysize(kNotificationsObserved); ++i) {
       if (kNotificationsObserved[i] == type) {
         count_[i]++;
         if (type == extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND) {
           updated_.insert(
               content::Details<UpdateDetails>(details)->id);
         }
         return;
@@ skipping 33 matching lines @@
 
 // Base class for further specialized test classes.
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
       : prefs_(prefs),
         pending_extension_manager_(&profile_),
         downloader_delegate_override_(NULL) {
   }
 
-  virtual ~MockService() {}
+  ~MockService() override {}
 
-  virtual PendingExtensionManager* pending_extension_manager() override {
+  PendingExtensionManager* pending_extension_manager() override {
     ADD_FAILURE() << "Subclass should override this if it will "
                   << "be accessed by a test.";
     return &pending_extension_manager_;
   }
 
   Profile* profile() { return &profile_; }
 
   net::URLRequestContextGetter* request_context() {
     return profile_.GetRequestContext();
   }
@@ skipping 120 matching lines @@
   }
 }
 
 class ServiceForManifestTests : public MockService {
  public:
   explicit ServiceForManifestTests(TestExtensionPrefs* prefs)
       : MockService(prefs),
         registry_(ExtensionRegistry::Get(profile())) {
   }
 
-  virtual ~ServiceForManifestTests() {}
+  ~ServiceForManifestTests() override {}
 
-  virtual const Extension* GetExtensionById(
-      const std::string& id, bool include_disabled) const override {
+  const Extension* GetExtensionById(const std::string& id,
+                                    bool include_disabled) const override {
     const Extension* result = registry_->enabled_extensions().GetByID(id);
     if (result || !include_disabled)
       return result;
     return registry_->disabled_extensions().GetByID(id);
   }
 
-  virtual const ExtensionSet* extensions() const override {
+  const ExtensionSet* extensions() const override {
     return &registry_->enabled_extensions();
   }
 
-  virtual PendingExtensionManager* pending_extension_manager() override {
+  PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
 
-  virtual const Extension* GetPendingExtensionUpdate(
+  const Extension* GetPendingExtensionUpdate(
       const std::string& id) const override {
     return NULL;
   }
 
-  virtual bool IsExtensionEnabled(const std::string& id) const override {
+  bool IsExtensionEnabled(const std::string& id) const override {
     return !registry_->disabled_extensions().Contains(id);
   }
 
   void set_extensions(ExtensionList extensions,
                       ExtensionList disabled_extensions) {
     registry_->ClearAll();
     for (ExtensionList::const_iterator it = extensions.begin();
          it != extensions.end(); ++it) {
       registry_->AddEnabled(*it);
     }
@@ skipping 12 matching lines @@
   explicit ServiceForDownloadTests(TestExtensionPrefs* prefs)
       : MockService(prefs) {
   }
 
   // Add a fake crx installer to be returned by a call to UpdateExtension()
   // with a specific ID.  Caller keeps ownership of |crx_installer|.
   void AddFakeCrxInstaller(const std::string& id, CrxInstaller* crx_installer) {
     fake_crx_installers_[id] = crx_installer;
   }
 
-  virtual bool UpdateExtension(
-      const std::string& id,
-      const base::FilePath& extension_path,
-      bool file_ownership_passed,
-      CrxInstaller** out_crx_installer) override {
+  bool UpdateExtension(const std::string& id,
+                       const base::FilePath& extension_path,
+                       bool file_ownership_passed,
+                       CrxInstaller** out_crx_installer) override {
     extension_id_ = id;
     install_path_ = extension_path;
 
     if (ContainsKey(fake_crx_installers_, id)) {
       *out_crx_installer = fake_crx_installers_[id];
       return true;
     }
 
     return false;
   }
 
-  virtual PendingExtensionManager* pending_extension_manager() override {
+  PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
 
-  virtual const Extension* GetExtensionById(
-      const std::string& id, bool) const override {
+  const Extension* GetExtensionById(const std::string& id,
+                                    bool) const override {
     last_inquired_extension_id_ = id;
     return NULL;
   }
 
   const std::string& extension_id() const { return extension_id_; }
   const base::FilePath& install_path() const { return install_path_; }
 
  private:
   // Hold the set of ids that UpdateExtension() should fake success on.
   // UpdateExtension(id, ...) will return true iff fake_crx_installers_
@@ skipping 1536 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions