Switched the cloud print proxy to use the Google push notifications....

chrome/service/cloud_print/cloud_print_proxy_backend.cc

 // Copyright (c) 2010 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 "base/file_util.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/net/http_return.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/printer_job_handler.h"
 #include "chrome/service/gaia/service_gaia_authenticator.h"
 #include "chrome/service/service_process.h"
 #include "jingle/notifier/base/notifier_options.h"
-#include "jingle/notifier/listener/mediator_thread_impl.h"
+#include "jingle/notifier/listener/push_notifications_thread.h"
 #include "jingle/notifier/listener/talk_mediator_impl.h"
 
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_status.h"
 
-// The real guts of SyncBackendHost, to keep the public client API clean.
+// The real guts of CloudPrintProxyBackend, to keep the public client API clean.
 class CloudPrintProxyBackend::Core
     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
       public URLFetcherDelegate,
       public cloud_print::PrintServerWatcherDelegate,
       public PrinterJobHandlerDelegate,
       public notifier::TalkMediator::Delegate {
  public:
   // It is OK for print_server_url to be empty. In this case system should
   // use system default (local) print server.
   explicit Core(CloudPrintProxyBackend* backend,
                 const GURL& cloud_print_server_url,
                 const DictionaryValue* print_system_settings);
 
   // 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) syncapi operations.
+  // (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);
   void DoInitializeWithToken(const std::string cloud_print_token,
                              const std::string cloud_print_xmpp_token,
                              const std::string email,
                              const std::string& proxy_id);
@@ skipping 116 matching lines @@
   ResponseHandler next_response_handler_;
   scoped_refptr<cloud_print::PrintSystem::PrintServerWatcher>
       print_server_watcher_;
   bool new_printers_available_;
   // Notification (xmpp) handler.
   scoped_ptr<notifier::TalkMediator> talk_mediator_;
   // Indicates whether XMPP notifications are currently enabled.
   bool notifications_enabled_;
   // Indicates whether a task to poll for jobs has been scheduled.
   bool job_poll_scheduled_;
+  // The channel we are interested in receiving push notifications for.
+  // This is "cloudprint.google.com/proxy/<proxy_id>"
+  std::string push_notifications_channel_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 CloudPrintProxyBackend::CloudPrintProxyBackend(
     CloudPrintProxyFrontend* frontend,
     const GURL& cloud_print_server_url,
     const DictionaryValue* print_system_settings)
       : core_thread_("Chrome_CloudPrintProxyCoreThread"),
         frontend_loop_(MessageLoop::current()),
@@ skipping 120 matching lines @@
     NOTREACHED();
     return;  // No print system available, fail initalization.
   }
 
   // TODO(sanjeevr): Validate the tokens.
   auth_token_ = cloud_print_token;
 
   const notifier::NotifierOptions kNotifierOptions;
   const bool kInvalidateXmppAuthToken = false;
   talk_mediator_.reset(new notifier::TalkMediatorImpl(
-      new notifier::MediatorThreadImpl(kNotifierOptions),
+      new notifier::PushNotificationsThread(kNotifierOptions,
+                                            kCloudPrintPushNotificationsSource),
       kInvalidateXmppAuthToken));
-  talk_mediator_->AddSubscribedServiceUrl(kCloudPrintTalkServiceUrl);
+  push_notifications_channel_ = kCloudPrintPushNotificationsSource;
+  push_notifications_channel_.append("/proxy/");
+  push_notifications_channel_.append(proxy_id);
+  talk_mediator_->AddSubscribedServiceUrl(push_notifications_channel_);
   talk_mediator_->SetDelegate(this);
   talk_mediator_->SetAuthToken(email, cloud_print_xmpp_token,
                                kSyncGaiaServiceId);
   talk_mediator_->Login();
 
   print_server_watcher_ = print_system_->CreatePrintServerWatcher();
   print_server_watcher_->StartWatching(this);
 
   proxy_id_ = proxy_id;
   StartRegistration();
@@ skipping 385 matching lines @@
   } else if (!previously_enabled) {
     PollForJobs();
   }
 }
 
 
 void CloudPrintProxyBackend::Core::OnIncomingNotification(
     const IncomingNotificationData& notification_data) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   LOG(INFO) << "CP_PROXY: Incoming notification.";
-  if (0 == base::strcasecmp(kCloudPrintTalkServiceUrl,
-                             notification_data.service_url.c_str())) {
+  if (0 == base::strcasecmp(push_notifications_channel_.c_str(),
+                            notification_data.service_url.c_str())) {
     HandlePrinterNotification(notification_data.service_specific_data);
   }
 }
 
 void CloudPrintProxyBackend::Core::OnOutgoingNotification() {}
 
 // cloud_print::PrinterChangeNotifier::Delegate implementation
 void CloudPrintProxyBackend::Core::OnPrinterAdded() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (request_.get()) {
@@ skipping 11 matching lines @@
   job_handler_map_.erase(printer_id);
 }
 
 void CloudPrintProxyBackend::Core::OnAuthError() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   LOG(INFO) << "CP_PROXY: Auth Error";
   backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::NotifyAuthenticationFailed));
 }