Added ConnectorSettings class.

chrome/service/cloud_print/cloud_print_proxy_backend.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_backend.h"
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/rand_util.h"
 #include "base/values.h"
 #include "chrome/service/cloud_print/cloud_print_auth.h"
 #include "chrome/service/cloud_print/cloud_print_connector.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/cloud_print_token_store.h"
+#include "chrome/service/cloud_print/connector_settings.h"
 #include "chrome/service/gaia/service_gaia_authenticator.h"
 #include "chrome/service/net/service_url_request_context.h"
 #include "chrome/service/service_process.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "jingle/notifier/listener/push_client.h"
 #include "jingle/notifier/listener/push_client_observer.h"
 #include "ui/base/l10n/l10n_util.h"
 
 // The real guts of CloudPrintProxyBackend, to keep the public client API clean.
 class CloudPrintProxyBackend::Core
     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
       public CloudPrintAuth::Client,
       public CloudPrintConnector::Client,
       public notifier::PushClientObserver {
  public:
   // It is OK for print_server_url to be empty. In this case system should
   // use system default (local) print server.
   Core(CloudPrintProxyBackend* backend,
-       const std::string& proxy_id,
-       const GURL& cloud_print_server_url,
-       const DictionaryValue* print_system_settings,
+       const ConnectorSettings& settings,
        const gaia::OAuthClientInfo& oauth_client_info,
        bool enable_job_poll);
 
   // Note:
   //
   // The Do* methods are the various entry points from CloudPrintProxyBackend
   // It calls us on a dedicated thread to actually perform synchronous
   // (and potentially blocking) operations.
   //
   // Called on the CloudPrintProxyBackend core_thread_ to perform
   // initialization. When we are passed in an LSID we authenticate using that
   // and retrieve new auth tokens.
   void DoInitializeWithLsid(const std::string& lsid,
-                            const std::string& proxy_id,
                             const std::string& last_robot_refresh_token,
                             const std::string& last_robot_email,
                             const std::string& last_user_email);
 
-  void DoInitializeWithToken(const std::string& cloud_print_token,
-                             const std::string& proxy_id);
+  void DoInitializeWithToken(const std::string& cloud_print_token);
   void DoInitializeWithRobotToken(const std::string& robot_oauth_refresh_token,
-                                  const std::string& robot_email,
-                                  const std::string& proxy_id);
+                                  const std::string& robot_email);
   void DoInitializeWithRobotAuthCode(const std::string& robot_oauth_auth_code,
-                                     const std::string& robot_email,
-                                     const std::string& proxy_id);
+                                     const std::string& robot_email);
 
   // Called on the CloudPrintProxyBackend core_thread_ to perform
   // shutdown.
   void DoShutdown();
   void DoRegisterSelectedPrinters(
       const printing::PrinterList& printer_list);
   void DoUnregisterPrinters();
 
   // CloudPrintAuth::Client implementation.
   virtual void OnAuthenticationComplete(
@@ skipping 47 matching lines @@
 
   // Our parent CloudPrintProxyBackend
   CloudPrintProxyBackend* backend_;
 
   // Cloud Print authenticator.
   scoped_refptr<CloudPrintAuth> auth_;
 
   // Cloud Print connector.
   scoped_refptr<CloudPrintConnector> connector_;
 
-  // Server URL.
-  GURL cloud_print_server_url_;
-  // Proxy Id.
-  std::string proxy_id_;
-  // Print system settings.
-  scoped_ptr<DictionaryValue> print_system_settings_;
   // OAuth client info.
   gaia::OAuthClientInfo oauth_client_info_;
   // Notification (xmpp) handler.
   scoped_ptr<notifier::PushClient> push_client_;
   // Indicates whether XMPP notifications are currently enabled.
   bool notifications_enabled_;
   // The time when notifications were enabled. Valid only when
   // notifications_enabled_ is true.
   base::TimeTicks notifications_enabled_since_;
   // Indicates whether a task to poll for jobs has been scheduled.
   bool job_poll_scheduled_;
   // Indicates whether we should poll for jobs when we lose XMPP connection.
   bool enable_job_poll_;
+  // Connector settings.
+  ConnectorSettings settings_;
   scoped_ptr<CloudPrintTokenStore> token_store_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 CloudPrintProxyBackend::CloudPrintProxyBackend(
     CloudPrintProxyFrontend* frontend,
-    const std::string& proxy_id,
-    const GURL& cloud_print_server_url,
-    const DictionaryValue* print_system_settings,
+    const ConnectorSettings& settings,
     const gaia::OAuthClientInfo& oauth_client_info,
     bool enable_job_poll)
       : core_thread_("Chrome_CloudPrintProxyCoreThread"),
         frontend_loop_(MessageLoop::current()),
         frontend_(frontend) {
   DCHECK(frontend_);
-  core_ = new Core(this,
-                   proxy_id,
-                   cloud_print_server_url,
-                   print_system_settings,
-                   oauth_client_info,
-                   enable_job_poll);
+  core_ = new Core(this, settings, oauth_client_info, enable_job_poll);
 }
 
 CloudPrintProxyBackend::~CloudPrintProxyBackend() {
   DCHECK(!core_);
 }
 
 bool CloudPrintProxyBackend::InitializeWithLsid(
     const std::string& lsid,
-    const std::string& proxy_id,
     const std::string& last_robot_refresh_token,
     const std::string& last_robot_email,
     const std::string& last_user_email) {
   if (!core_thread_.Start())
     return false;
   core_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithLsid,
-                 core_.get(), lsid, proxy_id, last_robot_refresh_token,
-                 last_robot_email, last_user_email));
+                 core_.get(), lsid, last_robot_refresh_token, last_robot_email,
+                 last_user_email));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithToken(
-    const std::string& cloud_print_token,
-    const std::string& proxy_id) {
+    const std::string& cloud_print_token) {
   if (!core_thread_.Start())
     return false;
   core_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithToken,
-                 core_.get(), cloud_print_token, proxy_id));
+                 core_.get(), cloud_print_token));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithRobotToken(
     const std::string& robot_oauth_refresh_token,
-    const std::string& robot_email,
-    const std::string& proxy_id) {
+    const std::string& robot_email) {
   if (!core_thread_.Start())
     return false;
   core_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotToken,
-                 core_.get(), robot_oauth_refresh_token, robot_email,
-                 proxy_id));
+                 core_.get(), robot_oauth_refresh_token, robot_email));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithRobotAuthCode(
     const std::string& robot_oauth_auth_code,
-    const std::string& robot_email,
-    const std::string& proxy_id) {
+    const std::string& robot_email) {
   if (!core_thread_.Start())
     return false;
   core_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode,
-                 core_.get(), robot_oauth_auth_code, robot_email, proxy_id));
+                 core_.get(), robot_oauth_auth_code, robot_email));
   return true;
 }
 
 void CloudPrintProxyBackend::Shutdown() {
   core_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoShutdown, core_.get()));
   core_thread_.Stop();
   core_ = NULL;  // Releases reference to core_.
 }
 
 void CloudPrintProxyBackend::UnregisterPrinters() {
   core_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoUnregisterPrinters,
                  core_.get()));
 }
 
 CloudPrintProxyBackend::Core::Core(
     CloudPrintProxyBackend* backend,
-    const std::string& proxy_id,
-    const GURL& cloud_print_server_url,
-    const DictionaryValue* print_system_settings,
+    const ConnectorSettings& settings,
     const gaia::OAuthClientInfo& oauth_client_info,
     bool enable_job_poll)
       : backend_(backend),
-        cloud_print_server_url_(cloud_print_server_url),
-        proxy_id_(proxy_id),
         oauth_client_info_(oauth_client_info),
         notifications_enabled_(false),
         job_poll_scheduled_(false),
         enable_job_poll_(enable_job_poll) {
-  if (print_system_settings) {
-    // It is possible to have no print settings specified.
-    print_system_settings_.reset(print_system_settings->DeepCopy());
-  }
+  settings_.CopyFrom(settings);
 }
 
 void CloudPrintProxyBackend::Core::CreateAuthAndConnector() {
   if (!auth_.get()) {
-    auth_ = new CloudPrintAuth(this,
-                               cloud_print_server_url_,
-                               oauth_client_info_,
-                               proxy_id_);
+    auth_ = new CloudPrintAuth(this, settings_.server_url(), oauth_client_info_,
+                               settings_.proxy_id());
   }
 
   if (!connector_.get()) {
-    connector_ = new CloudPrintConnector(this,
-                                         proxy_id_,
-                                         cloud_print_server_url_,
-                                         print_system_settings_.get());
+    connector_ = new CloudPrintConnector(this, settings_);
   }
 }
 
 void CloudPrintProxyBackend::Core::DestroyAuthAndConnector() {
   auth_ = NULL;
   connector_ = NULL;
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithLsid(
     const std::string& lsid,
-    const std::string& proxy_id,
     const std::string& last_robot_refresh_token,
     const std::string& last_robot_email,
     const std::string& last_user_email) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   CreateAuthAndConnector();
   // Note: The GAIA login is synchronous but that should be OK because we are in
   // the CloudPrintProxyCoreThread and we cannot really do anything else until
   // the GAIA signin is successful.
   auth_->AuthenticateWithLsid(lsid, last_robot_refresh_token,
                               last_robot_email, last_user_email);
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithToken(
-    const std::string& cloud_print_token,
-    const std::string& proxy_id) {
+    const std::string& cloud_print_token) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   CreateAuthAndConnector();
   auth_->AuthenticateWithToken(cloud_print_token);
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithRobotToken(
     const std::string& robot_oauth_refresh_token,
-    const std::string& robot_email,
-    const std::string& proxy_id) {
+    const std::string& robot_email) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   CreateAuthAndConnector();
   auth_->AuthenticateWithRobotToken(robot_oauth_refresh_token, robot_email);
 }
 
 void CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode(
     const std::string& robot_oauth_auth_code,
-    const std::string& robot_email,
-    const std::string& proxy_id) {
+    const std::string& robot_email) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   CreateAuthAndConnector();
   auth_->AuthenticateWithRobotAuthCode(robot_oauth_auth_code, robot_email);
 }
 
 void CloudPrintProxyBackend::Core::OnAuthenticationComplete(
     const std::string& access_token,
     const std::string& robot_oauth_refresh_token,
     const std::string& robot_email,
     const std::string& user_email) {
-  CloudPrintTokenStore* token_store = GetTokenStore();
+  CloudPrintTokenStore* token_store  = GetTokenStore();
   bool first_time = token_store->token().empty();
   token_store->SetToken(access_token);
   // Let the frontend know that we have authenticated.
   backend_->frontend_loop_->PostTask(
       FROM_HERE,
       base::Bind(&Core::NotifyAuthenticated, this, robot_oauth_refresh_token,
                  robot_email, user_email));
   if (first_time) {
     InitNotifications(robot_email, access_token);
   } else {
@@ skipping 44 matching lines @@
   notifier::Subscription subscription;
   subscription.channel = kCloudPrintPushNotificationsSource;
   subscription.from = kCloudPrintPushNotificationsSource;
   push_client_->UpdateSubscriptions(
       notifier::SubscriptionList(1, subscription));
   push_client_->UpdateCredentials(robot_email, access_token);
 }
 
 void CloudPrintProxyBackend::Core::DoShutdown() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
-  VLOG(1) << "CP_CONNECTOR: Shutdown connector, id: " << proxy_id_;
+  VLOG(1) << "CP_CONNECTOR: Shutdown connector, id: " << settings_.proxy_id();
 
   if (connector_->IsRunning())
     connector_->Stop();
 
   // Important to delete the PushClient on this thread.
   if (push_client_.get()) {
     push_client_->RemoveObserver(this);
   }
   push_client_.reset();
   notifications_enabled_ = false;
@@ skipping 80 matching lines @@
     const std::string& auth_token,
     const std::list<std::string>& printer_ids) {
   DCHECK(MessageLoop::current() == backend_->frontend_loop_);
   backend_->frontend_->OnUnregisterPrinters(auth_token, printer_ids);
 }
 
 void CloudPrintProxyBackend::Core::OnNotificationsEnabled() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   notifications_enabled_ = true;
   notifications_enabled_since_ = base::TimeTicks::Now();
-  VLOG(1) << "Notifications for connector " << proxy_id_
+  VLOG(1) << "Notifications for connector " << settings_.proxy_id()
           << " were enabled at "
           << notifications_enabled_since_.ToInternalValue();
   // Notifications just got re-enabled. In this case we want to schedule
   // a poll once for jobs we might have missed when we were dark.
   // Note that ScheduleJobPoll will not schedule again if a job poll task is
   // already scheduled.
   ScheduleJobPoll();
 }
 
 void CloudPrintProxyBackend::Core::OnNotificationsDisabled(
     notifier::NotificationsDisabledReason reason) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   notifications_enabled_ = false;
-  LOG(ERROR) << "Notifications for connector " << proxy_id_ << " disabled.";
+  LOG(ERROR) << "Notifications for connector " << settings_.proxy_id()
+             << " disabled.";
   notifications_enabled_since_ = base::TimeTicks();
   // We just lost notifications. This this case we want to schedule a
   // job poll if enable_job_poll_ is true.
   if (enable_job_poll_)
     ScheduleJobPoll();
 }
 
 
 void CloudPrintProxyBackend::Core::OnIncomingNotification(
     const notifier::Notification& notification) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_CONNECTOR: Incoming notification.";
   if (0 == base::strcasecmp(kCloudPrintPushNotificationsSource,
                             notification.channel.c_str()))
     HandlePrinterNotification(notification.data);
 }
+