Remove implicit HANDLE conversions from remoting.

remoting/host/win/unprivileged_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/unprivileged_process_delegate.h"
 
@@ skipping 65 matching lines @@
 bool CreateRestrictedToken(ScopedHandle* token_out) {
   // Create a token representing LocalService account.
   HANDLE temp_handle;
   if (!LogonUser(L"LocalService", L"NT AUTHORITY", NULL, LOGON32_LOGON_SERVICE,
                  LOGON32_PROVIDER_DEFAULT, &temp_handle)) {
     return false;
   }
   ScopedHandle token(temp_handle);
 
   sandbox::RestrictedToken restricted_token;
-  if (restricted_token.Init(token) != ERROR_SUCCESS)
+  if (restricted_token.Init(token.Get()) != ERROR_SUCCESS)
     return false;
 
   // Remove all privileges in the token.
   if (restricted_token.DeleteAllPrivileges(NULL) != ERROR_SUCCESS)
     return false;
 
   // Set low integrity level if supported by the OS.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     if (restricted_token.SetIntegrityLevel(sandbox::INTEGRITY_LEVEL_LOW)
         != ERROR_SUCCESS) {
@@ skipping 141 matching lines @@
   // Create a restricted token that will be used to run the worker process.
   ScopedHandle token;
   if (!CreateRestrictedToken(&token)) {
     PLOG(ERROR) << "Failed to create a restricted LocalService token";
     ReportFatalError();
     return;
   }
 
   // Determine our logon SID, so we can grant it access to our window station
   // and desktop.
-  ScopedSid logon_sid = GetLogonSid(token);
+  ScopedSid logon_sid = GetLogonSid(token.Get());
   if (!logon_sid) {
     PLOG(ERROR) << "Failed to retrieve the logon SID";
     ReportFatalError();
     return;
   }
 
   // Create the process and thread security descriptors.
   ScopedSd process_sd = ConvertSddlToSd(kWorkerProcessSd);
   ScopedSd thread_sd = ConvertSddlToSd(kWorkerThreadSd);
   if (!process_sd || !thread_sd) {
@@ skipping 40 matching lines @@
       PLOG(ERROR) << "Failed to create a window station and desktop";
       ReportFatalError();
       return;
     }
 
     // Try to launch the worker process. The launched process inherits
     // the window station, desktop and pipe handles, created above.
     ScopedHandle worker_thread;
     if (!LaunchProcessWithToken(command_line.GetProgram(),
                                 command_line.GetCommandLineString(),
-                                token,
+                                token.Get(),
                                 &process_attributes,
                                 &thread_attributes,
                                 true,
                                 0,
                                 NULL,
                                 &worker_process,
                                 &worker_thread)) {
       ReportFatalError();
       return;
     }
@@ skipping 19 matching lines @@
   channel_.reset();
 }
 
 void UnprivilegedProcessDelegate::KillProcess() {
   DCHECK(CalledOnValidThread());
 
   channel_.reset();
   event_handler_ = NULL;
 
   if (worker_process_.IsValid()) {
-    TerminateProcess(worker_process_, CONTROL_C_EXIT);
+    TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
     worker_process_.Close();
   }
 }
 
 bool UnprivilegedProcessDelegate::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   return event_handler_->OnMessageReceived(message);
 }
 
 void UnprivilegedProcessDelegate::OnChannelConnected(int32 peer_pid) {
   DCHECK(CalledOnValidThread());
 
-  DWORD pid = GetProcessId(worker_process_);
+  DWORD pid = GetProcessId(worker_process_.Get());
   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();
     return;
   }
 
   event_handler_->OnChannelConnected(peer_pid);
 }
@@ skipping 20 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);
 
   event_handler_->OnProcessLaunched(limited_handle.Pass());
 }
 
 }  // namespace remoting