Standardize usage of virtual/override/final in mojo/

mojo/application_manager/application_manager_unittest.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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
@@ skipping 16 matching lines @@
 struct TestContext {
   TestContext() : num_impls(0), num_loader_deletes(0) {}
   std::string last_test_string;
   int num_impls;
   int num_loader_deletes;
 };
 
 class QuitMessageLoopErrorHandler : public ErrorHandler {
  public:
   QuitMessageLoopErrorHandler() {}
-  virtual ~QuitMessageLoopErrorHandler() {}
+  ~QuitMessageLoopErrorHandler() override {}
 
   // |ErrorHandler| implementation:
-  virtual void OnConnectionError() override {
+  void OnConnectionError() override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuitMessageLoopErrorHandler);
 };
 
 class TestServiceImpl : public InterfaceImpl<TestService> {
  public:
   explicit TestServiceImpl(TestContext* context) : context_(context) {
     ++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();
   }
 
  private:
   TestContext* context_;
 };
 
 class TestClientImpl : public TestClient {
  public:
   explicit TestClientImpl(TestServicePtr service)
       : service_(service.Pass()), quit_after_ack_(false) {
     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();
   }
 
   void Test(std::string test_string) {
     quit_after_ack_ = true;
     service_->Test(test_string);
   }
 
  private:
   TestServicePtr service_;
   bool quit_after_ack_;
   DISALLOW_COPY_AND_ASSIGN(TestClientImpl);
 };
 
 class TestApplicationLoader : public ApplicationLoader,
                               public ApplicationDelegate,
                               public InterfaceFactory<TestService> {
  public:
   TestApplicationLoader() : context_(NULL), num_loads_(0) {}
 
-  virtual ~TestApplicationLoader() {
+  ~TestApplicationLoader() override {
     if (context_)
       ++context_->num_loader_deletes;
     test_app_.reset(NULL);
   }
 
   void set_context(TestContext* context) { context_ = context; }
   int num_loads() const { return num_loads_; }
   const std::vector<std::string>& GetArgs() const { return test_app_->args(); }
 
  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);
   }
 
   scoped_ptr<ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
 class TesterContext {
@@ skipping 91 matching lines @@
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public InterfaceImpl<TestA> {
  public:
   TestAImpl(ApplicationConnection* connection, TesterContext* test_context)
       : 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)));
   }
 
   void Quit() {
     base::MessageLoop::current()->Quit();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
   TesterContext* test_context_;
   TestBPtr b_;
 };
 
 class TestBImpl : public InterfaceImpl<TestB> {
  public:
   TestBImpl(ApplicationConnection* connection, TesterContext* test_context)
       : test_context_(test_context) {
     connection->ConnectToService(&c_);
   }
 
-  virtual ~TestBImpl() {
+  ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
     test_context_->QuitSoon();
   }
 
  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);
   }
 
   TesterContext* test_context_;
   TestCPtr c_;
 };
 
 class TestCImpl : public InterfaceImpl<TestC> {
  public:
   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();
   }
   TesterContext* test_context_;
 };
 
 class Tester : public ApplicationDelegate,
                public ApplicationLoader,
                public InterfaceFactory<TestA>,
                public InterfaceFactory<TestB>,
                public InterfaceFactory<TestC> {
  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();
       context_->QuitSoon();
       base::MessageLoop::current()->Quit();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     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);
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
 };
 
 class TestServiceInterceptor : public ApplicationManager::Interceptor {
  public:
   TestServiceInterceptor() : call_count_(0) {}
 
-  virtual ServiceProviderPtr OnConnectToClient(
+  ServiceProviderPtr OnConnectToClient(
       const GURL& url,
       ServiceProviderPtr service_provider) override {
     ++call_count_;
     url_ = url;
     return service_provider.Pass();
   }
 
   std::string url_spec() const {
     if (!url_.is_valid())
       return "invalid url";
@@ skipping 277 matching lines @@
   std::string url("test:test3");
   TestServicePtr test_service;
   application_manager_->ConnectToService(GURL(url), &test_service);
 
   EXPECT_EQ(1, interceptor.call_count());
   EXPECT_EQ(url, interceptor.url_spec());
   EXPECT_EQ(1, default_loader->num_loads());
 }
 
 }  // namespace mojo