Remove mojo:: part of mojo::shell:: nested namespace in //shell.

shell/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/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.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/cpp/bindings/strong_binding.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/application_manager/application_manager.h"
 #include "shell/application_manager/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
 
 struct TestContext {
   TestContext() : num_impls(0), num_loader_deletes(0) {}
   std::string last_test_string;
   int num_impls;
   int num_loader_deletes;
 };
 
 void QuitClosure(bool* value) {
   *value = true;
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
-class QuitMessageLoopErrorHandler : public ErrorHandler {
+class QuitMessageLoopErrorHandler : public mojo::ErrorHandler {
  public:
   QuitMessageLoopErrorHandler() {}
   ~QuitMessageLoopErrorHandler() override {}
 
-  // |ErrorHandler| implementation:
+  // |mojo::ErrorHandler| implementation:
   void OnConnectionError() override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuitMessageLoopErrorHandler);
 };
 
 class TestServiceImpl : public TestService {
  public:
-  TestServiceImpl(TestContext* context, InterfaceRequest<TestService> request)
+  TestServiceImpl(TestContext* context,
+                  mojo::InterfaceRequest<TestService> request)
       : context_(context), binding_(this, request.Pass()) {
     ++context_->num_impls;
   }
 
   ~TestServiceImpl() override {
     --context_->num_impls;
     if (!base::MessageLoop::current()->is_running())
       return;
     base::MessageLoop::current()->Quit();
   }
 
   // TestService implementation:
-  void Test(const String& test_string,
-            const Callback<void()>& callback) override {
+  void Test(const mojo::String& test_string,
+            const mojo::Callback<void()>& callback) override {
     context_->last_test_string = test_string;
     callback.Run();
   }
 
  private:
   TestContext* context_;
-  StrongBinding<TestService> binding_;
+  mojo::StrongBinding<TestService> binding_;
 };
 
 class TestClient {
  public:
   explicit TestClient(TestServicePtr service)
       : service_(service.Pass()), quit_after_ack_(false) {}
 
   void AckTest() {
     if (quit_after_ack_)
       base::MessageLoop::current()->Quit();
   }
 
   void Test(const std::string& test_string) {
     quit_after_ack_ = true;
     service_->Test(test_string,
                    base::Bind(&TestClient::AckTest, base::Unretained(this)));
   }
 
  private:
   TestServicePtr service_;
   bool quit_after_ack_;
   DISALLOW_COPY_AND_ASSIGN(TestClient);
 };
 
 class TestApplicationLoader : public ApplicationLoader,
-                              public ApplicationDelegate,
-                              public InterfaceFactory<TestService> {
+                              public mojo::ApplicationDelegate,
+                              public mojo::InterfaceFactory<TestService> {
  public:
   TestApplicationLoader() : context_(nullptr), num_loads_(0) {}
 
   ~TestApplicationLoader() override {
     if (context_)
       ++context_->num_loader_deletes;
     test_app_.reset();
   }
 
   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.
-  void Load(const GURL& url,
-            InterfaceRequest<Application> application_request) override {
+  void Load(
+      const GURL& url,
+      mojo::InterfaceRequest<mojo::Application> application_request) override {
     ++num_loads_;
-    test_app_.reset(new ApplicationImpl(this, application_request.Pass()));
+    test_app_.reset(
+        new mojo::ApplicationImpl(this, application_request.Pass()));
   }
 
-  // ApplicationDelegate implementation.
-  bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
+  // mojo::ApplicationDelegate implementation.
+  bool ConfigureIncomingConnection(
+      mojo::ApplicationConnection* connection) override {
     connection->AddService(this);
     return true;
   }
 
-  // InterfaceFactory implementation.
-  void Create(ApplicationConnection* connection,
-              InterfaceRequest<TestService> request) override {
+  // mojo::InterfaceFactory implementation.
+  void Create(mojo::ApplicationConnection* connection,
+              mojo::InterfaceRequest<TestService> request) override {
     new TestServiceImpl(context_, request.Pass());
   }
 
-  scoped_ptr<ApplicationImpl> test_app_;
+  scoped_ptr<mojo::ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
 class ClosingApplicationLoader : public ApplicationLoader {
  private:
   // ApplicationLoader implementation.
-  void Load(const GURL& url,
-            InterfaceRequest<Application> application_request) override {}
+  void Load(
+      const GURL& url,
+      mojo::InterfaceRequest<mojo::Application> application_request) override {}
 };
 
 class TesterContext {
  public:
   explicit TesterContext(base::MessageLoop* loop)
       : num_b_calls_(0),
         num_c_calls_(0),
         num_a_deletes_(0),
         num_b_deletes_(0),
         num_c_deletes_(0),
@@ skipping 80 matching lines @@
   int num_c_deletes_;
   bool tester_called_quit_;
   bool a_called_quit_;
 
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public TestA {
  public:
-  TestAImpl(ApplicationImpl* app_impl,
+  TestAImpl(mojo::ApplicationImpl* app_impl,
             TesterContext* test_context,
-            InterfaceRequest<TestA> request)
+            mojo::InterfaceRequest<TestA> request)
       : test_context_(test_context), binding_(this, request.Pass()) {
     app_impl->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
   }
 
   ~TestAImpl() override {
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
   void CallB() override {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   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_;
-  StrongBinding<TestA> binding_;
+  mojo::StrongBinding<TestA> binding_;
 };
 
 class TestBImpl : public TestB {
  public:
-  TestBImpl(ApplicationConnection* connection,
+  TestBImpl(mojo::ApplicationConnection* connection,
             TesterContext* test_context,
-            InterfaceRequest<TestB> request)
+            mojo::InterfaceRequest<TestB> request)
       : test_context_(test_context), binding_(this, request.Pass()) {
     connection->ConnectToService(&c_);
   }
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
     test_context_->QuitSoon();
   }
 
  private:
-  void B(const Callback<void()>& callback) override {
+  void B(const mojo::Callback<void()>& callback) override {

[jamesr, 2015/04/09 19:39:25]

this file would probably benefit from some using statements at the top for
Callback, InterfaceRequest, StrongBinding, ApplicationContext, etc

     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
-  void CallC(const Callback<void()>& callback) override {
+  void CallC(const mojo::Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     c_->C(callback);
   }
 
   TesterContext* test_context_;
   TestCPtr c_;
-  StrongBinding<TestB> binding_;
+  mojo::StrongBinding<TestB> binding_;
 };
 
 class TestCImpl : public TestC {
  public:
-  TestCImpl(ApplicationConnection* connection,
+  TestCImpl(mojo::ApplicationConnection* connection,
             TesterContext* test_context,
-            InterfaceRequest<TestC> request)
+            mojo::InterfaceRequest<TestC> request)
       : test_context_(test_context), binding_(this, request.Pass()) {}
 
   ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
 
  private:
-  void C(const Callback<void()>& callback) override {
+  void C(const mojo::Callback<void()>& callback) override {
     test_context_->IncrementNumCCalls();
     callback.Run();
   }
 
   TesterContext* test_context_;
-  StrongBinding<TestC> binding_;
+  mojo::StrongBinding<TestC> binding_;
 };
 
-class Tester : public ApplicationDelegate,
+class Tester : public mojo::ApplicationDelegate,
                public ApplicationLoader,
-               public InterfaceFactory<TestA>,
-               public InterfaceFactory<TestB>,
-               public InterfaceFactory<TestC> {
+               public mojo::InterfaceFactory<TestA>,
+               public mojo::InterfaceFactory<TestB>,
+               public mojo::InterfaceFactory<TestC> {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
-  void Load(const GURL& url,
-            InterfaceRequest<Application> application_request) override {
-    app_.reset(new ApplicationImpl(this, application_request.Pass()));
+  void Load(
+      const GURL& url,
+      mojo::InterfaceRequest<mojo::Application> application_request) override {
+    app_.reset(new mojo::ApplicationImpl(this, application_request.Pass()));
   }
 
-  bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
+  bool ConfigureIncomingConnection(
+      mojo::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;
   }
 
-  bool ConfigureOutgoingConnection(ApplicationConnection* connection) override {
+  bool ConfigureOutgoingConnection(
+      mojo::ApplicationConnection* connection) override {
     // If we're connecting to B, then add C.
     if (connection->GetRemoteApplicationURL() == kTestBURLString)
       connection->AddService<TestC>(this);
     return true;
   }
 
-  void Create(ApplicationConnection* connection,
-              InterfaceRequest<TestA> request) override {
+  void Create(mojo::ApplicationConnection* connection,
+              mojo::InterfaceRequest<TestA> request) override {
     a_bindings_.push_back(new TestAImpl(app_.get(), context_, request.Pass()));
   }
 
-  void Create(ApplicationConnection* connection,
-              InterfaceRequest<TestB> request) override {
+  void Create(mojo::ApplicationConnection* connection,
+              mojo::InterfaceRequest<TestB> request) override {
     new TestBImpl(connection, context_, request.Pass());
   }
 
-  void Create(ApplicationConnection* connection,
-              InterfaceRequest<TestC> request) override {
+  void Create(mojo::ApplicationConnection* connection,
+              mojo::InterfaceRequest<TestC> request) override {
     new TestCImpl(connection, context_, request.Pass());
   }
 
   TesterContext* context_;
-  scoped_ptr<ApplicationImpl> app_;
+  scoped_ptr<mojo::ApplicationImpl> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class TestDelegate : public ApplicationManager::Delegate {
  public:
   void AddMapping(const GURL& from, const GURL& to) { mappings_[from] = to; }
 
   // ApplicationManager::Delegate
   GURL ResolveMappings(const GURL& url) override {
@@ skipping 12 matching lines @@
       replacements.SetScheme("file", url::Component(0, 4));
       mapped_url = mapped_url.ReplaceComponents(replacements);
     }
     return mapped_url;
   }
 
  private:
   std::map<GURL, GURL> mappings_;
 };
 
-class TestExternal : public ApplicationDelegate {
+class TestExternal : public mojo::ApplicationDelegate {
  public:
   TestExternal() : configure_incoming_connection_called_(false) {}
 
-  void Initialize(ApplicationImpl* app) override {
+  void Initialize(mojo::ApplicationImpl* app) override {
     initialize_args_ = app->args();
     base::MessageLoop::current()->Quit();
   }
 
-  bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
+  bool ConfigureIncomingConnection(
+      mojo::ApplicationConnection* connection) override {
     configure_incoming_connection_called_ = true;
     base::MessageLoop::current()->Quit();
     return true;
   }
 
   const std::vector<std::string>& initialize_args() const {
     return initialize_args_;
   }
 
   bool configure_incoming_connection_called() const {
@@ skipping 361 matching lines @@
   bool called = false;
   application_manager_->ConnectToApplication(
       GURL("test:test"), GURL(), nullptr, nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 }  // namespace
 }  // namespace shell
-}  // namespace mojo