Move shell service to toplevel shell namespace

services/shell/tests/loader_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 <memory>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/catalog/factory.h"
 #include "services/catalog/store.h"
 #include "services/shell/connect_util.h"
 #include "services/shell/loader.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/interface_factory.h"
 #include "services/shell/public/cpp/shell_client.h"
 #include "services/shell/public/cpp/shell_connection.h"
 #include "services/shell/public/interfaces/interface_provider.mojom.h"
 #include "services/shell/shell.h"
 #include "services/shell/tests/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace mojo {
 namespace shell {
 namespace test {
 
 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(const Identity& expected,
                  bool* value,
                  const Identity& actual) {
   if (expected == actual) {
     *value = true;
     base::MessageLoop::current()->QuitWhenIdle();
   }
 }
 
 class TestServiceImpl : public TestService {
  public:
-  TestServiceImpl(TestContext* context, InterfaceRequest<TestService> request)
+  TestServiceImpl(TestContext* context, TestServiceRequest request)
       : context_(context), binding_(this, std::move(request)) {
     ++context_->num_impls;
   }
 
   ~TestServiceImpl() override {
     --context_->num_impls;
     if (!base::MessageLoop::current()->is_running())
       return;
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   // TestService implementation:
-  void Test(const String& test_string,
-            const Callback<void()>& callback) override {
+  void Test(const mojo::String& test_string,
+            const mojo::Closure& 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_(std::move(service)), quit_after_ack_(false) {}
 
   void AckTest() {
     if (quit_after_ack_)
       base::MessageLoop::current()->QuitWhenIdle();
@@ skipping 29 matching lines @@
   }
 
  private:
   // Loader implementation.
   void Load(const std::string& name,
             mojom::ShellClientRequest request) override {
     ++num_loads_;
     shell_connection_.reset(new ShellConnection(this, std::move(request)));
   }
 
-  // mojo::ShellClient implementation.
+  // ShellClient implementation.
   bool AcceptConnection(Connection* connection) override {
     connection->AddInterface<TestService>(this);
     last_requestor_name_ = connection->GetRemoteIdentity().name();
     return true;
   }
 
   // InterfaceFactory<TestService> implementation.
-  void Create(Connection* connection,
-              InterfaceRequest<TestService> request) override {
+  void Create(Connection* connection, TestServiceRequest request) override {
     new TestServiceImpl(context_, std::move(request));
   }
 
-  scoped_ptr<ShellConnection> shell_connection_;
+  std::unique_ptr<ShellConnection> shell_connection_;
   TestContext* context_;
   int num_loads_;
   std::string last_requestor_name_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLoader);
 };
 
 class ClosingLoader : public Loader {
  private:
   // Loader implementation.
@@ skipping 95 matching lines @@
   bool a_called_quit_;
 
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor name will be correctly passed.
 class TestAImpl : public TestA {
  public:
   TestAImpl(Connector* connector,
             TesterContext* test_context,
-            InterfaceRequest<TestA> request,
+            TestARequest request,
             InterfaceFactory<TestC>* factory)
       : test_context_(test_context), binding_(this, std::move(request)) {
     connection_ = connector->Connect(kTestBURLString);
     connection_->AddInterface<TestC>(factory);
     connection_->GetInterface(&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()->QuitWhenIdle();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
-  scoped_ptr<Connection> connection_;
+  std::unique_ptr<Connection> connection_;
   TesterContext* test_context_;
   TestBPtr b_;
-  StrongBinding<TestA> binding_;
+  mojo::StrongBinding<TestA> binding_;
 };
 
 class TestBImpl : public TestB {
  public:
   TestBImpl(Connection* connection,
             TesterContext* test_context,
-            InterfaceRequest<TestB> request)
+            TestBRequest request)
       : test_context_(test_context), binding_(this, std::move(request)) {
     connection->GetInterface(&c_);
   }
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->QuitWhenIdle();
     test_context_->QuitSoon();
   }
 
  private:
-  void B(const Callback<void()>& callback) override {
+  void B(const mojo::Closure& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
-  void CallC(const Callback<void()>& callback) override {
+  void CallC(const mojo::Closure& 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(Connection* connection,
             TesterContext* test_context,
-            InterfaceRequest<TestC> request)
+            TestCRequest request)
       : test_context_(test_context), binding_(this, std::move(request)) {}
 
   ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
 
  private:
-  void C(const Callback<void()>& callback) override {
+  void C(const mojo::Closure& callback) override {
     test_context_->IncrementNumCCalls();
     callback.Run();
   }
 
   TesterContext* test_context_;
-  StrongBinding<TestC> binding_;
+  mojo::StrongBinding<TestC> binding_;
 };
 
 class Tester : public ShellClient,
                public Loader,
                public InterfaceFactory<TestA>,
                public InterfaceFactory<TestB>,
                public InterfaceFactory<TestC> {
  public:
   Tester(TesterContext* context, const std::string& requestor_name)
       : context_(context), requestor_name_(requestor_name) {}
   ~Tester() override {}
 
  private:
   void Load(const std::string& name,
-            InterfaceRequest<mojom::ShellClient> request) override {
+            mojom::ShellClientRequest request) override {
     app_.reset(new ShellConnection(this, std::move(request)));
   }
 
   bool AcceptConnection(Connection* connection) override {
     if (!requestor_name_.empty() &&
         requestor_name_ != connection->GetRemoteIdentity().name()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
       base::MessageLoop::current()->QuitWhenIdle();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteIdentity().name() == kTestAURLString)
       connection->AddInterface<TestB>(this);
     else
       connection->AddInterface<TestA>(this);
     return true;
   }
 
-  void Create(Connection* connection,
-              InterfaceRequest<TestA> request) override {
+  void Create(Connection* connection, TestARequest request) override {
     a_bindings_.push_back(
         new TestAImpl(app_->connector(), context_, std::move(request), this));
   }
 
-  void Create(Connection* connection,
-              InterfaceRequest<TestB> request) override {
+  void Create(Connection* connection, TestBRequest request) override {
     new TestBImpl(connection, context_, std::move(request));
   }
 
-  void Create(Connection* connection,
-              InterfaceRequest<TestC> request) override {
+  void Create(Connection* connection, TestCRequest request) override {
     new TestCImpl(connection, context_, std::move(request));
   }
 
   TesterContext* context_;
-  scoped_ptr<ShellConnection> app_;
+  std::unique_ptr<ShellConnection> app_;
   std::string requestor_name_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
-void OnConnect(base::RunLoop* loop, mojom::ConnectResult result,
-               const String& user_id, uint32_t instance_id) {
+void OnConnect(base::RunLoop* loop,
+               mojom::ConnectResult result,
+               const mojo::String& user_id,
+               uint32_t instance_id) {
   loop->Quit();
 }
 
 class LoaderTest : public testing::Test {
  public:
   LoaderTest() : tester_context_(&loop_) {}
   ~LoaderTest() override {}
 
   void SetUp() override {
     blocking_pool_ = new base::SequencedWorkerPool(3, "blocking_pool");
     catalog_.reset(
         new catalog::Factory(blocking_pool_.get(), nullptr, nullptr));
     shell_.reset(new Shell(nullptr, catalog_->TakeShellClient()));
     test_loader_ = new TestLoader(&context_);
-    shell_->set_default_loader(scoped_ptr<Loader>(test_loader_));
+    shell_->set_default_loader(std::unique_ptr<Loader>(test_loader_));
 
     TestServicePtr service_proxy;
     ConnectToInterface(kTestURLString, &service_proxy);
     test_client_.reset(new TestClient(std::move(service_proxy)));
   }
 
   void TearDown() override {
     test_client_.reset();
     shell_.reset();
     blocking_pool_->Shutdown();
   }
 
   void AddLoaderForName(const std::string& name,
                         const std::string& requestor_name) {
     shell_->SetLoaderForName(
-        make_scoped_ptr(new Tester(&tester_context_, requestor_name)), name);
+        base::WrapUnique(new Tester(&tester_context_, requestor_name)), name);
   }
 
   bool HasRunningInstanceForName(const std::string& name) {
     Shell::TestAPI test_api(shell_.get());
     return test_api.HasRunningInstanceForName(name);
   }
 
  protected:
   template <typename Interface>
   void ConnectToInterface(const std::string& name,
-                          InterfacePtr<Interface>* ptr) {
+                          mojo::InterfacePtr<Interface>* ptr) {
     base::RunLoop loop;
     mojom::InterfaceProviderPtr remote_interfaces;
-    scoped_ptr<ConnectParams> params(new ConnectParams);
+    std::unique_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(CreateShellIdentity());
     params->set_target(Identity(name, mojom::kRootUserID));
-    params->set_remote_interfaces(GetProxy(&remote_interfaces));
+    params->set_remote_interfaces(mojo::GetProxy(&remote_interfaces));
     params->set_connect_callback(
         base::Bind(&OnConnect, base::Unretained(&loop)));
     shell_->Connect(std::move(params));
     loop.Run();
 
-    mojo::GetInterface(remote_interfaces.get(), ptr);
+    GetInterface(remote_interfaces.get(), ptr);
   }
 
   base::ShadowingAtExitManager at_exit_;
   TestLoader* test_loader_;
   TesterContext tester_context_;
   TestContext context_;
   base::MessageLoop loop_;
-  scoped_ptr<TestClient> test_client_;
-  scoped_ptr<catalog::Factory> catalog_;
+  std::unique_ptr<TestClient> test_client_;
+  std::unique_ptr<catalog::Factory> catalog_;
   scoped_refptr<base::SequencedWorkerPool> blocking_pool_;
-  scoped_ptr<Shell> shell_;
+  std::unique_ptr<Shell> shell_;
+
   DISALLOW_COPY_AND_ASSIGN(LoaderTest);
 };
 
 TEST_F(LoaderTest, Basic) {
   test_client_->Test("test");
   loop_.Run();
   EXPECT_EQ(std::string("test"), context_.last_test_string);
 }
 
 TEST_F(LoaderTest, ClientError) {
   test_client_->Test("test");
   EXPECT_TRUE(HasRunningInstanceForName(kTestURLString));
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset();
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
   EXPECT_TRUE(HasRunningInstanceForName(kTestURLString));
 }
 
 TEST_F(LoaderTest, Deletes) {
   {
     catalog::Factory catalog(blocking_pool_.get(), nullptr, nullptr);
     Shell shell(nullptr, catalog.TakeShellClient());
     TestLoader* default_loader = new TestLoader(&context_);
     TestLoader* name_loader1 = new TestLoader(&context_);
     TestLoader* name_loader2 = new TestLoader(&context_);
-    shell.set_default_loader(scoped_ptr<Loader>(default_loader));
-    shell.SetLoaderForName(scoped_ptr<Loader>(name_loader1), "test:test1");
-    shell.SetLoaderForName(scoped_ptr<Loader>(name_loader2), "test:test1");
+    shell.set_default_loader(std::unique_ptr<Loader>(default_loader));
+    shell.SetLoaderForName(std::unique_ptr<Loader>(name_loader1), "test:test1");
+    shell.SetLoaderForName(std::unique_ptr<Loader>(name_loader2), "test:test1");
   }
   EXPECT_EQ(3, context_.num_loader_deletes);
 }
 
 // Test for SetLoaderForName() & set_default_loader().
 TEST_F(LoaderTest, SetLoaders) {
   TestLoader* default_loader = new TestLoader(&context_);
   TestLoader* name_loader = new TestLoader(&context_);
-  shell_->set_default_loader(scoped_ptr<Loader>(default_loader));
-  shell_->SetLoaderForName(scoped_ptr<Loader>(name_loader), "test:test1");
+  shell_->set_default_loader(std::unique_ptr<Loader>(default_loader));
+  shell_->SetLoaderForName(std::unique_ptr<Loader>(name_loader), "test:test1");
 
   // test::test1 should go to name_loader.
   TestServicePtr test_service;
   ConnectToInterface("test:test1", &test_service);
   EXPECT_EQ(1, name_loader->num_loads());
   EXPECT_EQ(0, default_loader->num_loads());
 
   // http::test1 should go to default loader.
   ConnectToInterface("http:test1", &test_service);
   EXPECT_EQ(1, name_loader->num_loads());
   EXPECT_EQ(1, default_loader->num_loads());
 }
 
 TEST_F(LoaderTest, NoServiceNoLoad) {
   AddLoaderForName(kTestAURLString, std::string());
 
   // There is no TestC service implementation registered with the Shell, so this
   // cannot succeed (but also shouldn't crash).
   TestCPtr c;
   ConnectToInterface(kTestAURLString, &c);
   c.set_connection_error_handler(
       []() { base::MessageLoop::current()->QuitWhenIdle(); });
 
   loop_.Run();
   EXPECT_TRUE(c.encountered_error());
 }
 
 TEST_F(LoaderTest, TestEndApplicationClosure) {
   ClosingLoader* loader = new ClosingLoader();
-  shell_->SetLoaderForName(scoped_ptr<Loader>(loader), "test:test");
+  shell_->SetLoaderForName(std::unique_ptr<Loader>(loader), "test:test");
 
   bool called = false;
-  scoped_ptr<ConnectParams> params(new ConnectParams);
+  std::unique_ptr<ConnectParams> params(new ConnectParams);
   params->set_source(CreateShellIdentity());
   params->set_target(Identity("test:test", mojom::kRootUserID));
   shell_->SetInstanceQuitCallback(
       base::Bind(&QuitClosure, params->target(), &called));
   shell_->Connect(std::move(params));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST_F(LoaderTest, SameIdentityShouldNotCauseDuplicateLoad) {
   // 1 because LoaderTest connects once at startup.
   EXPECT_EQ(1, test_loader_->num_loads());
 
   TestServicePtr test_service;
   ConnectToInterface("test:foo", &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // Exactly the same name as above.
   ConnectToInterface("test:foo", &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // A different identity because the domain is different.
   ConnectToInterface("test:bar", &test_service);
   EXPECT_EQ(3, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
-}  // namespace mojo