Linux/ChromeOS Chromium style checker cleanup, chrome/browser edition.

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.h"
@@ skipping 52 matching lines @@
                                   ProtocolHandler* protocol_handler) OVERRIDE {
     return false;
   }
   virtual void AddInterceptor(Interceptor* interceptor) OVERRIDE {
   }
   virtual net::URLRequestJob* MaybeCreateJobWithInterceptor(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
-  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+  virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
-  net::URLRequestJob* MaybeInterceptRedirect(
+  virtual net::URLRequestJob* MaybeInterceptRedirect(
       const GURL& location,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
-  net::URLRequestJob* MaybeInterceptResponse(
+  virtual net::URLRequestJob* MaybeInterceptResponse(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
   virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
     return false;
   }
   virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
     return false;
   }
@@ skipping 21 matching lines @@
                                      scheme,
                                      expected,
                                      base::Unretained(interceptor)));
   MessageLoop::current()->RunUntilIdle();
 }
 
 class FakeDelegate : public ProtocolHandlerRegistry::Delegate {
  public:
   FakeDelegate() : force_os_failure_(false) {}
   virtual ~FakeDelegate() { }
-  virtual void RegisterExternalHandler(const std::string& protocol) {
+  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) {
+  virtual void DeregisterExternalHandler(const std::string& protocol) OVERRIDE {
     registered_protocols_.erase(protocol);
   }
 
   virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker(
     ShellIntegration::DefaultWebClientObserver* observer,
-    const std::string& protocol);
+    const std::string& protocol) OVERRIDE;
 
   virtual ProtocolHandlerRegistry::DefaultClientObserver* CreateShellObserver(
-      ProtocolHandlerRegistry* registry);
+      ProtocolHandlerRegistry* registry) OVERRIDE;
 
-  virtual void RegisterWithOSAsDefaultClient(const std::string& protocol,
-                                             ProtocolHandlerRegistry* reg) {
+  virtual void RegisterWithOSAsDefaultClient(
+      const std::string& protocol,
+      ProtocolHandlerRegistry* reg) OVERRIDE {
     ProtocolHandlerRegistry::Delegate::RegisterWithOSAsDefaultClient(protocol,
                                                                      reg);
     ASSERT_FALSE(IsFakeRegisteredWithOS(protocol));
   }
 
-  virtual bool IsExternalHandlerRegistered(const std::string& protocol) {
+  virtual bool IsExternalHandlerRegistered(
+      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) {
+      ShellIntegration::DefaultWebClientUIState state) OVERRIDE {
     ProtocolHandlerRegistry::DefaultClientObserver::SetDefaultWebClientUIState(
         state);
     if (state == ShellIntegration::STATE_IS_DEFAULT) {
       delegate_->FakeRegisterWithOS(worker_->protocol());
     }
     if (state != ShellIntegration::STATE_PROCESSING) {
       MessageLoop::current()->Quit();
     }
   }
 
@@ skipping 48 matching lines @@
     notification_registrar_.Add(this,
         chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
         content::Source<Profile>(profile));
   }
 
   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) {
+                       const content::NotificationDetails& details) OVERRIDE {
     ++events_;
   }
 
   int events_;
   content::NotificationRegistrar notification_registrar_;
 };
 
 class QueryProtocolHandlerOnChange
     : public content::NotificationObserver {
  public:
   QueryProtocolHandlerOnChange(Profile* profile,
                                ProtocolHandlerRegistry* registry)
     : local_registry_(registry),
       called_(false),
       notification_registrar_() {
     notification_registrar_.Add(this,
         chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
         content::Source<Profile>(profile));
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) {
+                       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 MessageLoop {
  public:
   TestMessageLoop() : MessageLoop(MessageLoop::TYPE_DEFAULT) {}
-  ~TestMessageLoop() {}
+  virtual ~TestMessageLoop() {}
   virtual bool IsType(MessageLoop::Type type) const OVERRIDE {
     switch (type) {
        case MessageLoop::TYPE_UI:
          return BrowserThread::CurrentlyOn(BrowserThread::UI);
        case MessageLoop::TYPE_IO:
          return BrowserThread::CurrentlyOn(BrowserThread::IO);
        case MessageLoop::TYPE_DEFAULT:
          return !BrowserThread::CurrentlyOn(BrowserThread::UI) &&
              !BrowserThread::CurrentlyOn(BrowserThread::IO);
     }
@@ skipping 626 matching lines @@
 
 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestInstallDefaultHandler) {
   RecreateRegistry(false);
   registry()->AddPredefinedHandler(CreateProtocolHandler(
       "test", GURL("http://test.com/%s"), "Test"));
   registry()->InitProtocolSettings();
   std::vector<std::string> protocols;
   registry()->GetRegisteredProtocols(&protocols);
   ASSERT_EQ(static_cast<size_t>(1), protocols.size());
 }