Mojo EDK: Add safe process connection API

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"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/test_launcher.h"
 #include "mojo/edk/embedder/embedder.h"
+#include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/catalog/store.h"
 #include "services/service_manager/background/background_service_manager.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "services/service_manager/runner/common/switches.h"
 #include "services/service_manager/runner/host/service_process_launcher.h"
 #include "services/service_manager/service_manager.h"
 #include "services/service_manager/switches.h"
 
 namespace {
 
 const char kTestRunnerName[] = "mash_browser_tests";
 const char kTestName[] = "content_browser";
 
 // State created per test to register a client process with the background
 // service manager.
 class MojoTestState : public content::TestState {
  public:
   explicit MojoTestState(
       service_manager::BackgroundServiceManager* background_service_manager)
-      : child_token_(mojo::edk::GenerateRandomToken()),
-        background_service_manager_(background_service_manager),
+      : background_service_manager_(background_service_manager),
         weak_factory_(this) {}
   ~MojoTestState() override {}
 
   void Init(base::CommandLine* command_line,
             base::TestLauncher::LaunchOptions* test_launch_options) {
     command_line->AppendSwitch(MojoTestConnector::kTestSwitch);
     command_line->AppendSwitch(switches::kChildProcess);
 
     platform_channel_ = base::MakeUnique<mojo::edk::PlatformChannelPair>();
 
     platform_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
     service_manager::mojom::ServicePtr service =
-        service_manager::PassServiceRequestOnCommandLine(command_line,
-                                                         child_token_);
+        service_manager::PassServiceRequestOnCommandLine(&process_connection_,
+                                                         command_line);
 
     background_service_manager_->RegisterService(
         service_manager::Identity(
             kTestName, service_manager::mojom::kRootUserID),
         std::move(service),
         service_manager::mojom::PIDReceiverRequest(&pid_receiver_));
 
     // 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();
-    mojo::edk::ChildProcessLaunched(
-        handle, platform_channel_->PassServerHandle(), child_token_);
+    process_connection_.Connect(handle, platform_channel_->PassServerHandle());
 
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&MojoTestState::SetPID, weak_factory_.GetWeakPtr(), pid));
   }
 
   // Called on the main thread only.
   void SetPID(base::ProcessId pid) {
     DCHECK(pid_receiver_.is_bound());
     pid_receiver_->SetPID(pid);
     pid_receiver_.reset();
   }
 
-  const std::string child_token_;
+  mojo::edk::PendingProcessConnection process_connection_;
   service_manager::BackgroundServiceManager* const background_service_manager_;
 
   // 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;
 
@@ skipping 88 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;
 }