Mojo: Convert OVERRIDE -> override in various subdirectories of 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"
 #include "mojo/application_manager/background_shell_application_loader.h"
 #include "mojo/application_manager/test.mojom.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
@@ skipping 12 matching lines @@
   int num_impls;
   int num_loader_deletes;
 };
 
 class QuitMessageLoopErrorHandler : public ErrorHandler {
  public:
   QuitMessageLoopErrorHandler() {}
   virtual ~QuitMessageLoopErrorHandler() {}
 
   // |ErrorHandler| implementation:
-  virtual void OnConnectionError() OVERRIDE {
+  virtual 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; }
 
-  virtual void OnConnectionError() OVERRIDE {
+  virtual void OnConnectionError() override {
     if (!base::MessageLoop::current()->is_running())
       return;
     base::MessageLoop::current()->Quit();
   }
 
   // TestService implementation:
-  virtual void Test(const String& test_string) OVERRIDE {
+  virtual 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(); }
 
-  virtual void AckTest() OVERRIDE {
+  virtual 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:
@@ skipping 17 matching lines @@
   void set_context(TestContext* context) { context_ = context; }
   int num_loads() const { return num_loads_; }
   std::vector<std::string> GetArgs() {
     return test_app_->args().To<std::vector<std::string> >();
   }
 
  private:
   // ApplicationLoader implementation.
   virtual void Load(ApplicationManager* manager,
                     const GURL& url,
-                    scoped_refptr<LoadCallbacks> callbacks) OVERRIDE {
+                    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 {}
+                                  const GURL& url) override {}
 
   // ApplicationDelegate implementation.
   virtual bool ConfigureIncomingConnection(
-      ApplicationConnection* connection) OVERRIDE {
+      ApplicationConnection* connection) override {
     connection->AddService(this);
     return true;
   }
 
   // InterfaceFactory implementation.
   virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestService> request) OVERRIDE {
+                      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 98 matching lines @@
       : test_context_(test_context) {
     connection->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
   }
   virtual ~TestAImpl() {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
-  virtual void CallB() OVERRIDE {
+  virtual void CallB() override {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
-  virtual void CallCFromB() OVERRIDE {
+  virtual 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() {
     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 {
+  virtual void B(const mojo::Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
-  virtual void CallC(const mojo::Callback<void()>& callback) OVERRIDE {
+  virtual 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(); }
 
  private:
-  virtual void C(const mojo::Callback<void()>& callback) OVERRIDE {
+  virtual 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() {}
 
  private:
   virtual void Load(ApplicationManager* manager,
                     const GURL& url,
-                    scoped_refptr<LoadCallbacks> callbacks) OVERRIDE {
+                    scoped_refptr<LoadCallbacks> callbacks) override {
     app_.reset(
         new ApplicationImpl(this, callbacks->RegisterApplication().Pass()));
   }
 
   virtual void OnApplicationError(ApplicationManager* manager,
-                                  const GURL& url) OVERRIDE {}
+                                  const GURL& url) override {}
 
   virtual bool ConfigureIncomingConnection(
-      ApplicationConnection* connection) OVERRIDE {
+      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 {
+      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 {
+                      InterfaceRequest<TestA> request) override {
     BindToRequest(new TestAImpl(connection, context_), &request);
   }
 
   virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestB> request) OVERRIDE {
+                      InterfaceRequest<TestB> request) override {
     BindToRequest(new TestBImpl(connection, context_), &request);
   }
 
   virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<TestC> request) OVERRIDE {
+                      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(
       const GURL& url,
-      ServiceProviderPtr service_provider) OVERRIDE {
+      ServiceProviderPtr service_provider) override {
     ++call_count_;
     url_ = url;
     return service_provider.Pass();
   }
 
   std::string url_spec() const {
     if (!url_.is_valid())
       return "invalid url";
     return url_.spec();
   }
 
   int call_count() const { return call_count_; }
 
  private:
   int call_count_;
   GURL url_;
   DISALLOW_COPY_AND_ASSIGN(TestServiceInterceptor);
 };
 
 }  // namespace
 
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   virtual ~ApplicationManagerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     application_manager_.reset(new ApplicationManager);
     TestApplicationLoader* default_loader = new TestApplicationLoader;
     default_loader->set_context(&context_);
     application_manager_->set_default_loader(
         scoped_ptr<ApplicationLoader>(default_loader));
 
     TestServicePtr service_proxy;
     application_manager_->ConnectToService(GURL(kTestURLString),
                                            &service_proxy);
     test_client_.reset(new TestClientImpl(service_proxy.Pass()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     test_client_.reset(NULL);
     application_manager_.reset(NULL);
   }
 
   scoped_ptr<BackgroundShellApplicationLoader> MakeLoader(
       const std::string& requestor_url) {
     scoped_ptr<ApplicationLoader> real_loader(
         new Tester(&tester_context_, requestor_url));
     scoped_ptr<BackgroundShellApplicationLoader> loader(
         new BackgroundShellApplicationLoader(real_loader.Pass(),
@@ skipping 235 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