[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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
@@ skipping 25 matching lines @@
   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 OnIncomingNotification(
       const syncable::ModelTypePayloadMap& type_payloads,
       IncomingNotificationSource source);
-  virtual void OnNotificationStateChange(bool notifications_enabled);
+  virtual void OnSyncNotifierStateChange(
+      SyncNotifierState sync_notifier_state);
 
  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 61 matching lines @@
   invalidation_notifier_->UpdateCredentials(email, token);
 }
 
 void NonBlockingInvalidationNotifier::Core::UpdateEnabledTypes(
     syncable::ModelTypeSet enabled_types) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   invalidation_notifier_->UpdateEnabledTypes(enabled_types);
 }
 
 void NonBlockingInvalidationNotifier::Core::OnIncomingNotification(
-        const syncable::ModelTypePayloadMap& type_payloads,
-        IncomingNotificationSource source) {
+    const syncable::ModelTypePayloadMap& type_payloads,
+    IncomingNotificationSource source) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
                           &SyncNotifierObserver::OnIncomingNotification,
                           type_payloads,
                           source);
 }
 
-void NonBlockingInvalidationNotifier::Core::OnNotificationStateChange(
-        bool notifications_enabled) {
+void NonBlockingInvalidationNotifier::Core::OnSyncNotifierStateChange(
+    SyncNotifierState sync_notifier_state) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
-                          &SyncNotifierObserver::OnNotificationStateChange,
-                          notifications_enabled);
+                          &SyncNotifierObserver::OnSyncNotifierStateChange,
+                          sync_notifier_state);
 }
 
 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)),
@@ skipping 93 matching lines @@
 }
 
 void NonBlockingInvalidationNotifier::OnIncomingNotification(
         const syncable::ModelTypePayloadMap& type_payloads,
         IncomingNotificationSource source) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   FOR_EACH_OBSERVER(SyncNotifierObserver, observers_,
                     OnIncomingNotification(type_payloads, source));
 }
 
-void NonBlockingInvalidationNotifier::OnNotificationStateChange(
-        bool notifications_enabled) {
+void NonBlockingInvalidationNotifier::OnSyncNotifierStateChange(
+    SyncNotifierState sync_notifier_state) {
   DCHECK(parent_message_loop_proxy_->BelongsToCurrentThread());
   FOR_EACH_OBSERVER(SyncNotifierObserver, observers_,
-                    OnNotificationStateChange(notifications_enabled));
+                    OnSyncNotifierStateChange(sync_notifier_state));
 }
 
 }  // namespace sync_notifier