Remove implicit HANDLE conversions from remoting.

remoting/host/daemon_process_win.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/daemon_process.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
@@ skipping 146 matching lines @@
 }
 
 bool DaemonProcessWin::OnDesktopSessionAgentAttached(
     int terminal_id,
     base::ProcessHandle desktop_process,
     IPC::PlatformFileForTransit desktop_pipe) {
   // Prepare |desktop_process| handle for sending over to the network process.
   base::ProcessHandle desktop_process_for_transit;
   if (!DuplicateHandle(GetCurrentProcess(),
                        desktop_process,
-                       network_process_,
+                       network_process_.Get(),
                        &desktop_process_for_transit,
                        0,
                        FALSE,
                        DUPLICATE_SAME_ACCESS)) {
     PLOG(ERROR) << "Failed to duplicate the desktop process handle";
     return false;
   }
 
   // |desktop_pipe| is a handle in the desktop process. It will be duplicated
   // by the network process directly from the desktop process.
@@ skipping 62 matching lines @@
   ScopedScHandle scmanager(
       OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE,
                     SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
   if (!scmanager.IsValid()) {
     PLOG(INFO) << "Failed to connect to the service control manager";
     return;
   }
 
   DWORD desired_access = SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS;
   ScopedScHandle service(
-      OpenService(scmanager, kWindowsServiceName, desired_access));
+      OpenService(scmanager.Get(), kWindowsServiceName, desired_access));
   if (!service.IsValid()) {
     PLOG(INFO) << "Failed to open to the '" << kWindowsServiceName
                << "' service";
     return;
   }
 
   // Change the service start type to 'manual'. All |NULL| parameters below mean
   // that there is no change to the corresponding service parameter.
-  if (!ChangeServiceConfig(service,
+  if (!ChangeServiceConfig(service.Get(),
                            SERVICE_NO_CHANGE,
                            SERVICE_DEMAND_START,
                            SERVICE_NO_CHANGE,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL,
                            NULL)) {
     PLOG(INFO) << "Failed to change the '" << kWindowsServiceName
                << "'service start type to 'manual'";
   }
 }
 
 bool DaemonProcessWin::InitializePairingRegistry() {
   if (!pairing_registry_privileged_key_.Valid()) {
     if (!OpenPairingRegistry())
       return false;
   }
 
   // Duplicate handles to the network process.
   IPC::PlatformFileForTransit privileged_key = GetRegistryKeyForTransit(
-      network_process_, pairing_registry_privileged_key_);
+      network_process_.Get(), pairing_registry_privileged_key_);
   IPC::PlatformFileForTransit unprivileged_key = GetRegistryKeyForTransit(
-      network_process_, pairing_registry_unprivileged_key_);
+      network_process_.Get(), pairing_registry_unprivileged_key_);
   if (!(privileged_key && unprivileged_key))
     return false;
 
   // Initialize the pairing registry in the network process. This has to be done
   // before the host configuration is sent, otherwise the host will not use
   // the passed handles.
   SendToNetwork(new ChromotingDaemonNetworkMsg_InitializePairingRegistry(
       privileged_key, unprivileged_key));
   return true;
 }
@@ skipping 31 matching lines @@
                 << "\\" << kPairingRegistrySecretsKeyName;
     return false;
   }
 
   pairing_registry_privileged_key_.Set(privileged.Take());
   pairing_registry_unprivileged_key_.Set(unprivileged.Take());
   return true;
 }
 
 }  // namespace remoting