Use service process to collect printers.

chrome/browser/printing/cloud_print/cloud_print_proxy_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 "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 
 #include <stack>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 CloudPrintProxyService::CloudPrintProxyService(Profile* profile)
     : profile_(profile),
       weak_factory_(this),
       enforcing_connector_policy_(false) {
 }
 
 CloudPrintProxyService::~CloudPrintProxyService() {
 }
 
 void CloudPrintProxyService::Initialize() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
                             ServiceProcessControl::SERVICE_EVENT_INITIALIZE,
                             ServiceProcessControl::SERVICE_EVENT_MAX);
   if (profile_->GetPrefs()->HasPrefPath(prefs::kCloudPrintEmail) &&
       (!profile_->GetPrefs()->GetString(prefs::kCloudPrintEmail).empty() ||
        !profile_->GetPrefs()->GetBoolean(prefs::kCloudPrintProxyEnabled))) {
     // If the cloud print proxy is enabled, or the policy preventing it from
     // being enabled is set, establish a channel with the service process and
     // update the status. This will check the policy when the status is sent
     // back.
     UMA_HISTOGRAM_ENUMERATION(
         "CloudPrint.ServiceEvents",
         ServiceProcessControl::SERVICE_EVENT_ENABLED_ON_LAUNCH,
         ServiceProcessControl::SERVICE_EVENT_MAX);
     RefreshStatusFromService();
   }
 
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kCloudPrintProxyEnabled,
       base::Bind(
           base::IgnoreResult(
               &CloudPrintProxyService::ApplyCloudPrintConnectorPolicy),
           base::Unretained(this)));
 }
 
 void CloudPrintProxyService::RefreshStatusFromService() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   InvokeServiceTask(
       base::Bind(&CloudPrintProxyService::RefreshCloudPrintProxyStatus,
                  weak_factory_.GetWeakPtr()));
 }
 
 bool CloudPrintProxyService::EnforceCloudPrintConnectorPolicyAndQuit() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   enforcing_connector_policy_ = true;
   if (ApplyCloudPrintConnectorPolicy())
     return true;
   return false;
 }
 
 void CloudPrintProxyService::EnableForUserWithRobot(
     const std::string& robot_auth_code,
     const std::string& robot_email,
     const std::string& user_email,
     const base::DictionaryValue& user_preferences) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
                             ServiceProcessControl::SERVICE_EVENT_ENABLE,
                             ServiceProcessControl::SERVICE_EVENT_MAX);
   if (profile_->GetPrefs()->GetBoolean(prefs::kCloudPrintProxyEnabled)) {
     InvokeServiceTask(
         base::Bind(&CloudPrintProxyService::EnableCloudPrintProxyWithRobot,
                    weak_factory_.GetWeakPtr(), robot_auth_code, robot_email,
                    user_email, base::Owned(user_preferences.DeepCopy())));
   }
 }
 
 void CloudPrintProxyService::DisableForUser() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
                             ServiceProcessControl::SERVICE_EVENT_DISABLE,
                             ServiceProcessControl::SERVICE_EVENT_MAX);
   InvokeServiceTask(
       base::Bind(&CloudPrintProxyService::DisableCloudPrintProxy,
                  weak_factory_.GetWeakPtr()));
 }
 
 bool CloudPrintProxyService::ApplyCloudPrintConnectorPolicy() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!profile_->GetPrefs()->GetBoolean(prefs::kCloudPrintProxyEnabled)) {
     std::string email =
         profile_->GetPrefs()->GetString(prefs::kCloudPrintEmail);
     if (!email.empty()) {
       UMA_HISTOGRAM_ENUMERATION(
           "CloudPrint.ServiceEvents",
           ServiceProcessControl::SERVICE_EVENT_DISABLE_BY_POLICY,
           ServiceProcessControl::SERVICE_EVENT_MAX);
       DisableForUser();
       profile_->GetPrefs()->SetString(prefs::kCloudPrintEmail, std::string());
       if (enforcing_connector_policy_) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&CloudPrintProxyService::RefreshCloudPrintProxyStatus,
                        weak_factory_.GetWeakPtr()));
       }
       return false;
     } else if (enforcing_connector_policy_) {
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
     }
   }
   return true;
 }
 
-void CloudPrintProxyService::GetPrintersAvalibleForRegistration(
-      std::vector<std::string>* printers) {
+void CloudPrintProxyService::GetPrinters(const PrintersCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!profile_->GetPrefs()->GetBoolean(prefs::kCloudPrintProxyEnabled))
+    return;
+
   base::FilePath list_path(
       CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kCloudPrintSetupProxy));
   if (!list_path.empty()) {
     std::string printers_json;
     base::ReadFileToString(list_path, &printers_json);
     scoped_ptr<base::Value> value(base::JSONReader::Read(printers_json));
     base::ListValue* list = NULL;
+    std::vector<std::string> printers;
     if (value && value->GetAsList(&list) && list) {
       for (size_t i = 0; i < list->GetSize(); ++i) {
         std::string printer;
         if (list->GetString(i, &printer))
-          printers->push_back(printer);
+          printers.push_back(printer);
       }
     }
     UMA_HISTOGRAM_COUNTS_10000("CloudPrint.AvailablePrintersList",
-                               printers->size());
+                               printers.size());
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(callback, printers));
   } else {
-    printing::PrinterList printer_list;
-    scoped_refptr<printing::PrintBackend> backend(
-        printing::PrintBackend::CreateInstance(NULL));
-    if (backend.get())
-      backend->EnumeratePrinters(&printer_list);
-    for (size_t i = 0; i < printer_list.size(); ++i)
-      printers->push_back(printer_list[i].printer_name);
-    UMA_HISTOGRAM_COUNTS_10000("CloudPrint.AvailablePrinters",
-                               printers->size());
+    InvokeServiceTask(
+        base::Bind(&CloudPrintProxyService::GetCloudPrintProxyPrinters,
+                   weak_factory_.GetWeakPtr(),
+                   callback));
   }
 }
 
+void CloudPrintProxyService::GetCloudPrintProxyPrinters(
+    const PrintersCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ServiceProcessControl* process_control = GetServiceProcessControl();
+  DCHECK(process_control->IsConnected());
+  process_control->GetPrinters(callback);
+}
+
 void CloudPrintProxyService::RefreshCloudPrintProxyStatus() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ServiceProcessControl* process_control = GetServiceProcessControl();
   DCHECK(process_control->IsConnected());
-  ServiceProcessControl::CloudPrintProxyInfoHandler callback =
-       base::Bind(&CloudPrintProxyService::ProxyInfoCallback,
-                  base::Unretained(this));
-  // GetCloudPrintProxyInfo takes ownership of callback.
+  ServiceProcessControl::CloudPrintProxyInfoCallback callback = base::Bind(
+      &CloudPrintProxyService::ProxyInfoCallback, base::Unretained(this));
   process_control->GetCloudPrintProxyInfo(callback);
 }
 
 void CloudPrintProxyService::EnableCloudPrintProxyWithRobot(
     const std::string& robot_auth_code,
     const std::string& robot_email,
     const std::string& user_email,
     const base::DictionaryValue* user_preferences) {
   ServiceProcessControl* process_control = GetServiceProcessControl();
   DCHECK(process_control->IsConnected());
@@ skipping 22 matching lines @@
 }
 
 bool CloudPrintProxyService::InvokeServiceTask(const base::Closure& task) {
   GetServiceProcessControl()->Launch(task, base::Closure());
   return true;
 }
 
 ServiceProcessControl* CloudPrintProxyService::GetServiceProcessControl() {
   return ServiceProcessControl::GetInstance();
 }