Add a sandbox API for broker handle duplication

sandbox/src/broker_services.cc

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// 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/src/broker_services.h"
 
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
 #include "sandbox/src/sandbox_policy_base.h"
 #include "sandbox/src/sandbox.h"
 #include "sandbox/src/target_process.h"
@@ skipping 165 matching lines @@
         case JOB_OBJECT_MSG_NEW_PROCESS: {
           ++target_counter;
           if (1 == target_counter) {
             ::ResetEvent(no_targets);
           }
           break;
         }
 
         case JOB_OBJECT_MSG_EXIT_PROCESS:
         case JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS: {
+          {
+            AutoLock lock(&broker->lock_);
+            broker->child_process_ids_.erase(reinterpret_cast<DWORD>(ovl));
+          }
           --target_counter;
           if (0 == target_counter)
             ::SetEvent(no_targets);
 
           DCHECK(target_counter >= 0);
           break;
         }
 
         case JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT: {
           break;
@@ skipping 88 matching lines @@
 
   // We are going to keep a pointer to the policy because we'll call it when
   // the job object generates notifications using the completion port.
   policy_base->AddRef();
   JobTracker* tracker = new JobTracker(job, policy_base);
   if (!AssociateCompletionPort(job, job_port_, tracker))
     return SpawnCleanup(target, 0);
   // Save the tracker because in cleanup we might need to force closing
   // the Jobs.
   tracker_list_.push_back(tracker);
+  child_process_ids_.insert(process_info.dwProcessId);
 
   // We return the caller a duplicate of the process handle so they
   // can close it at will.
   HANDLE dup_process_handle = NULL;
   if (!::DuplicateHandle(::GetCurrentProcess(), process_info.hProcess,
                          ::GetCurrentProcess(), &dup_process_handle,
                          0, FALSE, DUPLICATE_SAME_ACCESS))
     return SpawnCleanup(target, 0);
 
   *target_info = process_info;
   target_info->hProcess = dup_process_handle;
   return SBOX_ALL_OK;
 }
 
 
 ResultCode BrokerServicesBase::WaitForAllTargets() {
   ::WaitForSingleObject(no_targets_, INFINITE);
   return SBOX_ALL_OK;
 }
 
+bool BrokerServicesBase::IsActiveTarget(DWORD process_id) {
+  AutoLock lock(&lock_);
+  return child_process_ids_.find(process_id) != child_process_ids_.end();
+}
+
 }  // namespace sandbox