Standardize usage of virtual/override/final in mojo/

mojo/application_manager/application_manager_unittest.cc

Index: mojo/application_manager/application_manager_unittest.cc
diff --git a/mojo/application_manager/application_manager_unittest.cc b/mojo/application_manager/application_manager_unittest.cc
index 1800dce3dfb113480db7190f572ce495c47e1dd2..27688c68907fbc39bfc6f7f576bf19b0a6cc28f1 100644
--- a/mojo/application_manager/application_manager_unittest.cc
+++ b/mojo/application_manager/application_manager_unittest.cc
@@ -34,10 +34,10 @@ struct TestContext {
 class QuitMessageLoopErrorHandler : public ErrorHandler {
  public:
   QuitMessageLoopErrorHandler() {}
-  virtual ~QuitMessageLoopErrorHandler() {}
+  ~QuitMessageLoopErrorHandler() override {}
 
   // |ErrorHandler| implementation:
-  virtual void OnConnectionError() override {
+  void OnConnectionError() override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
@@ -51,16 +51,16 @@ class TestServiceImpl : public InterfaceImpl<TestService> {
     ++context_->num_impls;
   }
 
-  virtual ~TestServiceImpl() { --context_->num_impls; }
+  ~TestServiceImpl() override { --context_->num_impls; }
 
-  virtual void OnConnectionError() override {
+  void OnConnectionError() override {
     if (!base::MessageLoop::current()->is_running())
       return;
     base::MessageLoop::current()->Quit();
   }
 
   // TestService implementation:
-  virtual void Test(const String& test_string) override {
+  void Test(const String& test_string) override {
     context_->last_test_string = test_string;
     client()->AckTest();
   }
@@ -76,9 +76,9 @@ class TestClientImpl : public TestClient {
     service_.set_client(this);
   }
 
-  virtual ~TestClientImpl() { service_.reset(); }
+  ~TestClientImpl() override { service_.reset(); }
 
-  virtual void AckTest() override {
+  void AckTest() override {
     if (quit_after_ack_)
       base::MessageLoop::current()->Quit();
   }
@@ -100,7 +100,7 @@ class TestApplicationLoader : public ApplicationLoader,
  public:
   TestApplicationLoader() : context_(NULL), num_loads_(0) {}
 
-  virtual ~TestApplicationLoader() {
+  ~TestApplicationLoader() override {
     if (context_)
       ++context_->num_loader_deletes;
     test_app_.reset(NULL);
@@ -112,27 +112,26 @@ class TestApplicationLoader : public ApplicationLoader,
 
  private:
   // ApplicationLoader implementation.
-  virtual void Load(ApplicationManager* manager,
-                    const GURL& url,
-                    scoped_refptr<LoadCallbacks> callbacks) override {
+  void Load(ApplicationManager* manager,
+            const GURL& url,
+            scoped_refptr<LoadCallbacks> callbacks) override {
     ++num_loads_;
     test_app_.reset(
         new ApplicationImpl(this, callbacks->RegisterApplication().Pass()));
   }
 
-  virtual void OnApplicationError(ApplicationManager* manager,
-                                  const GURL& url) override {}
+  void OnApplicationError(ApplicationManager* manager,
+                          const GURL& url) override {}
 
   // ApplicationDelegate implementation.
-  virtual bool ConfigureIncomingConnection(
-      ApplicationConnection* connection) override {
+  bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService(this);
     return true;
   }
 
   // InterfaceFactory implementation.
-  virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestService> request) override {
+  void Create(ApplicationConnection* connection,
+              InterfaceRequest<TestService> request) override {
     BindToRequest(new TestServiceImpl(context_), &request);
   }
 
@@ -244,18 +243,18 @@ class TestAImpl : public InterfaceImpl<TestA> {
       : test_context_(test_context) {
     connection->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
   }
-  virtual ~TestAImpl() {
+  ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
-  virtual void CallB() override {
+  void CallB() override {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
-  virtual void CallCFromB() override {
+  void CallCFromB() override {
     b_->CallC(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
@@ -276,7 +275,7 @@ class TestBImpl : public InterfaceImpl<TestB> {
     connection->ConnectToService(&c_);
   }
 
-  virtual ~TestBImpl() {
+  ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
@@ -284,12 +283,12 @@ class TestBImpl : public InterfaceImpl<TestB> {
   }
 
  private:
-  virtual void B(const mojo::Callback<void()>& callback) override {
+  void B(const mojo::Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
-  virtual void CallC(const mojo::Callback<void()>& callback) override {
+  void CallC(const mojo::Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     c_->C(callback);
   }
@@ -303,10 +302,10 @@ class TestCImpl : public InterfaceImpl<TestC> {
   TestCImpl(ApplicationConnection* connection, TesterContext* test_context)
       : test_context_(test_context) {}
 
-  virtual ~TestCImpl() { test_context_->IncrementNumCDeletes(); }
+  ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
 
  private:
-  virtual void C(const mojo::Callback<void()>& callback) override {
+  void C(const mojo::Callback<void()>& callback) override {
     test_context_->IncrementNumCCalls();
     callback.Run();
   }
@@ -321,21 +320,20 @@ class Tester : public ApplicationDelegate,
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
-  virtual ~Tester() {}
+  ~Tester() override {}
 
  private:
-  virtual void Load(ApplicationManager* manager,
-                    const GURL& url,
-                    scoped_refptr<LoadCallbacks> callbacks) override {
+  void Load(ApplicationManager* manager,
+            const GURL& url,
+            scoped_refptr<LoadCallbacks> callbacks) override {
     app_.reset(
         new ApplicationImpl(this, callbacks->RegisterApplication().Pass()));
   }
 
-  virtual void OnApplicationError(ApplicationManager* manager,
-                                  const GURL& url) override {}
+  void OnApplicationError(ApplicationManager* manager,
+                          const GURL& url) override {}
 
-  virtual bool ConfigureIncomingConnection(
-      ApplicationConnection* connection) override {
+  bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     if (!requestor_url_.empty() &&
         requestor_url_ != connection->GetRemoteApplicationURL()) {
       context_->set_tester_called_quit();
@@ -351,26 +349,25 @@ class Tester : public ApplicationDelegate,
     return true;
   }
 
-  virtual bool ConfigureOutgoingConnection(
-      ApplicationConnection* connection) override {
+  bool ConfigureOutgoingConnection(ApplicationConnection* connection) override {
     // If we're connecting to B, then add C.
     if (connection->GetRemoteApplicationURL() == kTestBURLString)
       connection->AddService<TestC>(this);
     return true;
   }
 
-  virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestA> request) override {
+  void Create(ApplicationConnection* connection,
+              InterfaceRequest<TestA> request) override {
     BindToRequest(new TestAImpl(connection, context_), &request);
   }
 
-  virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestB> request) override {
+  void Create(ApplicationConnection* connection,
+              InterfaceRequest<TestB> request) override {
     BindToRequest(new TestBImpl(connection, context_), &request);
   }
 
-  virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestC> request) override {
+  void Create(ApplicationConnection* connection,
+              InterfaceRequest<TestC> request) override {
     BindToRequest(new TestCImpl(connection, context_), &request);
   }
 
@@ -383,7 +380,7 @@ class TestServiceInterceptor : public ApplicationManager::Interceptor {
  public:
   TestServiceInterceptor() : call_count_(0) {}
 
-  virtual ServiceProviderPtr OnConnectToClient(
+  ServiceProviderPtr OnConnectToClient(
       const GURL& url,
       ServiceProviderPtr service_provider) override {
     ++call_count_;