Remove implicit HANDLE conversions from remoting.

remoting/host/win/launch_process_with_token.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/win/launch_process_with_token.h"
 
 #include <windows.h>
 #include <winternl.h>
 
 #include <limits>
@@ skipping 114 matching lines @@
 bool CopyProcessToken(DWORD desired_access, ScopedHandle* token_out) {
   HANDLE temp_handle;
   if (!OpenProcessToken(GetCurrentProcess(),
                         TOKEN_DUPLICATE | desired_access,
                         &temp_handle)) {
     PLOG(ERROR) << "Failed to open process token";
     return false;
   }
   ScopedHandle process_token(temp_handle);
 
-  if (!DuplicateTokenEx(process_token,
+  if (!DuplicateTokenEx(process_token.Get(),
                         desired_access,
                         NULL,
                         SecurityImpersonation,
                         TokenPrimary,
                         &temp_handle)) {
     PLOG(ERROR) << "Failed to duplicate the process token";
     return false;
   }
 
   token_out->Set(temp_handle);
@@ skipping 12 matching lines @@
   // Get the LUID for the SE_TCB_NAME privilege.
   TOKEN_PRIVILEGES state;
   state.PrivilegeCount = 1;
   state.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
   if (!LookupPrivilegeValue(NULL, SE_TCB_NAME, &state.Privileges[0].Luid)) {
     PLOG(ERROR) << "Failed to lookup the LUID for the SE_TCB_NAME privilege";
     return false;
   }
 
   // Enable the SE_TCB_NAME privilege.
-  if (!AdjustTokenPrivileges(privileged_token, FALSE, &state, 0, NULL, 0)) {
+  if (!AdjustTokenPrivileges(privileged_token.Get(), FALSE, &state, 0, NULL,
+                             0)) {
     PLOG(ERROR) << "Failed to enable SE_TCB_NAME privilege in a token";
     return false;
   }
 
   *token_out = privileged_token.Pass();
   return true;
 }
 
 // Fills the process and thread handles in the passed |process_information|
 // structure and resume the process if the caller didn't want to suspend it.
@@ skipping 194 matching lines @@
     const base::CommandLine::StringType& command_line,
     DWORD creation_flags,
     const base::char16* desktop_name,
     PROCESS_INFORMATION* process_information_out) {
   DCHECK_LT(base::win::GetVersion(), base::win::VERSION_VISTA);
 
   base::win::ScopedHandle pipe;
   if (!ConnectToExecutionServer(session_id, &pipe))
     return false;
 
-  if (!SendCreateProcessRequest(pipe, application_name, command_line,
+  if (!SendCreateProcessRequest(pipe.Get(), application_name, command_line,
                                 creation_flags, desktop_name)) {
     return false;
   }
 
   PROCESS_INFORMATION process_information;
-  if (!ReceiveCreateProcessResponse(pipe, &process_information))
+  if (!ReceiveCreateProcessResponse(pipe.Get(), &process_information))
     return false;
 
   if (!ProcessCreateProcessResponse(creation_flags, &process_information)) {
     CloseHandlesAndTerminateProcess(&process_information);
     return false;
   }
 
   *process_information_out = process_information;
   return true;
 }
@@ skipping 14 matching lines @@
   if (!CopyProcessToken(desired_access, &session_token)) {
     return false;
   }
 
   // Temporarily enable the SE_TCB_NAME privilege as it is required by
   // SetTokenInformation(TokenSessionId).
   ScopedHandle privileged_token;
   if (!CreatePrivilegedToken(&privileged_token)) {
     return false;
   }
-  if (!ImpersonateLoggedOnUser(privileged_token)) {
+  if (!ImpersonateLoggedOnUser(privileged_token.Get())) {
     PLOG(ERROR) << "Failed to impersonate the privileged token";
     return false;
   }
 
   // Change the session ID of the token.
   DWORD new_session_id = session_id;
-  if (!SetTokenInformation(session_token,
+  if (!SetTokenInformation(session_token.Get(),
                            TokenSessionId,
                            &new_session_id,
                            sizeof(new_session_id))) {
     PLOG(ERROR) << "Failed to change session ID of a token";
 
     // Revert to the default token.
     CHECK(RevertToSelf());
     return false;
   }
 
@@ skipping 72 matching lines @@
 
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
   CHECK(process_info.IsValid());
   process_out->Set(process_info.TakeProcessHandle());
   thread_out->Set(process_info.TakeThreadHandle());
   return true;
 }
 
 }  // namespace remoting