Rename shell.mojom to connector.mojom, ApplicationManager to Shell

mojo/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 <utility>
 
 #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 "base/run_loop.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/services/package_manager/package_manager.h"
-#include "mojo/shell/application_manager.h"
 #include "mojo/shell/connect_util.h"
 #include "mojo/shell/loader.h"
 #include "mojo/shell/public/cpp/connector.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/cpp/shell_connection.h"
 #include "mojo/shell/public/interfaces/interface_provider.mojom.h"
+#include "mojo/shell/shell.h"
 #include "mojo/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";
@@ skipping 359 matching lines @@
 void OnConnect(base::RunLoop* loop, uint32_t instance_id, uint32_t user_id) {
   loop->Quit();
 }
 
 class LoaderTest : public testing::Test {
  public:
   LoaderTest() : tester_context_(&loop_) {}
   ~LoaderTest() override {}
 
   void SetUp() override {
-    application_manager_.reset(
-        new ApplicationManager(nullptr, nullptr, nullptr));
+    shell_.reset(new Shell(nullptr, nullptr, nullptr));
     test_loader_ = new TestLoader(&context_);
-    application_manager_->set_default_loader(scoped_ptr<Loader>(test_loader_));
+    shell_->set_default_loader(scoped_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();
-    application_manager_.reset();
+    shell_.reset();
   }
 
   void AddLoaderForName(const std::string& name,
                         const std::string& requestor_name) {
-    application_manager_->SetLoaderForName(
+    shell_->SetLoaderForName(
         make_scoped_ptr(new Tester(&tester_context_, requestor_name)), name);
   }
 
   bool HasRunningInstanceForName(const std::string& name) {
-    ApplicationManager::TestAPI manager_test_api(application_manager_.get());
-    return manager_test_api.HasRunningInstanceForName(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) {
     base::RunLoop loop;
     mojom::InterfaceProviderPtr remote_interfaces;
     scoped_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(CreateShellIdentity());
     params->set_target(Identity(name));
     params->set_remote_interfaces(GetProxy(&remote_interfaces));
     params->set_connect_callback(
         base::Bind(&OnConnect, base::Unretained(&loop)));
-    application_manager_->Connect(std::move(params));
+    shell_->Connect(std::move(params));
     loop.Run();
 
     mojo::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<ApplicationManager> application_manager_;
+  scoped_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) {
   {
-    ApplicationManager am(nullptr, nullptr, nullptr);
+    Shell shell(nullptr, nullptr, nullptr);
     TestLoader* default_loader = new TestLoader(&context_);
     TestLoader* name_loader1 = new TestLoader(&context_);
     TestLoader* name_loader2 = new TestLoader(&context_);
-    am.set_default_loader(scoped_ptr<Loader>(default_loader));
-    am.SetLoaderForName(scoped_ptr<Loader>(name_loader1), "test:test1");
-    am.SetLoaderForName(scoped_ptr<Loader>(name_loader2), "test:test1");
+    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");
   }
   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_);
-  application_manager_->set_default_loader(scoped_ptr<Loader>(default_loader));
-  application_manager_->SetLoaderForName(
-      scoped_ptr<Loader>(name_loader), "test:test1");
+  shell_->set_default_loader(scoped_ptr<Loader>(default_loader));
+  shell_->SetLoaderForName(scoped_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
-  // ApplicationManager, so this cannot succeed (but also shouldn't crash).
+  // 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();
-  application_manager_->SetLoaderForName(
-      scoped_ptr<Loader>(loader), "test:test");
+  shell_->SetLoaderForName(scoped_ptr<Loader>(loader), "test:test");
 
   bool called = false;
   scoped_ptr<ConnectParams> params(new ConnectParams);
   params->set_source(CreateShellIdentity());
   params->set_target(Identity("test:test", "", mojom::Connector::kUserRoot));
-  application_manager_->SetInstanceQuitCallback(
+  shell_->SetInstanceQuitCallback(
       base::Bind(&QuitClosure, params->target(), &called));
-  application_manager_->Connect(std::move(params));
+  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