replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/custom_handlers/protocol_handler_registry_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 "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <set>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 48 matching lines @@
 // FakeURLRequestJobFactory returns NULL for all job creation requests and false
 // for all IsHandled*() requests. FakeURLRequestJobFactory can be chained to
 // ProtocolHandlerRegistry::JobInterceptorFactory so the result of
 // MaybeCreateJobWithProtocolHandler() indicates whether the
 // ProtocolHandlerRegistry properly handled a job creation request.
 class FakeURLRequestJobFactory : public net::URLRequestJobFactory {
   // net::URLRequestJobFactory implementation:
   virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return NULL;
   }
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
+  virtual bool IsHandledProtocol(const std::string& scheme) const override {
     return false;
   }
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
+  virtual bool IsHandledURL(const GURL& url) const override {
     return false;
   }
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override {
     return true;
   }
 };
 
 void AssertWillHandleIO(
     const std::string& scheme,
     bool expected,
     ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   interceptor->Chain(scoped_ptr<net::URLRequestJobFactory>(
@@ skipping 29 matching lines @@
                                                           bool is_default) {
   base::DictionaryValue* value = GetProtocolHandlerValue(protocol, url);
   value->SetBoolean("default", is_default);
   return value;
 }
 
 class FakeDelegate : public ProtocolHandlerRegistry::Delegate {
  public:
   FakeDelegate() : force_os_failure_(false) {}
   virtual ~FakeDelegate() { }
-  virtual void RegisterExternalHandler(const std::string& protocol) OVERRIDE {
+  virtual void RegisterExternalHandler(const std::string& protocol) override {
     ASSERT_TRUE(
         registered_protocols_.find(protocol) == registered_protocols_.end());
     registered_protocols_.insert(protocol);
   }
 
-  virtual void DeregisterExternalHandler(const std::string& protocol) OVERRIDE {
+  virtual void DeregisterExternalHandler(const std::string& protocol) override {
     registered_protocols_.erase(protocol);
   }
 
   virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker(
     ShellIntegration::DefaultWebClientObserver* observer,
-    const std::string& protocol) OVERRIDE;
+    const std::string& protocol) override;
 
   virtual ProtocolHandlerRegistry::DefaultClientObserver* CreateShellObserver(
-      ProtocolHandlerRegistry* registry) OVERRIDE;
+      ProtocolHandlerRegistry* registry) override;
 
   virtual void RegisterWithOSAsDefaultClient(
       const std::string& protocol,
-      ProtocolHandlerRegistry* reg) OVERRIDE {
+      ProtocolHandlerRegistry* reg) override {
     ProtocolHandlerRegistry::Delegate::RegisterWithOSAsDefaultClient(protocol,
                                                                      reg);
     ASSERT_FALSE(IsFakeRegisteredWithOS(protocol));
   }
 
   virtual bool IsExternalHandlerRegistered(
-      const std::string& protocol) OVERRIDE {
+      const std::string& protocol) override {
     return registered_protocols_.find(protocol) != registered_protocols_.end();
   }
 
   bool IsFakeRegisteredWithOS(const std::string& protocol) {
     return os_registered_protocols_.find(protocol) !=
         os_registered_protocols_.end();
   }
 
   void FakeRegisterWithOS(const std::string& protocol) {
     os_registered_protocols_.insert(protocol);
@@ skipping 17 matching lines @@
 
 class FakeClientObserver
     : public ProtocolHandlerRegistry::DefaultClientObserver {
  public:
   FakeClientObserver(ProtocolHandlerRegistry* registry,
                      FakeDelegate* registry_delegate)
       : ProtocolHandlerRegistry::DefaultClientObserver(registry),
         delegate_(registry_delegate) {}
 
   virtual void SetDefaultWebClientUIState(
-      ShellIntegration::DefaultWebClientUIState state) OVERRIDE {
+      ShellIntegration::DefaultWebClientUIState state) override {
     ProtocolHandlerRegistry::DefaultClientObserver::SetDefaultWebClientUIState(
         state);
     if (state == ShellIntegration::STATE_IS_DEFAULT) {
       delegate_->FakeRegisterWithOS(worker_->protocol());
     }
     if (state != ShellIntegration::STATE_PROCESSING) {
       base::MessageLoop::current()->Quit();
     }
   }
 
  private:
   FakeDelegate* delegate_;
 };
 
 class FakeProtocolClientWorker
     : public ShellIntegration::DefaultProtocolClientWorker {
  public:
   FakeProtocolClientWorker(ShellIntegration::DefaultWebClientObserver* observer,
                            const std::string& protocol,
                            bool force_failure)
       : ShellIntegration::DefaultProtocolClientWorker(observer, protocol),
         force_failure_(force_failure) {}
 
  private:
   virtual ~FakeProtocolClientWorker() {}
 
-  virtual ShellIntegration::DefaultWebClientState CheckIsDefault() OVERRIDE {
+  virtual ShellIntegration::DefaultWebClientState CheckIsDefault() override {
     if (force_failure_) {
       return ShellIntegration::NOT_DEFAULT;
     } else {
       return ShellIntegration::IS_DEFAULT;
     }
   }
 
-  virtual bool SetAsDefault(bool interactive_permitted) OVERRIDE {
+  virtual bool SetAsDefault(bool interactive_permitted) override {
     return true;
   }
 
  private:
   bool force_failure_;
 };
 
 ProtocolHandlerRegistry::DefaultClientObserver*
     FakeDelegate::CreateShellObserver(ProtocolHandlerRegistry* registry) {
   return new FakeClientObserver(registry, this);
@@ skipping 13 matching lines @@
     notification_registrar_.Add(this,
         chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
             content::Source<content::BrowserContext>(context));
   }
 
   int events() { return events_; }
   bool notified() { return events_ > 0; }
   void Clear() { events_ = 0; }
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     ++events_;
   }
 
   int events_;
   content::NotificationRegistrar notification_registrar_;
 };
 
 class QueryProtocolHandlerOnChange
     : public content::NotificationObserver {
  public:
   QueryProtocolHandlerOnChange(content::BrowserContext* context,
                                ProtocolHandlerRegistry* registry)
     : local_registry_(registry),
       called_(false),
       notification_registrar_() {
     notification_registrar_.Add(this,
         chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
             content::Source<content::BrowserContext>(context));
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     std::vector<std::string> output;
     local_registry_->GetRegisteredProtocols(&output);
     called_ = true;
   }
 
   ProtocolHandlerRegistry* local_registry_;
   bool called_;
   content::NotificationRegistrar notification_registrar_;
 };
 
 // URLRequest DCHECKS that the current MessageLoop is IO. It does this because
 // it can't check the thread id (since net can't depend on content.) We want
 // to harness our tests so all threads use the same loop allowing us to
 // guarantee all messages are processed.) By overriding the IsType method
 // we basically ignore the supplied message loop type, and instead infer
 // our type based on the current thread. GO DEPENDENCY INJECTION!
 class TestMessageLoop : public base::MessageLoop {
  public:
   TestMessageLoop() {}
   virtual ~TestMessageLoop() {}
-  virtual bool IsType(base::MessageLoop::Type type) const OVERRIDE {
+  virtual bool IsType(base::MessageLoop::Type type) const override {
     switch (type) {
       case base::MessageLoop::TYPE_UI:
         return BrowserThread::CurrentlyOn(BrowserThread::UI);
       case base::MessageLoop::TYPE_IO:
         return BrowserThread::CurrentlyOn(BrowserThread::IO);
 #if defined(OS_ANDROID)
       case base::MessageLoop::TYPE_JAVA: // fall-through
 #endif // defined(OS_ANDROID)
       case base::MessageLoop::TYPE_CUSTOM:
       case base::MessageLoop::TYPE_DEFAULT:
@@ skipping 800 matching lines @@
   // added to pref.
   ASSERT_EQ(InPrefIgnoredHandlerCount(), 2);
   ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4);
 
   registry()->RemoveIgnoredHandler(p2u1);
 
   // p2u1 installed by user and policy, so it is removed from pref alone.
   ASSERT_EQ(InPrefIgnoredHandlerCount(), 1);
   ASSERT_EQ(InMemoryIgnoredHandlerCount(), 4);
 }