replace OVERRIDE and FINAL with override and final in chrome/browser/extensions/

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 237 matching lines @@
                             const std::string& version,
                             const base::FilePath& path) {
     extension_map_[id] = std::make_pair(version, path);
   }
 
   void RemoveExtension(const std::string& id) {
     extension_map_.erase(id);
   }
 
   // ExternalProvider implementation:
-  virtual void VisitRegisteredExtension() OVERRIDE {
+  virtual void VisitRegisteredExtension() override {
     visit_count_++;
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
       Version version(i->second.first);
 
       visitor_->OnExternalExtensionFileFound(
           i->first, &version, i->second.second, location_,
           Extension::NO_FLAGS, false);
     }
     visitor_->OnExternalProviderReady(this);
   }
 
-  virtual bool HasExtension(const std::string& id) const OVERRIDE {
+  virtual bool HasExtension(const std::string& id) const override {
     return extension_map_.find(id) != extension_map_.end();
   }
 
   virtual bool GetExtensionDetails(
       const std::string& id,
       Manifest::Location* location,
-      scoped_ptr<Version>* version) const OVERRIDE {
+      scoped_ptr<Version>* version) const override {
     DataMap::const_iterator it = extension_map_.find(id);
     if (it == extension_map_.end())
       return false;
 
     if (version)
       version->reset(new Version(it->second.first));
 
     if (location)
       *location = location_;
 
     return true;
   }
 
-  virtual bool IsReady() const OVERRIDE {
+  virtual bool IsReady() const override {
     return true;
   }
 
-  virtual void ServiceShutdown() OVERRIDE {
+  virtual void ServiceShutdown() override {
   }
 
   int visit_count() const { return visit_count_; }
   void set_visit_count(int visit_count) {
     visit_count_ = visit_count;
   }
 
  private:
   typedef std::map< std::string, std::pair<std::string, base::FilePath> >
       DataMap;
@@ skipping 60 matching lines @@
     provider_->VisitRegisteredExtension();
 
     return ids_found_;
   }
 
   virtual bool OnExternalExtensionFileFound(const std::string& id,
                                             const Version* version,
                                             const base::FilePath& path,
                                             Manifest::Location unused,
                                             int creation_flags,
-                                            bool mark_acknowledged) OVERRIDE {
+                                            bool mark_acknowledged) override {
     EXPECT_EQ(expected_creation_flags_, creation_flags);
 
     ++ids_found_;
     base::DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << "Got back ID (" << id.c_str() << ") we weren't expecting";
 
@@ skipping 23 matching lines @@
     }
     return true;
   }
 
   virtual bool OnExternalExtensionUpdateUrlFound(
       const std::string& id,
       const std::string& install_parameter,
       const GURL& update_url,
       Manifest::Location location,
       int creation_flags,
-      bool mark_acknowledged) OVERRIDE {
+      bool mark_acknowledged) override {
     ++ids_found_;
     base::DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << L"Got back ID (" << id.c_str() << ") we weren't expecting";
     EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
 
     if (pref) {
@@ skipping 10 matching lines @@
       pref->GetString("install_parameter", &parsed_install_parameter);
       EXPECT_EQ(parsed_install_parameter, install_parameter);
 
       // Remove it so we won't count it again.
       prefs_->Remove(id, NULL);
     }
     return true;
   }
 
   virtual void OnExternalProviderReady(
-      const extensions::ExternalProviderInterface* provider) OVERRIDE {
+      const extensions::ExternalProviderInterface* provider) override {
     EXPECT_EQ(provider, provider_.get());
     EXPECT_TRUE(provider->IsReady());
   }
 
  private:
   int ids_found_;
   base::FilePath fake_base_path_;
   int expected_creation_flags_;
   scoped_ptr<extensions::ExternalProviderImpl> provider_;
   scoped_ptr<base::DictionaryValue> prefs_;
@@ skipping 20 matching lines @@
                    extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                    content::NotificationService::AllSources());
     registrar_.Add(
         this,
         extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
         content::NotificationService::AllSources());
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     switch (type) {
       case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
         loaded_.push_back(make_scoped_refptr(extension));
         // The tests rely on the errors being in a certain order, which can vary
         // depending on how filesystem iteration works.
         std::stable_sort(loaded_.begin(), loaded_.end(), ExtensionsOrder());
         break;
       }
@@ skipping 644 matching lines @@
   content::NotificationRegistrar registrar_;
 };
 
 // Receives notifications from a PackExtensionJob, indicating either that
 // packing succeeded or that there was some error.
 class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
  public:
   PackExtensionTestClient(const base::FilePath& expected_crx_path,
                           const base::FilePath& expected_private_key_path);
   virtual void OnPackSuccess(const base::FilePath& crx_path,
-                             const base::FilePath& private_key_path) OVERRIDE;
+                             const base::FilePath& private_key_path) override;
   virtual void OnPackFailure(const std::string& error_message,
-                             ExtensionCreator::ErrorType type) OVERRIDE;
+                             ExtensionCreator::ErrorType type) override;
 
  private:
   const base::FilePath expected_crx_path_;
   const base::FilePath expected_private_key_path_;
   DISALLOW_COPY_AND_ASSIGN(PackExtensionTestClient);
 };
 
 PackExtensionTestClient::PackExtensionTestClient(
     const base::FilePath& expected_crx_path,
     const base::FilePath& expected_private_key_path)
@@ skipping 288 matching lines @@
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 struct MockExtensionRegistryObserver
     : public extensions::ExtensionRegistryObserver {
   virtual void OnExtensionWillBeInstalled(
       content::BrowserContext* browser_context,
       const Extension* extension,
       bool is_update,
       bool from_ephemeral,
-      const std::string& old_name) OVERRIDE {
+      const std::string& old_name) override {
     last_extension_installed = extension->id();
   }
 
   virtual void OnExtensionUninstalled(
       content::BrowserContext* browser_context,
       const Extension* extension,
-      extensions::UninstallReason reason) OVERRIDE {
+      extensions::UninstallReason reason) override {
     last_extension_uninstalled = extension->id();
   }
 
   std::string last_extension_installed;
   std::string last_extension_uninstalled;
 };
 
 // Test that correct notifications are sent to ExtensionRegistryObserver on
 // extension install and uninstall.
 TEST_F(ExtensionServiceTest, InstallObserverNotified) {
@@ skipping 3640 matching lines @@
                    extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
                    content::NotificationService::AllSources());
   }
 
   void set_ready(bool value) { ready_ = value; }
   bool ready() { return ready_; }
 
  private:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     switch (type) {
       case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED:
         ready_ = true;
         break;
       default:
         NOTREACHED();
     }
   }
 
   content::NotificationRegistrar registrar_;
@@ skipping 2001 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }