Use service process to collect printers.

chrome/service/cloud_print/cloud_print_proxy.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/service/cloud_print/cloud_print_proxy.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
@@ skipping 125 matching lines @@
   if (client_) {
     client_->OnCloudPrintProxyEnabled(true);
   }
 }
 
 bool CloudPrintProxy::CreateBackend() {
   DCHECK(CalledOnValidThread());
   if (backend_.get())
     return false;
 
-  settings_.InitFrom(service_prefs_);
+  ConnectorSettings settings;
+  settings.InitFrom(service_prefs_);
 
   // By default we don't poll for jobs when we lose XMPP connection. But this
   // behavior can be overridden by a preference.
   bool enable_job_poll =
     service_prefs_->GetBoolean(prefs::kCloudPrintEnableJobPoll, false);
 
   gaia::OAuthClientInfo oauth_client_info;
   oauth_client_info.client_id =
     google_apis::GetOAuth2ClientID(google_apis::CLIENT_CLOUD_PRINT);
   oauth_client_info.client_secret =
     google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_CLOUD_PRINT);
   oauth_client_info.redirect_uri = "oob";
-  backend_.reset(new CloudPrintProxyBackend(this, settings_, oauth_client_info,
-                                            enable_job_poll));
+  backend_.reset(new CloudPrintProxyBackend(
+      this, settings, oauth_client_info, enable_job_poll));
   return true;
 }
 
 void CloudPrintProxy::UnregisterPrintersAndDisableForUser() {
   DCHECK(CalledOnValidThread());
   if (backend_.get()) {
     // Try getting auth and printers info from the backend.
     // We'll get notified in this case.
     backend_->UnregisterPrinters();
   } else {
@@ skipping 10 matching lines @@
     client_->OnCloudPrintProxyDisabled(true);
   }
   ShutdownBackend();
 }
 
 void CloudPrintProxy::GetProxyInfo(CloudPrintProxyInfo* info) {
   info->enabled = enabled_;
   info->email.clear();
   if (enabled_)
     info->email = user_email();
-  info->proxy_id = settings_.proxy_id();
-  // If the Cloud Print service is not enabled, we may need to read the old
-  // value of proxy_id from prefs.
-  if (info->proxy_id.empty())
-    info->proxy_id =
-        service_prefs_->GetString(prefs::kCloudPrintProxyId, std::string());
+  ConnectorSettings settings;
+  settings.InitFrom(service_prefs_);
+  info->proxy_id = settings.proxy_id();
+}
+
+void CloudPrintProxy::GetPrinters(std::vector<std::string>* printers) {
+  ConnectorSettings settings;
+  settings.InitFrom(service_prefs_);
+  scoped_refptr<PrintSystem> print_system =
+      PrintSystem::CreateInstance(settings.print_system_settings());
+  if (!print_system)
+    return;
+  PrintSystem::PrintSystemResult result = print_system->Init();
+  if (!result.succeeded())
+    return;
+  printing::PrinterList printer_list;
+  print_system->EnumeratePrinters(&printer_list);
+  for (size_t i = 0; i < printer_list.size(); ++i)
+    printers->push_back(printer_list[i].printer_name);
 }
 
 void CloudPrintProxy::CheckCloudPrintProxyPolicy() {
   g_service_process->io_thread()->message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(&CheckCloudPrintProxyPolicyInBrowser));
 }
 
 void CloudPrintProxy::OnAuthenticated(
     const std::string& robot_oauth_refresh_token,
     const std::string& robot_email,
@@ skipping 39 matching lines @@
     client_->OnCloudPrintProxyDisabled(false);
   }
 }
 
 void CloudPrintProxy::OnUnregisterPrinters(
     const std::string& auth_token,
     const std::list<std::string>& printer_ids) {
   UMA_HISTOGRAM_COUNTS_10000("CloudPrint.UnregisterPrinters",
                              printer_ids.size());
   ShutdownBackend();
-  wipeout_.reset(new CloudPrintWipeout(this, settings_.server_url()));
+  ConnectorSettings settings;
+  settings.InitFrom(service_prefs_);
+  wipeout_.reset(new CloudPrintWipeout(this, settings.server_url()));
   wipeout_->UnregisterPrinters(auth_token, printer_ids);
 }
 
 void CloudPrintProxy::OnXmppPingUpdated(int ping_timeout) {
   DCHECK(CalledOnValidThread());
   service_prefs_->SetInt(prefs::kCloudPrintXmppPingTimeout, ping_timeout);
   service_prefs_->WritePrefs();
 }
 
 void CloudPrintProxy::OnUnregisterPrintersComplete() {
   wipeout_.reset();
   // Finish disabling cloud print for this user.
   DisableForUser();
 }
 
 void CloudPrintProxy::ShutdownBackend() {
   DCHECK(CalledOnValidThread());
   if (backend_.get())
     backend_->Shutdown();
   backend_.reset();
 }
 
 }  // namespace cloud_print