replace OVERRIDE and FINAL with override and 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 220 matching lines @@
     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 {
+                       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 35 matching lines @@
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
       : prefs_(prefs),
         pending_extension_manager_(&profile_),
         downloader_delegate_override_(NULL) {
   }
 
   virtual ~MockService() {}
 
-  virtual PendingExtensionManager* pending_extension_manager() OVERRIDE {
+  virtual 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 126 matching lines @@
 class ServiceForManifestTests : public MockService {
  public:
   explicit ServiceForManifestTests(TestExtensionPrefs* prefs)
       : MockService(prefs),
         registry_(ExtensionRegistry::Get(profile())) {
   }
 
   virtual ~ServiceForManifestTests() {}
 
   virtual const Extension* GetExtensionById(
-      const std::string& id, bool include_disabled) const OVERRIDE {
+      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 {
+  virtual const ExtensionSet* extensions() const override {
     return &registry_->enabled_extensions();
   }
 
-  virtual PendingExtensionManager* pending_extension_manager() OVERRIDE {
+  virtual PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
 
   virtual const Extension* GetPendingExtensionUpdate(
-      const std::string& id) const OVERRIDE {
+      const std::string& id) const override {
     return NULL;
   }
 
-  virtual bool IsExtensionEnabled(const std::string& id) const OVERRIDE {
+  virtual 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 16 matching lines @@
   // 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 {
+      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 {
+  virtual PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
 
   virtual const Extension* GetExtensionById(
-      const std::string& id, bool) const OVERRIDE {
+      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 58 matching lines @@
 
 // All of our tests that need to use private APIs of ExtensionUpdater live
 // inside this class (which is a friend to ExtensionUpdater).
 class ExtensionUpdaterTest : public testing::Test {
  public:
   ExtensionUpdaterTest()
       : thread_bundle_(
             content::TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     prefs_.reset(new TestExtensionPrefs(base::MessageLoopProxy::current()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Some tests create URLRequestContextGetters, whose destruction must run
     // on the IO thread. Make sure the IO loop spins before shutdown so that
     // those objects are released.
     RunUntilIdle();
     prefs_.reset();
   }
 
   void RunUntilIdle() {
     prefs_->pref_service()->CommitPendingWrite();
     base::RunLoop().RunUntilIdle();
@@ skipping 1455 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