Standardize usage of virtual/override/final in mojo/

mojo/application_manager/application_manager.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 "mojo/application_manager/application_manager.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 11 matching lines @@
 
 namespace {
 // Used by TestAPI.
 bool has_created_instance = false;
 
 class StubServiceProvider : public InterfaceImpl<ServiceProvider> {
  public:
   ServiceProvider* GetRemoteServiceProvider() { return client(); }
 
  private:
-  virtual void ConnectToService(
-      const String& service_name,
-      ScopedMessagePipeHandle client_handle) override {}
+  void ConnectToService(const String& service_name,
+                        ScopedMessagePipeHandle client_handle) override {}
 };
 
 }  // namespace
 
 ApplicationManager::Delegate::~Delegate() {}
 
 class ApplicationManager::LoadCallbacksImpl
     : public ApplicationLoader::LoadCallbacks {
  public:
   LoadCallbacksImpl(base::WeakPtr<ApplicationManager> manager,
                     const GURL& requested_url,
                     const GURL& requestor_url,
                     ServiceProviderPtr service_provider)
       : manager_(manager),
         requested_url_(requested_url),
         requestor_url_(requestor_url),
         service_provider_(service_provider.Pass()) {}
 
  private:
-  virtual ~LoadCallbacksImpl() {}
+  ~LoadCallbacksImpl() override {}
 
   // LoadCallbacks implementation
-  virtual ScopedMessagePipeHandle RegisterApplication() override {
+  ScopedMessagePipeHandle RegisterApplication() override {
     ScopedMessagePipeHandle shell_handle;
     if (manager_) {
       manager_->RegisterLoadedApplication(requested_url_,
                                           requestor_url_,
                                           service_provider_.Pass(),
                                           &shell_handle);
     }
     return shell_handle.Pass();
   }
 
-  virtual void LoadWithContentHandler(const GURL& content_handler_url,
-                                      URLResponsePtr url_response) override {
+  void LoadWithContentHandler(const GURL& content_handler_url,
+                              URLResponsePtr url_response) override {
     if (manager_) {
       manager_->LoadWithContentHandler(requested_url_,
                                        requestor_url_,
                                        content_handler_url,
                                        url_response.Pass(),
                                        service_provider_.Pass());
     }
   }
 
   base::WeakPtr<ApplicationManager> manager_;
   GURL requested_url_;
   GURL requestor_url_;
   ServiceProviderPtr service_provider_;
 };
 
 class ApplicationManager::ShellImpl : public InterfaceImpl<Shell> {
  public:
   ShellImpl(ApplicationManager* manager, const GURL& url)
       : manager_(manager), url_(url) {}
 
-  virtual ~ShellImpl() {}
+  ~ShellImpl() override {}
 
   void ConnectToClient(const GURL& requestor_url,
                        ServiceProviderPtr service_provider) {
     client()->AcceptConnection(String::From(requestor_url),
                                service_provider.Pass());
   }
 
   // ServiceProvider implementation:
-  virtual void ConnectToApplication(
+  void ConnectToApplication(
       const String& app_url,
       InterfaceRequest<ServiceProvider> in_service_provider) override {
     ServiceProviderPtr out_service_provider;
     out_service_provider.Bind(in_service_provider.PassMessagePipe());
     manager_->ConnectToApplication(
         app_url.To<GURL>(), url_, out_service_provider.Pass());
   }
 
   const GURL& url() const { return url_; }
 
  private:
-  virtual void OnConnectionError() override {
-    manager_->OnShellImplError(this);
-  }
+  void OnConnectionError() override { manager_->OnShellImplError(this); }
 
   ApplicationManager* const manager_;
   const GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellImpl);
 };
 
 struct ApplicationManager::ContentHandlerConnection {
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url) {
@@ skipping 195 matching lines @@
   StubServiceProvider* stub_sp = new StubServiceProvider;
   ServiceProviderPtr spp;
   BindToProxy(stub_sp, &spp);
   ConnectToApplication(application_url, GURL(), spp.Pass());
   MessagePipe pipe;
   stub_sp->GetRemoteServiceProvider()->ConnectToService(interface_name,
                                                         pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 }  // namespace mojo