Base: Remove Receive() from ScopedHandle.

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 56 matching lines @@
 // Security descriptor of the worker process threads. It gives access SYSTEM
 // full access to the threads. It gives READ_CONTROL, SYNCHRONIZE,
 // THREAD_QUERY_INFORMATION and THREAD_TERMINATE rights to the built-in
 // administrators group.
 const char kWorkerThreadSd[] = "O:SYG:SYD:(A;;GA;;;SY)(A;;0x120801;;;BA)";
 
 // Creates a token with limited access that will be used to run the worker
 // process.
 bool CreateRestrictedToken(ScopedHandle* token_out) {
   // Create a token representing LocalService account.
-  ScopedHandle token;
+  HANDLE temp_handle;
   if (!LogonUser(L"LocalService", L"NT AUTHORITY", NULL, LOGON32_LOGON_SERVICE,
-                 LOGON32_PROVIDER_DEFAULT, token.Receive())) {
+                 LOGON32_PROVIDER_DEFAULT, &temp_handle)) {
     return false;
   }
+  ScopedHandle token;
+  token.Set(temp_handle);
 
   sandbox::RestrictedToken restricted_token;
   if (restricted_token.Init(token) != 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) {
       return false;
     }
   }
 
   // Return the resulting token.
-  return restricted_token.GetRestrictedTokenHandle(token_out->Receive()) ==
-      ERROR_SUCCESS;
+  if (restricted_token.GetRestrictedTokenHandle(&temp_handle) ==
+      ERROR_SUCCESS) {
+    token_out->Set(temp_handle);
+    return true;
+  }
+  return false;
 }
 
 // Creates a window station with a given name and the default desktop giving
 // the complete access to |logon_sid|.
 bool CreateWindowStationAndDesktop(ScopedSid logon_sid,
                                    WindowStationAndDesktop* handles_out) {
   // Convert the logon SID into a string.
   std::string logon_sid_string = ConvertSidToString(logon_sid.get());
   if (logon_sid_string.empty()) {
     LOG_GETLASTERROR(ERROR) << "Failed to convert a SID to string";
@@ skipping 154 matching lines @@
   thread_attributes.lpSecurityDescriptor = thread_sd.get();
   thread_attributes.bInheritHandle = FALSE;
 
   ScopedHandle worker_process;
   {
     // Take a lock why any inheritable handles are open to make sure that only
     // one process inherits them.
     base::AutoLock lock(g_inherit_handles_lock.Get());
 
     // Create a connected IPC channel.
-    ScopedHandle client;
-    if (!CreateConnectedIpcChannel(io_task_runner_, this, client.Receive(),
+    HANDLE temp_handle;
+    if (!CreateConnectedIpcChannel(io_task_runner_, this, &temp_handle,
                                    &server)) {
       ReportFatalError();
       return;
     }
+    ScopedHandle client;
+    client.Set(temp_handle);
 
     // Convert the handle value into a decimal integer. Handle values are 32bit
     // even on 64bit platforms.
     std::string pipe_handle = base::StringPrintf(
         "%d", reinterpret_cast<ULONG_PTR>(client.Get()));
 
     // Pass the IPC channel via the command line.
     CommandLine command_line(target_command_->argv());
     command_line.AppendSwitchASCII(kDaemonPipeSwitchName, pipe_handle);
 
@@ skipping 98 matching lines @@
     base::win::ScopedHandle worker_process) {
   DCHECK(CalledOnValidThread());
   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;
-  ScopedHandle limited_handle;
+  HANDLE temp_handle;
   if (!DuplicateHandle(GetCurrentProcess(),
                        worker_process_,
                        GetCurrentProcess(),
-                       limited_handle.Receive(),
+                       &temp_handle,
                        desired_access,
                        FALSE,
                        0)) {
     LOG_GETLASTERROR(ERROR) << "Failed to duplicate a handle";
     ReportFatalError();
     return;
   }
+  ScopedHandle limited_handle;
+  limited_handle.Set(temp_handle);
 
   event_handler_->OnProcessLaunched(limited_handle.Pass());
 }
 
 } // namespace remoting