Replace remaining shell references with service manager

services/service_manager/tests/connect/connect_unittest.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 103 matching lines @@
     }
 
     ConnectTest* connect_test_;
 
     DISALLOW_COPY_AND_ASSIGN(TestService);
   };
 
   // test::ServiceTest:
   void SetUp() override {
     test::ServiceTest::SetUp();
-    // We need to connect to the package first to force the shell to read the
+    // We need to connect to the package first to force the service manager to
+    // read the
     // package app's manifest and register aliases for the applications it
     // provides.
     test::mojom::ConnectTestServicePtr root_service;
     std::unique_ptr<Connection> connection =
         connector()->Connect(kTestPackageName);
     connection->GetInterface(&root_service);
     base::RunLoop run_loop;
     std::string root_name;
     root_service->GetTitle(
         base::Bind(&ReceiveOneString, &root_name, &run_loop));
@@ skipping 222 matching lines @@
     base::RunLoop loop;
     user_id_test->ConnectToClassAppAsDifferentUser(
         target,
         base::Bind(&ReceiveConnectionResult, &result, &result_identity, &loop));
     loop.Run();
   }
   EXPECT_EQ(mojom::ConnectResult::ACCESS_DENIED, result);
   EXPECT_FALSE(target == result_identity);
 }
 
-// There are various other tests (shell, lifecycle) that test valid client
+// There are various other tests (service manager, lifecycle) that test valid
+// client
 // process specifications. This is the only one for blocking.
 TEST_F(ConnectTest, ConnectToClientProcess_Blocked) {
   std::unique_ptr<Connection> connection =
       connector()->Connect(kTestDriverName);
   test::mojom::ClientProcessTestPtr client_process_test;
   connection->GetInterface(&client_process_test);
   mojom::ConnectResult result;
   Identity result_identity;
   {
     base::RunLoop loop;
     client_process_test->LaunchAndConnectToProcess(
         base::Bind(&ReceiveConnectionResult, &result, &result_identity, &loop));
     loop.Run();
   }
   EXPECT_EQ(mojom::ConnectResult::ACCESS_DENIED, result);
 }
 
 // Verifies that a client with the "all_users" capability class can receive
 // connections from clients run as other users.
 TEST_F(ConnectTest, AllUsersSingleton) {
   // Connect to an instance with an explicitly different user_id. This supplied
-  // user id should be ignored by the shell (which will generate its own
+  // user id should be ignored by the service manager (which will generate its
+  // own
   // synthetic user id for all-user singleton instances).
   const std::string singleton_userid = base::GenerateGUID();
   Connector::ConnectParams params(
       Identity(kTestSingletonAppName, singleton_userid));
   std::unique_ptr<Connection> connection = connector()->Connect(&params);
   {
     base::RunLoop loop;
     connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
     loop.Run();
     EXPECT_NE(connection->GetRemoteIdentity().user_id(), singleton_userid);
   }
   // This connects using the current client's user_id. It should be bound to the
-  // same service started above, with the same shell-generated user id.
+  // same service started above, with the same service manager-generated user
+  // id.
   std::unique_ptr<Connection> inherit_connection =
       connector()->Connect(kTestSingletonAppName);
   {
     base::RunLoop loop;
     inherit_connection->AddConnectionCompletedClosure(
         base::Bind(&QuitLoop, &loop));
     loop.Run();
     EXPECT_EQ(inherit_connection->GetRemoteIdentity().user_id(),
               connection->GetRemoteIdentity().user_id());
   }
 }
 
 }  // namespace service_manager