Rename ServiceConnector back to ServiceManager

mojo/shell/service_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 "mojo/public/bindings/allocation_scope.h"
 #include "mojo/public/bindings/remote_ptr.h"
 #include "mojo/public/environment/environment.h"
 #include "mojo/public/shell/application.h"
 #include "mojo/public/utility/run_loop.h"
-#include "mojo/shell/service_connector.h"
+#include "mojo/shell/service_manager.h"
 #include "mojom/shell.h"
 #include "mojom/test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 
@@ skipping 45 matching lines @@
     service_->Test(mojo::String(test_string));
   }
 
  private:
   RemotePtr<TestService> service_;
   bool quit_after_ack_;
   DISALLOW_COPY_AND_ASSIGN(TestClientImpl);
 };
 }  // namespace
 
-class ServiceConnectorTest : public testing::Test,
-                             public ServiceConnector::Loader {
+class ServiceManagerTest : public testing::Test,
+                             public ServiceManager::Loader {
  public:
-  ServiceConnectorTest() {}
+  ServiceManagerTest() {}
 
-  virtual ~ServiceConnectorTest() {}
+  virtual ~ServiceManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     GURL test_url(kTestURLString);
-    service_connector_.reset(new ServiceConnector);
-    service_connector_->SetLoaderForURL(this, test_url);
+    service_manager_.reset(new ServiceManager);
+    service_manager_->SetLoaderForURL(this, test_url);
 
     InterfacePipe<TestService, AnyInterface> pipe;
     test_client_.reset(new TestClientImpl(pipe.handle_to_self.Pass()));
-    service_connector_->Connect(test_url, pipe.handle_to_peer.Pass());
+    service_manager_->Connect(test_url, pipe.handle_to_peer.Pass());
   }
 
   virtual void TearDown() OVERRIDE {
     test_client_.reset(NULL);
     test_app_.reset(NULL);
-    service_connector_.reset(NULL);
+    service_manager_.reset(NULL);
   }
 
   virtual void Load(const GURL& url,
                     ScopedShellHandle shell_handle) OVERRIDE {
     test_app_.reset(new Application(shell_handle.Pass()));
     test_app_->AddServiceFactory(
         new ServiceFactory<TestServiceImpl, TestContext>(&context_));
   }
 
   bool HasFactoryForTestURL() {
-    ServiceConnector::TestAPI connector_test_api(service_connector_.get());
-    return connector_test_api.HasFactoryForURL(GURL(kTestURLString));
+    ServiceManager::TestAPI manager_test_api(service_manager_.get());
+    return manager_test_api.HasFactoryForURL(GURL(kTestURLString));
   }
 
  protected:
   mojo::Environment env_;
   mojo::RunLoop loop_;
   TestContext context_;
   scoped_ptr<Application> test_app_;
   scoped_ptr<TestClientImpl> test_client_;
-  scoped_ptr<ServiceConnector> service_connector_;
-  DISALLOW_COPY_AND_ASSIGN(ServiceConnectorTest);
+  scoped_ptr<ServiceManager> service_manager_;
+  DISALLOW_COPY_AND_ASSIGN(ServiceManagerTest);
 };
 
-TEST_F(ServiceConnectorTest, Basic) {
+TEST_F(ServiceManagerTest, Basic) {
   test_client_->Test("test");
   loop_.Run();
   EXPECT_EQ(std::string("test"), context_.last_test_string);
 }
 
-TEST_F(ServiceConnectorTest, ClientError) {
+TEST_F(ServiceManagerTest, ClientError) {
   test_client_->Test("test");
   EXPECT_TRUE(HasFactoryForTestURL());
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset(NULL);
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
   EXPECT_FALSE(HasFactoryForTestURL());
 }
 }  // namespace shell
 }  // namespace mojo