[Sync] Propagate XMPP auth errors to SyncNotifierObservers

sync/notifier/non_blocking_invalidation_notifier.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 "sync/notifier/non_blocking_invalidation_notifier.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 24 matching lines @@
           invalidation_state_tracker,
       const std::string& client_info);
   void Teardown();
   void SetUniqueId(const std::string& unique_id);
   void SetStateDeprecated(const std::string& state);
   void UpdateCredentials(const std::string& email, const std::string& token);
   void UpdateEnabledTypes(syncable::ModelTypeSet enabled_types);
 
   // SyncNotifierObserver implementation (all called on I/O thread by
   // InvalidationNotifier).
+  virtual void OnNotificationsEnabled() OVERRIDE;
+  virtual void OnNotificationsDisabled(
+      NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
       const syncable::ModelTypePayloadMap& type_payloads,
-      IncomingNotificationSource source);
-  virtual void OnNotificationStateChange(bool notifications_enabled);
+      IncomingNotificationSource source) OVERRIDE;
 
  private:
   friend class
       base::RefCountedThreadSafe<NonBlockingInvalidationNotifier::Core>;
   // Called on parent or I/O thread.
   ~Core();
 
   // The variables below should be used only on the I/O thread.
   const browser_sync::WeakHandle<SyncNotifierObserver> delegate_observer_;
   scoped_ptr<InvalidationNotifier> invalidation_notifier_;
@@ skipping 60 matching lines @@
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->UpdateCredentials(email, token);
 }
 
 void NonBlockingInvalidationNotifier::Core::UpdateEnabledTypes(
     syncable::ModelTypeSet enabled_types) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->UpdateEnabledTypes(enabled_types);
 }
 
+void NonBlockingInvalidationNotifier::Core::OnNotificationsEnabled() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  delegate_observer_.Call(FROM_HERE,
+                          &SyncNotifierObserver::OnNotificationsEnabled);
+}
+
+void NonBlockingInvalidationNotifier::Core::OnNotificationsDisabled(
+    NotificationsDisabledReason reason) {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  delegate_observer_.Call(
+      FROM_HERE, &SyncNotifierObserver::OnNotificationsDisabled, reason);
+}
+
 void NonBlockingInvalidationNotifier::Core::OnIncomingNotification(
-        const syncable::ModelTypePayloadMap& type_payloads,
-        IncomingNotificationSource source) {
+    const syncable::ModelTypePayloadMap& type_payloads,
+    IncomingNotificationSource source) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
                           &SyncNotifierObserver::OnIncomingNotification,
                           type_payloads,
                           source);
 }
 
-void NonBlockingInvalidationNotifier::Core::OnNotificationStateChange(
-        bool notifications_enabled) {
-  DCHECK(network_task_runner_->BelongsToCurrentThread());
-  delegate_observer_.Call(FROM_HERE,
-                          &SyncNotifierObserver::OnNotificationStateChange,
-                          notifications_enabled);
-}
-
 NonBlockingInvalidationNotifier::NonBlockingInvalidationNotifier(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
     const std::string& initial_invalidation_state,
     const browser_sync::WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
     const std::string& client_info)
         : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
           core_(
               new Core(browser_sync::MakeWeakHandle(
@@ skipping 83 matching lines @@
   }
 }
 
 void NonBlockingInvalidationNotifier::SendNotification(
     syncable::ModelTypeSet changed_types) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   // InvalidationClient doesn't implement SendNotification(), so no
   // need to forward on the call.
 }
 
+void NonBlockingInvalidationNotifier::OnNotificationsEnabled() {
+  DCHECK(parent_task_runner_->BelongsToCurrentThread());
+  FOR_EACH_OBSERVER(SyncNotifierObserver, observers_,
+                    OnNotificationsEnabled());
+}
+
+void NonBlockingInvalidationNotifier::OnNotificationsDisabled(
+    NotificationsDisabledReason reason) {
+  DCHECK(parent_task_runner_->BelongsToCurrentThread());
+  FOR_EACH_OBSERVER(SyncNotifierObserver, observers_,
+                    OnNotificationsDisabled(reason));
+}
+
 void NonBlockingInvalidationNotifier::OnIncomingNotification(
         const syncable::ModelTypePayloadMap& type_payloads,
         IncomingNotificationSource source) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   FOR_EACH_OBSERVER(SyncNotifierObserver, observers_,
                     OnIncomingNotification(type_payloads, source));
 }
 
-void NonBlockingInvalidationNotifier::OnNotificationStateChange(
-        bool notifications_enabled) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  FOR_EACH_OBSERVER(SyncNotifierObserver, observers_,
-                    OnNotificationStateChange(notifications_enabled));
-}
-
 }  // namespace sync_notifier