[Sync] Propagate XMPP auth errors to SyncNotifierObservers

jingle/notifier/listener/non_blocking_push_client.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 "jingle/notifier/listener/non_blocking_push_client.h"
 
 #include "base/bind.h"
-#include "base/message_loop_proxy.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/message_loop_proxy.h"
 #include "jingle/notifier/listener/push_client_observer.h"
 
 namespace notifier {
 
 // All methods are called on the delegate thread unless specified
 // otherwise.
 class NonBlockingPushClient::Core
     : public base::RefCountedThreadSafe<NonBlockingPushClient::Core>,
       public PushClientObserver {
  public:
@@ skipping 11 matching lines @@
       const CreateBlockingPushClientCallback&
           create_blocking_push_client_callback);
 
   // Must be called before being destroyed.
   void DestroyOnDelegateThread();
 
   void UpdateSubscriptions(const SubscriptionList& subscriptions);
   void UpdateCredentials(const std::string& email, const std::string& token);
   void SendNotification(const Notification& data);
 
-  virtual void OnNotificationStateChange(
-      bool notifications_enabled) OVERRIDE;
+  virtual void OnNotificationsEnabled() OVERRIDE;
+  virtual void OnNotificationsDisabled(
+      NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
       const Notification& notification) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<NonBlockingPushClient::Core>;
 
   // Called on either the parent thread or the delegate thread.
   virtual ~Core();
 
   const scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner_;
@@ skipping 48 matching lines @@
   delegate_push_client_->UpdateCredentials(email, token);
 }
 
 void NonBlockingPushClient::Core::SendNotification(
     const Notification& notification) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate_push_client_.get());
   delegate_push_client_->SendNotification(notification);
 }
 
-void NonBlockingPushClient::Core::OnNotificationStateChange(
-    bool notifications_enabled) {
+void NonBlockingPushClient::Core::OnNotificationsEnabled() {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   parent_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&NonBlockingPushClient::OnNotificationStateChange,
-                 parent_push_client_, notifications_enabled));
+      base::Bind(&NonBlockingPushClient::OnNotificationsEnabled,
+                 parent_push_client_));
+}
+
+void NonBlockingPushClient::Core::OnNotificationsDisabled(
+    NotificationsDisabledReason reason) {
+  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  parent_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&NonBlockingPushClient::OnNotificationsDisabled,
+                 parent_push_client_, reason));
 }
 
 void NonBlockingPushClient::Core::OnIncomingNotification(
     const Notification& notification) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   parent_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NonBlockingPushClient::OnIncomingNotification,
                  parent_push_client_, notification));
 }
@@ skipping 50 matching lines @@
 
 void NonBlockingPushClient::SendNotification(
     const Notification& notification) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   delegate_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NonBlockingPushClient::Core::SendNotification, core_.get(),
                  notification));
 }
 
-void NonBlockingPushClient::OnNotificationStateChange(
-    bool notifications_enabled) {
+void NonBlockingPushClient::OnNotificationsEnabled() {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   FOR_EACH_OBSERVER(PushClientObserver, observers_,
-                    OnNotificationStateChange(notifications_enabled));
+                    OnNotificationsEnabled());
+}
+
+void NonBlockingPushClient::OnNotificationsDisabled(
+    NotificationsDisabledReason reason) {
+  DCHECK(non_thread_safe_.CalledOnValidThread());
+  FOR_EACH_OBSERVER(PushClientObserver, observers_,
+                    OnNotificationsDisabled(reason));
 }
 
 void NonBlockingPushClient::OnIncomingNotification(
     const Notification& notification) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   FOR_EACH_OBSERVER(PushClientObserver, observers_,
                     OnIncomingNotification(notification));
 }
 
 }  // namespace notifier