Remove implicit HANDLE conversions from remoting.

remoting/host/win/wts_session_process_delegate.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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_delegate.h"
 
 #include "base/bind.h"
@@ skipping 170 matching lines @@
     }
 
     // Limit the number of active processes in the job to two (the helper
     // process performing elevation and the worker process itself) and make sure
     // that all processes will be killed once the job object is destroyed.
     JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
     memset(&info, 0, sizeof(info));
     info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_ACTIVE_PROCESS |
         JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
     info.BasicLimitInformation.ActiveProcessLimit = 2;
-    if (!SetInformationJobObject(job,
+    if (!SetInformationJobObject(job.Get(),
                                  JobObjectExtendedLimitInformation,
                                  &info,
                                  sizeof(info))) {
       PLOG(ERROR) << "Failed to set limits on the job object";
       return false;
     }
 
     // ScopedHandle is not compatible with base::Passed, so we wrap it to
     // a scoped pointer.
     scoped_ptr<ScopedHandle> job_wrapper(new ScopedHandle());
@@ skipping 52 matching lines @@
 void WtsSessionProcessDelegate::Core::KillProcess() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   channel_.reset();
   event_handler_ = NULL;
   launch_pending_ = false;
   pipe_.Close();
 
   if (launch_elevated_) {
     if (job_.IsValid())
-      TerminateJobObject(job_, CONTROL_C_EXIT);
+      TerminateJobObject(job_.Get(), CONTROL_C_EXIT);
   } else {
     if (worker_process_.IsValid())
-      TerminateProcess(worker_process_, CONTROL_C_EXIT);
+      TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
   }
 
   worker_process_.Close();
 }
 
 WtsSessionProcessDelegate::Core::~Core() {
   DCHECK(!channel_);
   DCHECK(!event_handler_);
   DCHECK(!pipe_.IsValid());
   DCHECK(!worker_process_.IsValid());
@@ skipping 21 matching lines @@
 }
 
 void WtsSessionProcessDelegate::Core::OnChannelConnected(int32 peer_pid) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Report the worker PID now if the worker process is launched indirectly.
   // Note that in this case the pipe's security descriptor is the only
   // protection against a malicious processed connecting to the pipe.
   if (launch_elevated_) {
     DWORD pid;
-    if (!get_named_pipe_client_pid_(pipe_, &pid)) {
+    if (!get_named_pipe_client_pid_(pipe_.Get(), &pid)) {
       PLOG(ERROR) << "Failed to retrive PID of the client";
       ReportFatalError();
       return;
     }
 
     if (pid != static_cast<DWORD>(peer_pid)) {
       LOG(ERROR) << "The actual client PID " << pid
                  << " does not match the one reported by the client: "
                  << peer_pid;
       ReportFatalError();
@@ skipping 53 matching lines @@
   // Create the server end of the IPC channel.
   std::string channel_name = IPC::Channel::GenerateUniqueRandomChannelID();
   ScopedHandle pipe;
   if (!CreateIpcChannel(channel_name, channel_security_, &pipe)) {
     ReportFatalError();
     return;
   }
 
   // Wrap the pipe into an IPC channel.
   scoped_ptr<IPC::ChannelProxy> channel(
-      IPC::ChannelProxy::Create(IPC::ChannelHandle(pipe),
+      IPC::ChannelProxy::Create(IPC::ChannelHandle(pipe.Get()),
                                 IPC::Channel::MODE_SERVER,
                                 this,
                                 io_task_runner_));
 
   // Pass the name of the IPC channel to use.
   command_line.AppendSwitchNative(kDaemonPipeSwitchName,
                                   base::UTF8ToWide(channel_name));
 
   // Try to launch the process.
   ScopedHandle worker_process;
   ScopedHandle worker_thread;
   if (!LaunchProcessWithToken(command_line.GetProgram(),
                               command_line.GetCommandLineString(),
-                              session_token_,
+                              session_token_.Get(),
                               NULL,
                               NULL,
                               false,
                               CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB,
                               base::UTF8ToUTF16(kDefaultDesktopName).c_str(),
                               &worker_process,
                               &worker_thread)) {
     ReportFatalError();
     return;
   }
 
   if (launch_elevated_) {
-    if (!AssignProcessToJobObject(job_, worker_process)) {
+    if (!AssignProcessToJobObject(job_.Get(), worker_process.Get())) {
       PLOG(ERROR) << "Failed to assign the worker to the job object";
       ReportFatalError();
       return;
     }
   }
 
-  if (!ResumeThread(worker_thread)) {
+  if (!ResumeThread(worker_thread.Get())) {
     PLOG(ERROR) << "Failed to resume the worker thread";
     ReportFatalError();
     return;
   }
 
   channel_ = channel.Pass();
   pipe_ = pipe.Pass();
 
   // Report success if the worker process is lauched directly. Otherwise, PID of
   // the client connected to the pipe will be used later. See
@@ skipping 78 matching lines @@
   DCHECK(!worker_process_.IsValid());
 
   worker_process_ = worker_process.Pass();
 
   // Report a handle that can be used to wait for the worker process completion,
   // query information about the process and duplicate handles.
   DWORD desired_access =
       SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
   HANDLE temp_handle;
   if (!DuplicateHandle(GetCurrentProcess(),
-                       worker_process_,
+                       worker_process_.Get(),
                        GetCurrentProcess(),
                        &temp_handle,
                        desired_access,
                        FALSE,
                        0)) {
     PLOG(ERROR) << "Failed to duplicate a handle";
     ReportFatalError();
     return;
   }
   ScopedHandle limited_handle(temp_handle);
@@ skipping 31 matching lines @@
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting