Add sandbox support for associating peer processes

sandbox/tests/common/controller.cc

 // Copyright (c) 2012 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 "sandbox/tests/common/controller.h"
 
 #include <string>
 
+#include "base/process.h"
+#include "base/process_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "sandbox/src/sandbox_factory.h"
 #include "sandbox/src/sandbox_utils.h"
 
 namespace {
 
 static const int kDefaultTimeout = 3000;
 
 // Constructs a full path to a file inside the system32 folder.
@@ skipping 63 matching lines @@
       return NULL;
 
     is_initialized = true;
   }
 
   return broker;
 }
 
 TestRunner::TestRunner(JobLevel job_level, TokenLevel startup_token,
                        TokenLevel main_token)
-    : is_init_(false), is_async_(false), target_process_id_(0) {
+    : is_init_(false), is_async_(false), no_sandbox_(false),
+      target_process_id_(0) {
   Init(job_level, startup_token, main_token);
 }
 
 TestRunner::TestRunner()
-    : is_init_(false), is_async_(false), target_process_id_(0) {
+    : is_init_(false), is_async_(false), no_sandbox_(false),
+      target_process_id_(0) {
   Init(JOB_LOCKDOWN, USER_RESTRICTED_SAME_ACCESS, USER_LOCKDOWN);
 }
 
 void TestRunner::Init(JobLevel job_level, TokenLevel startup_token,
                       TokenLevel main_token) {
   broker_ = NULL;
   policy_ = NULL;
   timeout_ = kDefaultTimeout;
   state_ = AFTER_REVERT;
   is_async_= false;
@@ skipping 94 matching lines @@
   // Get the path to the sandboxed process.
   wchar_t prog_name[MAX_PATH];
   GetModuleFileNameW(NULL, prog_name, MAX_PATH);
 
   // Launch the sandboxed process.
   ResultCode result = SBOX_ALL_OK;
   PROCESS_INFORMATION target = {0};
 
   std::wstring arguments(L"\"");
   arguments += prog_name;
-  arguments += L"\" -child ";
+  arguments += L"\" -child";
+  arguments += no_sandbox_ ? L"-no-sandbox " : L" ";
   arguments += command;
 
-  result = broker_->SpawnTarget(prog_name, arguments.c_str(), policy_,
-                                &target);
+  if (no_sandbox_) {
+    STARTUPINFO startup_info = {sizeof(STARTUPINFO)};
+    if (!::CreateProcessW(prog_name, &arguments[0], NULL, NULL, FALSE, 0,
+                          NULL, NULL, &startup_info, &target)) {
+      return SBOX_ERROR_GENERIC;
+    }
+    broker_->AddTargetPeer(target.hProcess);
+  } else {
+    result = broker_->SpawnTarget(prog_name, arguments.c_str(), policy_,
+                                  &target);
+  }
 
   if (SBOX_ALL_OK != result)
     return SBOX_TEST_FAILED_TO_RUN_TEST;
 
   ::ResumeThread(target.hThread);
 
   // For an asynchronous run we don't bother waiting.
   if (is_async_) {
     target_process_.Set(target.hProcess);
     target_process_id_ = target.dwProcessId;
@@ skipping 70 matching lines @@
                                 ::GetProcAddress(module, command_name.c_str()));
   if (!command)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   if (BEFORE_INIT == state)
     return command(argc - 4, argv + 4);
   else if (EVERY_STATE == state)
     command(argc - 4, argv + 4);
 
   TargetServices* target = SandboxFactory::GetTargetServices();
-  if (!target)
+  if (target) {
+    if (SBOX_ALL_OK != target->Init())
+      return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
+
+    if (BEFORE_REVERT == state)
+      return command(argc - 4, argv + 4);
+    else if (EVERY_STATE == state)
+      command(argc - 4, argv + 4);
+
+    target->LowerToken();
+  } else if (0 != _wcsicmp(argv[1], L"-child-no-sandbox")) {
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
+  }
 
-  if (SBOX_ALL_OK != target->Init())
-    return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
-
-  if (BEFORE_REVERT == state)
-    return command(argc - 4, argv + 4);
-  else if (EVERY_STATE == state)
-    command(argc - 4, argv + 4);
-
-  target->LowerToken();
   return command(argc - 4, argv + 4);
 }
 
 }  // namespace sandbox