Don't pass ProcessHandle through ChildProcessHostDelegate.

content/common/child_process_host_impl.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 "content/common/child_process_host_impl.h"
 
 #include <limits>
 
 #include "base/atomic_sequence_num.h"
 #include "base/command_line.h"
@@ skipping 121 matching lines @@
     // results in Chromium Helper EH.app or Google Chrome Helper EH.app.
     child_path = TransformPathForFeature(child_path, "EH");
   }
 #endif
 
   return child_path;
 }
 
 ChildProcessHostImpl::ChildProcessHostImpl(ChildProcessHostDelegate* delegate)
     : delegate_(delegate),
-      peer_handle_(base::kNullProcessHandle),
       opening_channel_(false) {
 #if defined(OS_WIN)
   AddFilter(new FontCacheDispatcher());
 #endif
 }
 
 ChildProcessHostImpl::~ChildProcessHostImpl() {
   for (size_t i = 0; i < filters_.size(); ++i) {
     filters_[i]->OnChannelClosing();
     filters_[i]->OnFilterRemoved();
   }
-
-  base::CloseProcessHandle(peer_handle_);
 }
 
 void ChildProcessHostImpl::AddFilter(IPC::MessageFilter* filter) {
   filters_.push_back(filter);
 
   if (channel_)
     filter->OnFilterAdded(channel_.get());
 }
 
 void ChildProcessHostImpl::ForceShutdown() {
@@ skipping 104 matching lines @@
   }
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
     logger->OnPostDispatchMessage(msg, channel_id_);
 #endif
   return handled;
 }
 
 void ChildProcessHostImpl::OnChannelConnected(int32 peer_pid) {
-  if (!peer_handle_ &&
-      !base::OpenPrivilegedProcessHandle(peer_pid, &peer_handle_)) {
-    peer_handle_ = delegate_->GetHandle();
-    DCHECK(peer_handle_);
+  if (!peer_process_.IsValid()) {
+    base::ProcessHandle peer_handle_;
+    if (base::OpenPrivilegedProcessHandle(peer_pid, &peer_handle_)) {
+      // TODO(rvargas) crbug.com/417532: don't go through a ProcessHandle.
+      if (peer_handle_ == base::GetCurrentProcessHandle())
+        peer_process_ = base::Process::Current();
+      else
+        peer_process_ = base::Process(peer_handle_);
+    } else {
+      peer_process_ = delegate_->GetProcess().Duplicate();
+    }
+    DCHECK(peer_process_.IsValid());
   }
   opening_channel_ = false;
   delegate_->OnChannelConnected(peer_pid);
   for (size_t i = 0; i < filters_.size(); ++i)
     filters_[i]->OnChannelConnected(peer_pid);
 }
 
 void ChildProcessHostImpl::OnChannelError() {
   opening_channel_ = false;
   delegate_->OnChannelError();
 
   for (size_t i = 0; i < filters_.size(); ++i)
     filters_[i]->OnChannelError();
 
   // This will delete host_, which will also destroy this!
   delegate_->OnChildDisconnected();
 }
 
 void ChildProcessHostImpl::OnBadMessageReceived(const IPC::Message& message) {
   delegate_->OnBadMessageReceived(message);
 }
 
 void ChildProcessHostImpl::OnAllocateSharedMemory(
     uint32 buffer_size,
     base::SharedMemoryHandle* handle) {
-  AllocateSharedMemory(buffer_size, peer_handle_, handle);
+  AllocateSharedMemory(buffer_size, peer_process_.Handle(), handle);
 }
 
 void ChildProcessHostImpl::OnShutdownRequest() {
   if (delegate_->CanShutdown())
     Send(new ChildProcessMsg_Shutdown());
 }
 
 void ChildProcessHostImpl::OnAllocateGpuMemoryBuffer(
     uint32 width,
     uint32 height,
@@ skipping 13 matching lines @@
     GpuMemoryBufferAllocated(reply, gfx::GpuMemoryBufferHandle());
     return;
   }
 
   // Note: It is safe to use base::Unretained here as the shared memory
   // implementation of AllocateForChildProcess() calls this synchronously.
   GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
       g_next_gpu_memory_buffer_id.GetNext(),
       gfx::Size(width, height),
       format,
-      peer_handle_,
+      peer_process_.Handle(),
       base::Bind(&ChildProcessHostImpl::GpuMemoryBufferAllocated,
                  base::Unretained(this),
                  reply));
 }
 
 void ChildProcessHostImpl::OnDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     uint32 sync_point) {
   // Note: Nothing to do here as ownership of shared memory backed
   // GpuMemoryBuffers is passed with IPC.
 }
 
 void ChildProcessHostImpl::GpuMemoryBufferAllocated(
     IPC::Message* reply,
     const gfx::GpuMemoryBufferHandle& handle) {
   ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer::WriteReplyParams(reply,
                                                                     handle);
   Send(reply);
 }
 
 }  // namespace content