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

chrome/browser/extensions/extension_system_impl.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 "chrome/browser/extensions/extension_system_impl.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 143 matching lines @@
 
 namespace {
 
 class ContentVerifierDelegateImpl : public ContentVerifierDelegate {
  public:
   explicit ContentVerifierDelegateImpl(ExtensionService* service)
       : service_(service->AsWeakPtr()), default_mode_(GetDefaultMode()) {}
 
   virtual ~ContentVerifierDelegateImpl() {}
 
-  virtual Mode ShouldBeVerified(const Extension& extension) OVERRIDE {
+  virtual Mode ShouldBeVerified(const Extension& extension) override {
 #if defined(OS_CHROMEOS)
     if (ExtensionAssetsManagerChromeOS::IsSharedInstall(&extension))
       return ContentVerifierDelegate::ENFORCE_STRICT;
 #endif
 
     if (!extension.is_extension() && !extension.is_legacy_packaged_app())
       return ContentVerifierDelegate::NONE;
     if (!Manifest::IsAutoUpdateableLocation(extension.location()))
       return ContentVerifierDelegate::NONE;
 
     if (!ManifestURL::UpdatesFromGallery(&extension)) {
       // It's possible that the webstore update url was overridden for testing
       // so also consider extensions with the default (production) update url
       // to be from the store as well.
       GURL default_webstore_url = extension_urls::GetDefaultWebstoreUpdateUrl();
       if (ManifestURL::GetUpdateURL(&extension) != default_webstore_url)
         return ContentVerifierDelegate::NONE;
     }
 
     return default_mode_;
   }
 
-  virtual const ContentVerifierKey& PublicKey() OVERRIDE {
+  virtual const ContentVerifierKey& PublicKey() override {
     static ContentVerifierKey key(
         extension_misc::kWebstoreSignaturesPublicKey,
         extension_misc::kWebstoreSignaturesPublicKeySize);
     return key;
   }
 
   virtual GURL GetSignatureFetchUrl(const std::string& extension_id,
-                                    const base::Version& version) OVERRIDE {
+                                    const base::Version& version) override {
     // TODO(asargent) Factor out common code from the extension updater's
     // ManifestFetchData class that can be shared for use here.
     std::vector<std::string> parts;
     parts.push_back("uc");
     parts.push_back("installsource=signature");
     parts.push_back("id=" + extension_id);
     parts.push_back("v=" + version.GetString());
     std::string x_value =
         net::EscapeQueryParamValue(JoinString(parts, "&"), true);
     std::string query = "response=redirect&x=" + x_value;
 
     GURL base_url = extension_urls::GetWebstoreUpdateUrl();
     GURL::Replacements replacements;
     replacements.SetQuery(query.c_str(), url::Component(0, query.length()));
     return base_url.ReplaceComponents(replacements);
   }
 
   virtual std::set<base::FilePath> GetBrowserImagePaths(
-      const extensions::Extension* extension) OVERRIDE {
+      const extensions::Extension* extension) override {
     return extension_file_util::GetBrowserImagePaths(extension);
   }
 
-  virtual void VerifyFailed(const std::string& extension_id) OVERRIDE {
+  virtual void VerifyFailed(const std::string& extension_id) override {
     if (!service_)
       return;
     ExtensionRegistry* registry = ExtensionRegistry::Get(service_->profile());
     const Extension* extension =
         registry->GetExtensionById(extension_id, ExtensionRegistry::ENABLED);
     if (!extension)
       return;
     Mode mode = ShouldBeVerified(*extension);
     if (mode >= ContentVerifierDelegate::ENFORCE) {
       service_->DisableExtension(extension_id, Extension::DISABLE_CORRUPTED);
@@ skipping 419 matching lines @@
 void ExtensionSystemImpl::UnregisterExtensionWithRequestContexts(
     const std::string& extension_id,
     const UnloadedExtensionInfo::Reason reason) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&InfoMap::RemoveExtension, info_map(), extension_id, reason));
 }
 
 }  // namespace extensions