Use the mojo::shell namespace consistently underly 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;
@@ skipping 23 matching lines @@
 
   ~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 mojo::Callback<void()>& callback) override {
+            const Callback<void()>& callback) override {
     context_->last_test_string = test_string;
     callback.Run();
   }
 
  private:
   TestContext* context_;
   StrongBinding<TestService> binding_;
 };
 
 class TestClient {
@@ skipping 201 matching lines @@
   }
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
     test_context_->QuitSoon();
   }
 
  private:
-  void B(const mojo::Callback<void()>& callback) override {
+  void B(const Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
-  void CallC(const mojo::Callback<void()>& callback) override {
+  void CallC(const Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     c_->C(callback);
   }
 
   TesterContext* test_context_;
   TestCPtr c_;
   StrongBinding<TestB> binding_;
 };
 
 class TestCImpl : public TestC {
  public:
   TestCImpl(ApplicationConnection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestC> request)
       : test_context_(test_context), binding_(this, request.Pass()) {}
 
   ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
 
  private:
-  void C(const mojo::Callback<void()>& callback) override {
+  void C(const Callback<void()>& callback) override {
     test_context_->IncrementNumCCalls();
     callback.Run();
   }
 
   TesterContext* test_context_;
   StrongBinding<TestC> binding_;
 };
 
 class Tester : public ApplicationDelegate,
                public ApplicationLoader,
@@ skipping 106 matching lines @@
 
   bool configure_incoming_connection_called() const {
     return configure_incoming_connection_called_;
   }
 
  private:
   std::vector<std::string> initialize_args_;
   bool configure_incoming_connection_called_;
 };
 
-}  // namespace
-
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(&test_delegate_));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
@@ skipping 297 matching lines @@
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(0, scheme_loader->num_loads());
 
   // test::test2 should go to scheme loader.
   application_manager_->ConnectToService(GURL("test:test2?foo=bar"),
                                          &test_service);
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(1, scheme_loader->num_loads());
 }
 
+}  // namespace
+}  // namespace shell
 }  // namespace mojo