Added Cloud Print Service installer/uninstaller.

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>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/common/chrome_switches.h"
 #include "cloud_print/common/win/cloud_print_utils.h"
+#include "cloud_print/service/service_constants.h"
 #include "cloud_print/service/service_switches.h"
 #include "cloud_print/service/win/chrome_launcher.h"
 #include "cloud_print/service/win/local_security_policy.h"
 
 namespace {
 
 const wchar_t kServiceExeName[] = L"cloud_print_service.exe";
 
 // The traits class for Windows Service.
 class ServiceHandleTraits {
@@ skipping 45 matching lines @@
 
   if (!service->IsValid())
     return cloud_print::GetLastHResult();
 
   return S_OK;
 }
 
 }  // namespace
 
 ServiceController::ServiceController(const string16& name)
-    : name_(name) {
+    : name_(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))
@@ skipping 18 matching lines @@
   if (!::ControlService(service, SERVICE_CONTROL_STOP, &status))
     return cloud_print::GetLastHResult();
   while (::QueryServiceStatus(service, &status) &&
           status.dwCurrentState > SERVICE_STOPPED) {
     Sleep(500);
     ::ControlService(service, 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));
+}
+
 HRESULT ServiceController::InstallConnectorService(
     const string16& user,
     const string16& password,
     const base::FilePath& user_data_dir,
     bool enable_logging) {
   return InstallService(user, password, true, kServiceSwitch, user_data_dir,
                         enable_logging);
 }
 
 HRESULT ServiceController::InstallCheckService(
@@ skipping 13 matching lines @@
   // TODO(vitalybuka): consider "lite" version if we don't want unregister
   // printers here.
   HRESULT hr = UninstallService();
   if (FAILED(hr))
     return hr;
 
   hr = UpdateRegistryAppId(true);
   if (FAILED(hr))
     return hr;
 
-  base::FilePath service_path;
-  CHECK(PathService::Get(base::FILE_EXE, &service_path));
-  service_path = service_path.DirName().Append(base::FilePath(kServiceExeName));
+  base::FilePath service_path = GetBinary();
   if (!file_util::PathExists(service_path))
     return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
   CommandLine command_line(service_path);
   command_line.AppendSwitch(run_switch);
   if (!user_data_dir.empty())
     command_line.AppendSwitchPath(switches::kUserDataDir, user_data_dir);
   if (enable_logging) {
     command_line.AppendSwitch(switches::kEnableLogging);
     command_line.AppendSwitchASCII(switches::kV, "1");
   }
@@ skipping 43 matching lines @@
   if (service) {
     if (!::DeleteService(service)) {
       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 (!file_util::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,
+                             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))
+    return hr;
+
+  hr = StartService();
+  if (FAILED(hr))
+    return hr;
+
+  return S_OK;
+}
+
 void ServiceController::UpdateState() {
-  ServiceHandle service;
   state_ = STATE_NOT_FOUND;
   user_.clear();
   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) &&
       status.dwCurrentState == SERVICE_RUNNING) {
     state_ = STATE_RUNNING;
   }
 
   DWORD config_size = 0;
   ::QueryServiceConfig(service, 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) ||
       config_size != buffer.size()) {
     return;
   }
 
-  CommandLine command_line(CommandLine::FromString(config->lpBinaryPathName));
-  if (!command_line.HasSwitch(kServiceSwitch)) {
+  command_line_ = CommandLine::FromString(config->lpBinaryPathName);
+  if (!command_line_.HasSwitch(kServiceSwitch)) {
     state_ = STATE_NOT_FOUND;
     return;
   }
-  is_logging_enabled_ = command_line.HasSwitch(switches::kEnableLogging);
+  is_logging_enabled_ = command_line_.HasSwitch(switches::kEnableLogging);
   user_ = config->lpServiceStartName;
 }
+
+bool ServiceController::is_logging_enabled() const {
+  return command_line_.HasSwitch(switches::kEnableLogging);
+}