Send data back from service using IPC, not file.

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 <atlbase.h>
 #include <security.h>
 
 #include <iomanip>
 #include <iostream>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/installer/launcher_support/chrome_launcher_support.h"
+#include "base/win/scoped_handle.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/service_controller.h"
+#include "cloud_print/service/win/service_listener.h"
 #include "cloud_print/service/win/service_utils.h"
-#include "printing/backend/print_backend.h"
+#include "cloud_print/service/win/setup_listener.h"
 
 namespace {
 
-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";
 
 void InvalidUsage() {
   base::FilePath service_path;
   CHECK(PathService::Get(base::FILE_EXE, &service_path));
 
   std::cout << "Usage: ";
   std::cout << service_path.BaseName().value();
   std::cout << " [";
     std::cout << "[";
@@ skipping 64 matching lines @@
     if (input.empty() || input == "y") {
       return true;
     } else if (input == "n") {
       return false;
     }
   }
 }
 
 }  // namespace
 
+
 class CloudPrintServiceModule
     : public ATL::CAtlServiceModuleT<CloudPrintServiceModule, IDS_SERVICENAME> {
  public:
   typedef ATL::CAtlServiceModuleT<CloudPrintServiceModule,
                                   IDS_SERVICENAME> Base;
 
   CloudPrintServiceModule()
       : check_requirements_(false),
         controller_(new ServiceController(m_szServiceName)) {
   }
@@ skipping 20 matching lines @@
     }
     return is_service;
   }
 
   HRESULT PreMessageLoop(int nShowCmd) {
     HRESULT hr = Base::PreMessageLoop(nShowCmd);
     if (FAILED(hr))
       return hr;
 
     if (check_requirements_) {
-      hr = CheckRequirements();
-      if (FAILED(hr))
-        return hr;
-      // Don't run message loop and stop service.
-      return S_FALSE;
+      CheckRequirements();
     } else {
-      hr = StartConnector();
+      HRESULT hr = StartConnector();
       if (FAILED(hr))
         return hr;
     }
 
     LogEvent(_T("Service started/resumed"));
     SetServiceStatus(SERVICE_RUNNING);
 
     return hr;
   }
 
   HRESULT PostMessageLoop() {
     StopConnector();
+    setup_listener_.reset();
     return Base::PostMessageLoop();
   }
 
  private:
   HRESULT ParseCommandLine(const CommandLine& command_line, bool* is_service) {
     if (!is_service)
       return E_INVALIDARG;
     *is_service = false;
 
     user_data_dir_ = command_line.GetSwitchValuePath(kUserDataDirSwitch);
@@ skipping 11 matching lines @@
 
       string16 run_as_user;
       string16 run_as_password;
       SelectWindowsAccount(&run_as_user, &run_as_password);
 
       HRESULT hr = SetupServiceState();
       if (FAILED(hr))
         return hr;
 
       hr = controller_->InstallService(run_as_user, run_as_password,
-                                       kServiceSwitch, user_data_dir_);
+                                       kServiceSwitch, user_data_dir_, true);
       if (SUCCEEDED(hr) && command_line.HasSwitch(kStartSwitch))
         return controller_->StartService();
 
       return hr;
     }
 
     if (command_line.HasSwitch(kStartSwitch))
       return controller_->StartService();
 
+    if (command_line.HasSwitch(kConsoleSwitch)) {
+      check_requirements_ = command_line.HasSwitch(kRequirementsSwitch);
+      ::SetConsoleCtrlHandler(&ConsoleCtrlHandler, TRUE);
+      HRESULT hr = Run();
+      ::SetConsoleCtrlHandler(NULL, FALSE);
+      return hr;
+    }
+
     if (command_line.HasSwitch(kServiceSwitch) ||
         command_line.HasSwitch(kRequirementsSwitch)) {
       *is_service = true;
       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));
 
-      base::FilePath requirements_filename(user_data_dir_);
-      requirements_filename =
-          requirements_filename.Append(kRequirementsFileName);
-
-      file_util::Delete(requirements_filename, false);
-      if (file_util::PathExists(requirements_filename)) {
-        LOG(ERROR) << "Unable to delete " <<
-            requirements_filename.value() << ".";
+      SetupListener setup(*run_as_user);
+      if (FAILED(controller_->InstallService(*run_as_user, *run_as_password,
+                                             kRequirementsSwitch,
+                                             user_data_dir_, false))) {
+        LOG(ERROR) << "Failed to install service as " << *run_as_user << ".";
         continue;
       }
-      if (FAILED(controller_->InstallService(*run_as_user, *run_as_password,
-                                             kRequirementsSwitch,
-                                             user_data_dir_))) {
-        continue;
+
+      bool service_started = SUCCEEDED(controller_->StartService());
+
+      if (service_started &&
+          !setup.WaitResponce(base::TimeDelta::FromSeconds(30))) {
+        LOG(ERROR) << "Failed to check environment for user " << *run_as_user
+                   << ".";
       }
-      bool service_started = SUCCEEDED(controller_->StartService());
+
       controller_->UninstallService();
       if (!service_started) {
         LOG(ERROR) << "Failed to start service as " << *run_as_user << ".";
         continue;
       }
-      std::string printers;
-      if (!file_util::PathExists(requirements_filename) ||
-          !file_util::ReadFileToString(requirements_filename, &printers)) {
-        LOG(ERROR) << "Service can't create " << requirements_filename.value();
+      if (setup.user_data_dir().empty()) {
+        LOG(ERROR) << "Service can't access " << user_data_dir_.value() << ".";
         continue;
       }
-
-      if (EndsWith(printers, kChromeIsNotAvalible, true)) {
-        LOG(ERROR) << kChromeIsNotAvalible << " for " << *run_as_user << ".";
+      if (setup.chrome_path().empty()) {
+        LOG(ERROR) << "Chrome is not available  for " << *run_as_user << ".";
+        continue;
+      }
+      if (!setup.is_xps_availible()) {
+        LOG(ERROR) << "XPS pack is not installed.";
         continue;
       }
 
       std::cout << "\nService requirements check result: \n";
-      std::cout << printers << "\n";
-      file_util::Delete(requirements_filename, false);
+      std::cout << "Username: " << setup.user_name()<< "\n";
+      std::cout << "Chrome: " << setup.chrome_path().value()<< "\n";
+      std::cout << "Printers:\n  ";
+      std::ostream_iterator<std::string> cout_it(std::cout, "\n  ");
+      std::copy(setup.printers().begin(), setup.printers().end(), cout_it);
+      std::cout << "\n";
 
       if (AskUser("Do you want to use " + WideToASCII(*run_as_user) + "?"))
         return;
     }
   }
 
   HRESULT SetupServiceState() {
     base::FilePath file = user_data_dir_.Append(kServiceStateFileName);
 
     for (;;) {
@@ skipping 37 matching lines @@
               return last_error ? HRESULT_FROM_WIN32(last_error) : E_FAIL;
             }
           }
         }
       }
     }
 
     return S_OK;
   }
 
-  HRESULT CheckRequirements() {
-    base::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) {
-      output += " ";
-      output += printer_list[i].printer_name;
-      output += "\n";
-    }
-    base::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;
+  void CheckRequirements() {
+    setup_listener_.reset(new ServiceListener(user_data_dir_));
   }
 
   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 check_requirements_;
   base::FilePath user_data_dir_;
   scoped_ptr<ChromeLauncher> chrome_;
   scoped_ptr<ServiceController> controller_;
+  scoped_ptr<ServiceListener> setup_listener_;
 };
 
 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);
 }