Sandbox: Remove job_object from (IPCInfo::)ClientInfo.

sandbox/win/src/sharedmem_ipc_server.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 "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "sandbox/win/src/sharedmem_ipc_server.h"
 #include "sandbox/win/src/sharedmem_ipc_client.h"
 #include "sandbox/win/src/sandbox.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "sandbox/win/src/crosscall_params.h"
 #include "sandbox/win/src/crosscall_server.h"
 
 namespace {
 // This handle must not be closed.
 volatile HANDLE g_alive_mutex = NULL;
 }
 
 namespace sandbox {
 
 SharedMemIPCServer::SharedMemIPCServer(HANDLE target_process,
                                        DWORD target_process_id,
-                                       HANDLE target_job,
                                        ThreadProvider* thread_provider,
                                        Dispatcher* dispatcher)
     : client_control_(NULL),
       thread_provider_(thread_provider),
       target_process_(target_process),
       target_process_id_(target_process_id),
-      target_job_object_(target_job),
       call_dispatcher_(dispatcher) {
   // We create a initially owned mutex. If the server dies unexpectedly,
   // the thread that owns it will fail to release the lock and windows will
   // report to the target (when it tries to acquire it) that the wait was
   // abandoned. Note: We purposely leak the local handle because we want it to
   // be closed by Windows itself so it is properly marked as abandoned if the
   // server dies.
   if (!g_alive_mutex) {
     HANDLE mutex = ::CreateMutexW(NULL, TRUE, NULL);
     if (::InterlockedCompareExchangePointer(&g_alive_mutex, mutex, NULL)) {
@@ skipping 62 matching lines @@
     if (!MakeEvents(&service_context->ping_event,
                     &service_context->pong_event,
                     &client_context->ping_event,
                     &client_context->pong_event)) {
       return false;
     }
 
     client_context->channel_base = base_start;
     client_context->state = kFreeChannel;
 
-    // Note that some of these values are available as members of this
-    // object but we put them again into the service_context because we
-    // will be called on a static method (ThreadPingEventReady)
+    // Note that some of these values are available as members of this object
+    // but we put them again into the service_context because we will be called
+    // on a static method (ThreadPingEventReady). In particular, target_process_
+    // is a raw handle that is not owned by this object (it's owned by the
+    // owner of this object), and we are storing it in multiple places.
     service_context->shared_base = reinterpret_cast<char*>(shared_mem);
     service_context->channel_size = channel_size;
     service_context->channel = client_context;
     service_context->channel_buffer = service_context->shared_base +
                                       client_context->channel_base;
     service_context->dispatcher = call_dispatcher_;
     service_context->target_info.process = target_process_;
     service_context->target_info.process_id = target_process_id_;
-    service_context->target_info.job_object = target_job_object_;
     // Advance to the next channel.
     base_start += channel_size;
     // Register the ping event with the threadpool.
     thread_provider_->RegisterWait(this, service_context->ping_event,
                                    ThreadPingEventReady, service_context);
   }
   if (!::DuplicateHandle(::GetCurrentProcess(), g_alive_mutex,
                          target_process_, &client_control_->server_alive,
                          SYNCHRONIZE | EVENT_MODIFY_STATE, FALSE, 0)) {
     return false;
@@ skipping 278 matching lines @@
   }
   *server_pong = ::CreateEventW(NULL, FALSE, FALSE, NULL);
   if (!::DuplicateHandle(::GetCurrentProcess(), *server_pong, target_process_,
                          client_pong, kDesiredAccess, FALSE, 0)) {
     return false;
   }
   return true;
 }
 
 }  // namespace sandbox