[Sync] Replace TalkMediator*/MediatorThread* with PushClient

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/common/net/gaia/gaia_oauth_client.h"
 #include "chrome/common/net/gaia/gaia_urls.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/gaia/service_gaia_authenticator.h"
 #include "chrome/service/net/service_url_request_context.h"
 #include "chrome/service/service_process.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "jingle/notifier/base/notifier_options.h"
-#include "jingle/notifier/listener/mediator_thread_impl.h"
-#include "jingle/notifier/listener/talk_mediator_impl.h"
+#include "jingle/notifier/listener/push_client.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::TalkMediator::Delegate {
+      public notifier::PushClient::Observer {
  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 gaia::OAuthClientInfo& oauth_client_info,
        bool enable_job_poll);
 
@@ skipping 26 matching lines @@
   void DoShutdown();
   void DoRegisterSelectedPrinters(
       const printing::PrinterList& printer_list);
   void DoUnregisterPrinters();
 
   // CloudPrintAuth::Client implementation.
   virtual void OnAuthenticationComplete(
       const std::string& access_token,
       const std::string& robot_oauth_refresh_token,
       const std::string& robot_email,
-      const std::string& user_email);
-  virtual void OnInvalidCredentials();
+      const std::string& user_email) OVERRIDE;
+  virtual void OnInvalidCredentials() OVERRIDE;
 
   // CloudPrintConnector::Client implementation.
-  virtual void OnAuthFailed();
+  virtual void OnAuthFailed() OVERRIDE;
 
-  // notifier::TalkMediator::Delegate implementation.
+  // notifier::PushClient::Delegate implementation.
   virtual void OnNotificationStateChange(
-      bool notifications_enabled);
+      bool notifications_enabled) OVERRIDE;
   virtual void OnIncomingNotification(
-      const notifier::Notification& notification);
-  virtual void OnOutgoingNotification();
+      const notifier::Notification& notification) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
 
   virtual ~Core() {}
 
   void CreateAuthAndConnector();
   void DestroyAuthAndConnector();
 
   // NotifyXXX is how the Core communicates with the frontend across
@@ skipping 31 matching lines @@
 
   // 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::TalkMediator> talk_mediator_;
+  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_;
   scoped_ptr<CloudPrintTokenStore> token_store_;
@@ skipping 187 matching lines @@
   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 {
     // If we are refreshing a token, update the XMPP token too.
-    DCHECK(talk_mediator_.get());
-    talk_mediator_->SetAuthToken(robot_email,
-                                 access_token,
-                                 kSyncGaiaServiceId);
+    DCHECK(push_client_.get());
+    push_client_->UpdateCredentials(robot_email, access_token);
   }
   // Start cloud print connector if needed.
   if (!connector_->IsRunning()) {
     if (!connector_->Start()) {
       // Let the frontend know that we do not have a print system.
       backend_->frontend_loop_->PostTask(
           FROM_HERE, base::Bind(&Core::NotifyPrintSystemUnavailable, this));
     }
   }
 }
@@ skipping 18 matching lines @@
 
 void CloudPrintProxyBackend::Core::InitNotifications(
     const std::string& robot_email,
     const std::string& access_token) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
 
   notifier::NotifierOptions notifier_options;
   notifier_options.request_context_getter =
       g_service_process->GetServiceURLRequestContextGetter();
   notifier_options.auth_mechanism = "X-OAUTH2";
-  talk_mediator_.reset(new notifier::TalkMediatorImpl(
-      new notifier::MediatorThreadImpl(notifier_options),
-      notifier_options));
+  push_client_.reset(new notifier::PushClient(notifier_options));
+  push_client_->AddObserver(this);
   notifier::Subscription subscription;
   subscription.channel = kCloudPrintPushNotificationsSource;
   subscription.from = kCloudPrintPushNotificationsSource;
-  talk_mediator_->AddSubscription(subscription);
-  talk_mediator_->SetDelegate(this);
-  talk_mediator_->SetAuthToken(robot_email, access_token, kSyncGaiaServiceId);
-  talk_mediator_->Login();
+  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_;
 
   if (connector_->IsRunning())
     connector_->Stop();
 
-  // Important to delete the TalkMediator on this thread.
-  if (talk_mediator_.get())
-    talk_mediator_->Logout();
-  talk_mediator_.reset();
+  // Important to delete the PushClient on this thread.
+  if (push_client_.get()) {
+    push_client_->RemoveObserver(this);
+  }
+  push_client_.reset();
   notifications_enabled_ = false;
   notifications_enabled_since_ = base::TimeTicks();
   token_store_.reset();
 
   DestroyAuthAndConnector();
 }
 
 void CloudPrintProxyBackend::Core::DoUnregisterPrinters() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
 
@@ skipping 100 matching lines @@
 
 
 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);
 }
-
-void CloudPrintProxyBackend::Core::OnOutgoingNotification() {}