Update MojoTestConnection Service Registration

chrome/test/base/mojo_test_connector.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 "chrome/test/base/mojo_test_connector.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 49 matching lines @@
     test_launch_options->inherit_handles = true;
     test_launch_options->handles_to_inherit = &handle_passing_info_;
 #if defined(OFFICIAL_BUILD)
     CHECK(false) << "Launching mojo process with inherit_handles is insecure!";
 #endif
 #elif defined(OS_POSIX)
     test_launch_options->fds_to_remap = &handle_passing_info_;
 #else
 #error "Unsupported"
 #endif
-    service_manager::mojom::ServicePtr service =
-        service_manager::PassServiceRequestOnCommandLine(&process_connection_,
-                                                         command_line);
 
-    background_service_manager_->RegisterService(
-        service_manager::Identity(content::mojom::kPackagedServicesServiceName,
-                                  service_manager::mojom::kRootUserID),
-        std::move(service),
-        service_manager::mojom::PIDReceiverRequest(&pid_receiver_));
+    // Create the pipe token, as it must be passed to children processes via the
+    // command line.
+    service_ = service_manager::PassServiceRequestOnCommandLine(
+        &process_connection_, command_line);
 
     // ChildProcessLaunched may be called on an arbitrary thread, so track the
     // current TaskRunner and post back to it when we want to send the PID.
     main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   }
 
  private:
   // content::TestState:
   void ChildProcessLaunched(base::ProcessHandle handle,
                             base::ProcessId pid) override {
     platform_channel_->ChildProcessLaunched();
     process_connection_.Connect(
         handle,
         mojo::edk::ConnectionParams(platform_channel_->PassServerHandle()));
 
-    main_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&MojoTestState::SetPID, weak_factory_.GetWeakPtr(), pid));
+    main_task_runner_->PostTask(FROM_HERE,
+                                base::Bind(&MojoTestState::SetupService,
+                                           weak_factory_.GetWeakPtr(), pid));
   }
 
   // Called on the main thread only.
-  void SetPID(base::ProcessId pid) {
+  // This registers the services needed for the test. This is not done until
+  // after ChildProcessLaunched as previous test runs will tear down existing
+  // connections.
+  void SetupService(base::ProcessId pid) {
+    background_service_manager_->RegisterService(
+        service_manager::Identity(content::mojom::kPackagedServicesServiceName,
+                                  service_manager::mojom::kRootUserID),
+        std::move(service_),
+        service_manager::mojom::PIDReceiverRequest(&pid_receiver_));
+
     DCHECK(pid_receiver_.is_bound());
     pid_receiver_->SetPID(pid);
     pid_receiver_.reset();
   }
 
   mojo::edk::PendingProcessConnection process_connection_;
   service_manager::BackgroundServiceManager* const background_service_manager_;
 
+  // The ServicePtr must be created before child process launch so that the pipe
+  // can be set on the command line. It is held until SetupService is called at
+  // which point |background_service_manager_| takes over ownership.
+  service_manager::mojom::ServicePtr service_;
+
   // NOTE: HandlePassingInformation must remain valid through process launch,
   // hence it lives here instead of within Init()'s stack.
   mojo::edk::HandlePassingInformation handle_passing_info_;
 
   std::unique_ptr<mojo::edk::PlatformChannelPair> platform_channel_;
   service_manager::mojom::PIDReceiverPtr pid_receiver_;
   scoped_refptr<base::TaskRunner> main_task_runner_ = nullptr;
 
   base::WeakPtrFactory<MojoTestState> weak_factory_;
 
@@ skipping 86 matching lines @@
 MojoTestConnector::~MojoTestConnector() {}
 
 std::unique_ptr<content::TestState> MojoTestConnector::PrepareForTest(
     base::CommandLine* command_line,
     base::TestLauncher::LaunchOptions* test_launch_options) {
   auto test_state =
       base::MakeUnique<MojoTestState>(&background_service_manager_);
   test_state->Init(command_line, test_launch_options);
   return test_state;
 }