Moved chrome detection to service process.

cloud_print/service/win/cloud_print_service.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 "cloud_print/service/win/cloud_print_service.h"
 
 #define SECURITY_WIN32
 #include <security.h>
 
 #include <iomanip>
@@ skipping 11 matching lines @@
 #include "chrome/installer/launcher_support/chrome_launcher_support.h"
 #include "cloud_print/service/service_state.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"
 #include "cloud_print/service/win/resource.h"
 #include "printing/backend/print_backend.h"
 
 namespace {
 
-const wchar_t kPrintersFileName[] = L"printers.txt";
+const char kChromeIsNotAvalible[] = "\nChrome is not available\n";
+const char kChromeIsAvalible[] = "\nChrome is available\n";
+const wchar_t kRequirementsFileName[] = L"cloud_print_service_requirements.txt";
 const wchar_t kServiceStateFileName[] = L"Service State";
 
 // The traits class for Windows Service.
 class ServiceHandleTraits {
  public:
   typedef SC_HANDLE Handle;
 
   // Closes the handle.
   static bool CloseHandle(Handle handle) {
     return ::CloseServiceHandle(handle) != FALSE;
@@ skipping 119 matching lines @@
 
 class CloudPrintServiceModule
     : public ATL::CAtlServiceModuleT<CloudPrintServiceModule, IDS_SERVICENAME> {
  public:
   typedef ATL::CAtlServiceModuleT<CloudPrintServiceModule,
                                   IDS_SERVICENAME> Base;
 
   DECLARE_REGISTRY_APPID_RESOURCEID(IDR_CLOUDPRINTSERVICE,
                                     "{8013FB7C-2E3E-4992-B8BD-05C0C4AB0627}")
 
-  CloudPrintServiceModule() : detect_printers_(false) {
+  CloudPrintServiceModule() : check_requirements_(false) {
   }
 
   HRESULT InitializeSecurity() {
     // TODO(gene): Check if we need to call CoInitializeSecurity and provide
     // the appropriate security settings for service.
     return S_OK;
   }
 
   HRESULT InstallService(const string16& user,
                          const string16& password,
                          const char* run_switch) {
-    using namespace chrome_launcher_support;
-
     // TODO(vitalybuka): consider "lite" version if we don't want unregister
     // printers here.
     HRESULT hr = UninstallService();
     if (FAILED(hr))
       return hr;
 
-    if (GetChromePathForInstallationLevel(SYSTEM_LEVEL_INSTALLATION).empty()) {
-      LOG(WARNING) << "Found no Chrome installed for all users.";
-    }
-
     hr = UpdateRegistryAppId(true);
     if (FAILED(hr))
       return hr;
 
     FilePath service_path;
     CHECK(PathService::Get(base::FILE_EXE, &service_path));
     CommandLine command_line(service_path);
     command_line.AppendSwitch(run_switch);
     command_line.AppendSwitchPath(kUserDataDirSwitch, user_data_dir_);
 
@@ skipping 49 matching lines @@
           std::setbase(16) << *pnRetCode;
     }
     return is_service;
   }
 
   HRESULT PreMessageLoop(int nShowCmd) {
     HRESULT hr = Base::PreMessageLoop(nShowCmd);
     if (FAILED(hr))
       return hr;
 
-    if (detect_printers_) {
-      hr = DetectPrinters();
+    if (check_requirements_) {
+      hr = CheckRequirements();
       if (FAILED(hr))
         return hr;
       // Don't run message loop and stop service.
       return S_FALSE;
     } else {
       hr = StartConnector();
       if (FAILED(hr))
         return hr;
     }
 
@@ skipping 40 matching lines @@
       if (SUCCEEDED(hr) && command_line.HasSwitch(kStartSwitch))
         return StartService();
 
       return hr;
     }
 
     if (command_line.HasSwitch(kStartSwitch))
       return StartService();
 
     if (command_line.HasSwitch(kServiceSwitch) ||
-        command_line.HasSwitch(kPrintersSwitch)) {
+        command_line.HasSwitch(kRequirementsSwitch)) {
       *is_service = true;
-      detect_printers_ = command_line.HasSwitch(kPrintersSwitch);
+      check_requirements_ = command_line.HasSwitch(kRequirementsSwitch);
       return S_OK;
     }
 
     if (command_line.HasSwitch(kConsoleSwitch)) {
       ::SetConsoleCtrlHandler(&ConsoleCtrlHandler, TRUE);
       HRESULT hr = Run();
       ::SetConsoleCtrlHandler(NULL, FALSE);
       return hr;
     }
 
     InvalidUsage();
     return S_FALSE;
   }
 
   void SelectWindowsAccount(string16* run_as_user,
                             string16* run_as_password) {
     *run_as_user = GetCurrentUserName();
     for (;;) {
       std::cout << "\nPlease provide Windows account to run service.\n";
       *run_as_user = ASCIIToWide(GetOption("Account as DOMAIN\\USERNAME",
                                            WideToASCII(*run_as_user), false));
       *run_as_password = ASCIIToWide(GetOption("Password", "", true));
 
-      FilePath printers_filename(user_data_dir_);
-      printers_filename = printers_filename.Append(kPrintersFileName);
+      FilePath requirements_filename(user_data_dir_);
+      requirements_filename =
+          requirements_filename.Append(kRequirementsFileName);
 
-      file_util::Delete(printers_filename, false);
+      file_util::Delete(requirements_filename, false);
+      if (file_util::PathExists(requirements_filename)) {
+        LOG(ERROR) << "Unable to delete " <<
+            requirements_filename.value() << ".";
+        continue;
+      }
       if (FAILED(InstallService(run_as_user->c_str(),
                                 run_as_password->c_str(),
-                                kPrintersSwitch))) {
+                                kRequirementsSwitch))) {
         continue;
       }
-      if (FAILED(StartService())) {
+      bool service_started = SUCCEEDED(StartService());
+      UninstallService();
+      if (!service_started) {
         LOG(ERROR) << "Failed to start service as " << *run_as_user << ".";
         continue;
       }
-      UninstallService();
-      if (!file_util::PathExists(printers_filename)) {
-        LOG(ERROR) << "Service can't create " << printers_filename.value();
+      std::string printers;
+      if (!file_util::PathExists(requirements_filename) ||
+          !file_util::ReadFileToString(requirements_filename, &printers)) {
+        LOG(ERROR) << "Service can't create " << requirements_filename.value();
         continue;
       }
 
-      std::string printers;
-      file_util::ReadFileToString(printers_filename, &printers);
-      std::cout << "\nPrinters available for " << run_as_user << ":\n";
+      if (EndsWith(printers, kChromeIsNotAvalible, true)) {
+        LOG(ERROR) << kChromeIsNotAvalible << " for " << *run_as_user << ".";
+        continue;
+      }
+
+      std::cout << "\nService requirements check result: \n";
       std::cout << printers << "\n";
-      file_util::Delete(printers_filename, false);
+      file_util::Delete(requirements_filename, false);
 
       if (AskUser("Do you want to use " + WideToASCII(*run_as_user) + "?"))
         return;
     }
   }
 
   HRESULT SetupServiceState() {
     FilePath file = user_data_dir_.Append(kServiceStateFileName);
 
     for (;;) {
@@ skipping 89 matching lines @@
     SERVICE_STATUS status = {0};
     if (!::ControlService(service, SERVICE_CONTROL_STOP, &status))
       return HResultFromLastError();
     while (::QueryServiceStatus(service, &status) &&
            status.dwCurrentState > SERVICE_STOPPED) {
       Sleep(500);
     }
     return S_OK;
   }
 
-  HRESULT DetectPrinters() {
-    FilePath printers_filename(user_data_dir_);
-    printers_filename = printers_filename.Append(kPrintersFileName);
-    std::string printers;
+  HRESULT CheckRequirements() {
+    FilePath requirements_filename(user_data_dir_);
+    requirements_filename = requirements_filename.Append(kRequirementsFileName);
+    std::string output;
+    output.append("Printers available for " +
+                  WideToASCII(GetCurrentUserName()) + ":\n");
     scoped_refptr<printing::PrintBackend> backend(
         printing::PrintBackend::CreateInstance(NULL));
     printing::PrinterList printer_list;
     backend->EnumeratePrinters(&printer_list);
     for (size_t i = 0; i < printer_list.size(); ++i) {
-      printers += printer_list[i].printer_name;
-      printers += "\n";
+      output += " ";
+      output += printer_list[i].printer_name;
+      output += "\n";
     }
-    file_util::WriteFile(printers_filename, printers.c_str(), printers.size());
+    FilePath chrome = chrome_launcher_support::GetAnyChromePath();
+    output.append(chrome.empty() ? kChromeIsNotAvalible : kChromeIsAvalible);
+    file_util::WriteFile(requirements_filename, output.c_str(), output.size());
     return S_OK;
   }
 
   HRESULT StartConnector() {
     chrome_.reset(new ChromeLauncher(user_data_dir_));
     return chrome_->Start() ? S_OK : E_FAIL;
   }
 
   void StopConnector() {
     if (chrome_.get()) {
       chrome_->Stop();
       chrome_.reset();
     }
   }
 
   static BOOL WINAPI ConsoleCtrlHandler(DWORD type);
 
-  bool detect_printers_;
+  bool check_requirements_;
   FilePath user_data_dir_;
   scoped_ptr<ChromeLauncher> chrome_;
 };
 
 CloudPrintServiceModule _AtlModule;
 
 BOOL CloudPrintServiceModule::ConsoleCtrlHandler(DWORD type) {
   PostThreadMessage(_AtlModule.m_dwThreadID, WM_QUIT, 0, 0);
   return TRUE;
 }
 
 int main() {
   base::AtExitManager at_exit;
   return _AtlModule.WinMain(0);
 }