[mojo-edk] Bind a child token to child launches and port reservations.

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 59 matching lines @@
                   std::move(required_shell_classes));
   required_capabilities->Set("mojo:shell", std::move(shell_caps));
   apps->Append(std::move(test_app_config));
   return base::WrapUnique(new shell::TestCatalogStore(std::move(apps)));
 }
 
 // BackgroundTestState maintains all the state necessary to bind the test to
 // mojo. This class is only used on the thread created by BackgroundShell.
 class BackgroundTestState {
  public:
-  BackgroundTestState() {}
+  BackgroundTestState() : child_token_(mojo::edk::GenerateRandomToken()) {}
   ~BackgroundTestState() {}
 
   // Prepares the command line and other setup for connecting the test to mojo.
-  // Must be paired with a clal to ChildProcessLaunched().
+  // Must be paired with a call to ChildProcessLaunched().
   void Connect(base::CommandLine* command_line,
                shell::Shell* shell,
                const std::string& instance,
                base::TestLauncher::LaunchOptions* test_launch_options) {
     command_line->AppendSwitch(MojoTestConnector::kTestSwitch);
     command_line->AppendSwitch(switches::kChildProcess);
     mojo_ipc_channel_.reset(new mojo::edk::PlatformChannelPair);
     mojo_ipc_channel_->PrepareToPassClientHandleToChildProcess(
         command_line, &handle_passing_info_);
 #if defined(OS_WIN)
     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
     shell::mojom::ShellClientPtr client =
-        shell::PassShellClientRequestOnCommandLine(command_line);
+        shell::PassShellClientRequestOnCommandLine(command_line, child_token_);
 
     std::unique_ptr<shell::ConnectParams> params(new shell::ConnectParams);
     params->set_source(shell::CreateShellIdentity());
     params->set_target(
         shell::Identity(kTestName, shell::mojom::kRootUserID, instance));
 
     shell::mojom::ClientProcessConnectionPtr client_process_connection =
         shell::mojom::ClientProcessConnection::New();
     client_process_connection->shell_client =
         client.PassInterface().PassHandle();
     client_process_connection->pid_receiver_request =
         mojo::GetProxy(&pid_receiver_).PassMessagePipe();
     params->set_client_process_connection(std::move(client_process_connection));
     shell->Connect(std::move(params));
   }
 
   // Called after the test process has launched. Completes the registration done
   // in Connect().
   void ChildProcessLaunched(base::ProcessHandle handle, base::ProcessId pid) {
     pid_receiver_->SetPID(pid);
     mojo_ipc_channel_->ChildProcessLaunched();
     mojo::edk::ChildProcessLaunched(
         handle, mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(
-                    mojo_ipc_channel_->PassServerHandle().release().handle)));
+                    mojo_ipc_channel_->PassServerHandle().release().handle)),
+        child_token_);
   }
 
  private:
   // Used to back the NodeChannel between the parent and child node.
+  const std::string child_token_;
   std::unique_ptr<mojo::edk::PlatformChannelPair> mojo_ipc_channel_;
 
   mojo::edk::HandlePassingInformation handle_passing_info_;
 
   shell::mojom::PIDReceiverPtr pid_receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundTestState);
 };
 
 // Called used destroy BackgroundTestState on the background thread.
@@ skipping 93 matching lines @@
 MojoTestConnector::~MojoTestConnector() {}
 
 std::unique_ptr<content::TestState> MojoTestConnector::PrepareForTest(
     base::CommandLine* command_line,
     base::TestLauncher::LaunchOptions* test_launch_options) {
   std::unique_ptr<MojoTestState> test_state(
       new MojoTestState(&background_shell_));
   test_state->Init(command_line, test_launch_options);
   return std::move(test_state);
 }