Remove uses of CloseProcessHandle.

remoting/host/desktop_session_proxy.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 "remoting/host/desktop_session_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/process/process_handle.h"
 #include "base/memory/shared_memory.h"
@@ skipping 96 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control,
     base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
     bool virtual_terminal)
     : audio_capture_task_runner_(audio_capture_task_runner),
       caller_task_runner_(caller_task_runner),
       io_task_runner_(io_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       client_session_control_(client_session_control),
       desktop_session_connector_(desktop_session_connector),
-      desktop_process_(base::kNullProcessHandle),
       pending_capture_frame_requests_(0),
       is_desktop_session_connected_(false),
       virtual_terminal_(virtual_terminal) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 scoped_ptr<AudioCapturer> DesktopSessionProxy::CreateAudioCapturer() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return make_scoped_ptr(new IpcAudioCapturer(this));
@@ skipping 83 matching lines @@
   VLOG(1) << "IPC: network <- desktop (" << peer_pid << ")";
 }
 
 void DesktopSessionProxy::OnChannelError() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   DetachFromDesktop();
 }
 
 bool DesktopSessionProxy::AttachToDesktop(
-    base::ProcessHandle desktop_process,
+    base::Process desktop_process,
     IPC::PlatformFileForTransit desktop_pipe) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!desktop_channel_);
-  DCHECK_EQ(desktop_process_, base::kNullProcessHandle);
+  DCHECK(!desktop_process_.IsValid());
 
   // Ignore the attach notification if the client session has been disconnected
   // already.
-  if (!client_session_control_.get()) {
-    base::CloseProcessHandle(desktop_process);
+  if (!client_session_control_.get())
     return false;
-  }
 
-  desktop_process_ = desktop_process;
+  desktop_process_ = desktop_process.Pass();
 
 #if defined(OS_WIN)
   // On Windows: |desktop_process| is a valid handle, but |desktop_pipe| needs
   // to be duplicated from the desktop process.
   HANDLE temp_handle;
-  if (!DuplicateHandle(desktop_process_, desktop_pipe, GetCurrentProcess(),
-                       &temp_handle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+  if (!DuplicateHandle(desktop_process_.Handle(), desktop_pipe,
+                       GetCurrentProcess(), &temp_handle, 0,
+                       FALSE, DUPLICATE_SAME_ACCESS)) {
     PLOG(ERROR) << "Failed to duplicate the desktop-to-network pipe handle";
 
-    desktop_process_ = base::kNullProcessHandle;
-    base::CloseProcessHandle(desktop_process);
+    desktop_process_.Close();
     return false;
   }
   base::win::ScopedHandle pipe(temp_handle);
 
   IPC::ChannelHandle desktop_channel_handle(pipe.Get());
 
 #elif defined(OS_POSIX)
   // On posix: |desktop_pipe| is a valid file descriptor.
   DCHECK(desktop_pipe.auto_close);
 
@@ skipping 17 matching lines @@
       virtual_terminal_));
 
   return true;
 }
 
 void DesktopSessionProxy::DetachFromDesktop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   desktop_channel_.reset();
 
-  if (desktop_process_ != base::kNullProcessHandle) {
-    base::CloseProcessHandle(desktop_process_);
-    desktop_process_ = base::kNullProcessHandle;
-  }
+  if (desktop_process_.IsValid())
+    desktop_process_.Close();
 
   shared_buffers_.clear();
 
   // Generate fake responses to keep the video capturer in sync.
   while (pending_capture_frame_requests_) {
     --pending_capture_frame_requests_;
     PostCaptureCompleted(nullptr);
   }
 }
 
@@ skipping 128 matching lines @@
     desktop_session_connector_->SetScreenResolution(this, screen_resolution_);
   SendToDesktop(
       new ChromotingNetworkDesktopMsg_SetScreenResolution(screen_resolution_));
 }
 
 DesktopSessionProxy::~DesktopSessionProxy() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_session_connector_.get() && is_desktop_session_connected_)
     desktop_session_connector_->DisconnectTerminal(this);
-
-  if (desktop_process_ != base::kNullProcessHandle) {
-    base::CloseProcessHandle(desktop_process_);
-    desktop_process_ = base::kNullProcessHandle;
-  }
 }
 
 scoped_refptr<DesktopSessionProxy::IpcSharedBufferCore>
 DesktopSessionProxy::GetSharedBufferCore(int id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   SharedBuffers::const_iterator i = shared_buffers_.find(id);
   if (i != shared_buffers_.end()) {
     return i->second;
   } else {
@@ skipping 19 matching lines @@
                             base::Passed(&packet)));
 }
 
 void DesktopSessionProxy::OnCreateSharedBuffer(
     int id,
     IPC::PlatformFileForTransit handle,
     uint32 size) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   scoped_refptr<IpcSharedBufferCore> shared_buffer =
-      new IpcSharedBufferCore(id, handle, desktop_process_, size);
+      new IpcSharedBufferCore(id, handle, desktop_process_.Handle(), size);
 
   if (shared_buffer->memory() != nullptr &&
       !shared_buffers_.insert(std::make_pair(id, shared_buffer)).second) {
     LOG(ERROR) << "Duplicate shared buffer id " << id << " encountered";
   }
 }
 
 void DesktopSessionProxy::OnReleaseSharedBuffer(int id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
@@ skipping 78 matching lines @@
 }
 
 // static
 void DesktopSessionProxyTraits::Destruct(
     const DesktopSessionProxy* desktop_session_proxy) {
   desktop_session_proxy->caller_task_runner_->DeleteSoon(FROM_HERE,
                                                          desktop_session_proxy);
 }
 
 }  // namespace remoting