Remove implicit HANDLE conversions from cloud_print.

cloud_print/service/win/service_controller.cc

 // Copyright 2013 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 "cloud_print/service/win/service_controller.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <atlctl.h>
 
@@ skipping 53 matching lines @@
 HRESULT OpenService(const base::string16& name, DWORD access,
                     ServiceHandle* service) {
   if (!service)
     return E_POINTER;
 
   ServiceHandle scm;
   HRESULT hr = OpenServiceManager(&scm);
   if (FAILED(hr))
     return hr;
 
-  service->Set(::OpenService(scm, name.c_str(), access));
+  service->Set(::OpenService(scm.Get(), name.c_str(), access));
 
   if (!service->IsValid())
     return cloud_print::GetLastHResult();
 
   return S_OK;
 }
 
 }  // namespace
 
 ServiceController::ServiceController()
     : name_(cloud_print::LoadLocalString(IDS_SERVICE_NAME)),
       command_line_(CommandLine::NO_PROGRAM) {
 }
 
 ServiceController::~ServiceController() {
 }
 
 HRESULT ServiceController::StartService() {
   ServiceHandle service;
   HRESULT hr = OpenService(name_, SERVICE_START| SERVICE_QUERY_STATUS,
                            &service);
   if (FAILED(hr))
     return hr;
-  if (!::StartService(service, 0, NULL))
+  if (!::StartService(service.Get(), 0, NULL))
     return cloud_print::GetLastHResult();
   SERVICE_STATUS status = {0};
-  while (::QueryServiceStatus(service, &status) &&
+  while (::QueryServiceStatus(service.Get(), &status) &&
           status.dwCurrentState == SERVICE_START_PENDING) {
     Sleep(100);
   }
   return S_OK;
 }
 
 HRESULT ServiceController::StopService() {
   ServiceHandle service;
   HRESULT hr = OpenService(name_, SERVICE_STOP | SERVICE_QUERY_STATUS,
                            &service);
   if (FAILED(hr))
     return hr;
   SERVICE_STATUS status = {0};
-  if (!::ControlService(service, SERVICE_CONTROL_STOP, &status))
+  if (!::ControlService(service.Get(), SERVICE_CONTROL_STOP, &status))
     return cloud_print::GetLastHResult();
-  while (::QueryServiceStatus(service, &status) &&
+  while (::QueryServiceStatus(service.Get(), &status) &&
           status.dwCurrentState > SERVICE_STOPPED) {
     Sleep(500);
-    ::ControlService(service, SERVICE_CONTROL_STOP, &status);
+    ::ControlService(service.Get(), SERVICE_CONTROL_STOP, &status);
   }
   return S_OK;
 }
 
 base::FilePath ServiceController::GetBinary() const {
   base::FilePath service_path;
   CHECK(PathService::Get(base::FILE_EXE, &service_path));
   return service_path.DirName().Append(base::FilePath(kServiceExeName));
 }
 
@@ skipping 59 matching lines @@
 
   ServiceHandle scm;
   hr = OpenServiceManager(&scm);
   if (FAILED(hr))
     return hr;
 
   base::string16 display_name =
       cloud_print::LoadLocalString(IDS_SERVICE_DISPLAY_NAME);
   ServiceHandle service(
       ::CreateService(
-          scm, name_.c_str(), display_name.c_str(), SERVICE_ALL_ACCESS,
+          scm.Get(), name_.c_str(), display_name.c_str(), SERVICE_ALL_ACCESS,
           SERVICE_WIN32_OWN_PROCESS,
           auto_start ? SERVICE_AUTO_START : SERVICE_DEMAND_START,
           SERVICE_ERROR_NORMAL, command_line.GetCommandLineString().c_str(),
           NULL, NULL, NULL, user.empty() ? NULL : user.c_str(),
           password.empty() ? NULL : password.c_str()));
 
   if (!service.IsValid()) {
     LOG(ERROR) << "Failed to install service as " << user << ".";
     return cloud_print::GetLastHResult();
   }
 
   base::string16 description_string =
       cloud_print::LoadLocalString(IDS_SERVICE_DESCRIPTION);
   SERVICE_DESCRIPTION description = {0};
   description.lpDescription = const_cast<wchar_t*>(description_string.c_str());
-  ::ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &description);
+  ::ChangeServiceConfig2(service.Get(), SERVICE_CONFIG_DESCRIPTION,
+                         &description);
 
   return S_OK;
 }
 
 HRESULT ServiceController::UninstallService() {
   StopService();
 
   ServiceHandle service;
   OpenService(name_, SERVICE_STOP | DELETE, &service);
   HRESULT hr = S_FALSE;
-  if (service) {
-    if (!::DeleteService(service)) {
+  if (service.IsValid()) {
+    if (!::DeleteService(service.Get())) {
       LOG(ERROR) << "Failed to uninstall service";
       hr = cloud_print::GetLastHResult();
     }
   }
   UpdateRegistryAppId(false);
   return hr;
 }
 
 HRESULT ServiceController::UpdateBinaryPath() {
   UpdateState();
   ServiceController::State origina_state = state();
   if (origina_state < ServiceController::STATE_STOPPED)
     return S_FALSE;
 
   ServiceHandle service;
   HRESULT hr = OpenService(name_, SERVICE_CHANGE_CONFIG, &service);
   if (FAILED(hr))
     return hr;
 
   base::FilePath service_path = GetBinary();
   if (!base::PathExists(service_path))
     return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
   command_line_.SetProgram(service_path);
-  if (!::ChangeServiceConfig(service, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,
-                             SERVICE_NO_CHANGE,
+  if (!::ChangeServiceConfig(service.Get(), SERVICE_NO_CHANGE,
+                             SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,
                              command_line_.GetCommandLineString().c_str(), NULL,
                              NULL, NULL, NULL, NULL, NULL)) {
     return cloud_print::GetLastHResult();
   }
 
   if (origina_state != ServiceController::STATE_RUNNING)
     return S_OK;
 
   hr = StopService();
   if (FAILED(hr))
@@ skipping 12 matching lines @@
   is_logging_enabled_ = false;
 
   ServiceHandle service;
   HRESULT hr = OpenService(name_, SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG,
                            &service);
   if (FAILED(hr))
     return;
 
   state_ = STATE_STOPPED;
   SERVICE_STATUS status = {0};
-  if (::QueryServiceStatus(service, &status) &&
+  if (::QueryServiceStatus(service.Get(), &status) &&
       status.dwCurrentState == SERVICE_RUNNING) {
     state_ = STATE_RUNNING;
   }
 
   DWORD config_size = 0;
-  ::QueryServiceConfig(service, NULL, 0, &config_size);
+  ::QueryServiceConfig(service.Get(), NULL, 0, &config_size);
   if (!config_size)
     return;
 
   std::vector<uint8> buffer(config_size, 0);
   QUERY_SERVICE_CONFIG* config =
       reinterpret_cast<QUERY_SERVICE_CONFIG*>(&buffer[0]);
-  if (!::QueryServiceConfig(service, config, buffer.size(), &config_size) ||
+  if (!::QueryServiceConfig(service.Get(), config, buffer.size(),
+                            &config_size) ||
       config_size != buffer.size()) {
     return;
   }
 
   command_line_ = CommandLine::FromString(config->lpBinaryPathName);
   if (!command_line_.HasSwitch(kServiceSwitch)) {
     state_ = STATE_NOT_FOUND;
     return;
   }
   is_logging_enabled_ = command_line_.HasSwitch(switches::kEnableLogging);
   user_ = config->lpServiceStartName;
 }
 
 bool ServiceController::is_logging_enabled() const {
   return command_line_.HasSwitch(switches::kEnableLogging);
 }