[Sync] Propagate XMPP auth errors to SyncNotifierObservers

sync/notifier/p2p_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/p2p_notifier.h"
 
 #include <algorithm>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 126 matching lines @@
     return false;
   }
   changed_types_ = syncable::ModelTypeSetFromValue(*changed_types_list);
   return true;
 }
 
 P2PNotifier::P2PNotifier(scoped_ptr<notifier::PushClient> push_client,
                          P2PNotificationTarget send_notification_target)
     : push_client_(push_client.Pass()),
       logged_in_(false),
-      notifications_enabled_(false),
+      state_(NOTIFICATIONS_OFF),
       send_notification_target_(send_notification_target) {
   DCHECK(send_notification_target_ == NOTIFY_OTHERS ||
          send_notification_target_ == NOTIFY_ALL);
   push_client_->AddObserver(this);
 }
 
 P2PNotifier::~P2PNotifier() {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   push_client_->RemoveObserver(this);
 }
@@ skipping 47 matching lines @@
 }
 
 void P2PNotifier::SendNotification(
     syncable::ModelTypeSet changed_types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   const P2PNotificationData notification_data(
       unique_id_, send_notification_target_, changed_types);
   SendNotificationData(notification_data);
 }
 
-void P2PNotifier::OnNotificationStateChange(bool notifications_enabled) {
+void P2PNotifier::OnPushClientStateChange(
+    notifier::PushClientState push_client_state) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
-  bool disabled_to_enabled = notifications_enabled && !notifications_enabled_;
-  notifications_enabled_ = notifications_enabled;
-  FOR_EACH_OBSERVER(SyncNotifierObserver, observer_list_,
-      OnNotificationStateChange(notifications_enabled_));
-  if (disabled_to_enabled) {
+  SyncNotifierState state =
+      PushClientStateToSyncNotifierState(push_client_state);
+  bool just_turned_on =

[rlarocque, 2012/06/14 20:01:07]

This protects against spurious notifications, right?  Do we really expect to
receive spurious notifications?

[akalin, 2012/06/16 01:06:55]

I think it's okay to be defensive here since it could conceivably be used with a
real XMPP server (as opposed to our test one).

But yeah, it's not likely that we'd get spurious notifications, unless the XMPP
server sends out multiple subscription replies or something.

+      (state_ != NOTIFICATIONS_ON) && (state == NOTIFICATIONS_ON);
+  state_ = state;
+  FOR_EACH_OBSERVER(
+      SyncNotifierObserver, observer_list_,
+      OnSyncNotifierStateChange(state_));
+  if (just_turned_on) {
     const P2PNotificationData notification_data(
         unique_id_, NOTIFY_SELF, enabled_types_);
     SendNotificationData(notification_data);
   }
 }
 
 void P2PNotifier::OnIncomingNotification(
     const notifier::Notification& notification) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   DVLOG(1) << "Received notification " << notification.ToString();
   if (!logged_in_) {
     DVLOG(1) << "Not logged in yet -- not emitting notification";
     return;
   }
-  if (!notifications_enabled_) {
-    DVLOG(1) << "Notifications not enabled -- not emitting notification";
+  if (state_ != NOTIFICATIONS_ON) {
+    DVLOG(1) << "Notifications not on -- not emitting notification";
     return;
   }
   if (notification.channel != kSyncP2PNotificationChannel) {
     LOG(WARNING) << "Notification from unexpected source "
                  << notification.channel;
   }
   P2PNotificationData notification_data;
   if (!notification_data.ResetFromString(notification.data)) {
     LOG(WARNING) << "Could not parse notification data from "
                  << notification.data;
@@ skipping 26 matching lines @@
     const P2PNotificationData& notification_data) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   notifier::Notification notification;
   notification.channel = kSyncP2PNotificationChannel;
   notification.data = notification_data.ToString();
   DVLOG(1) << "Sending XMPP notification: " << notification.ToString();
   push_client_->SendNotification(notification);
 }
 
 }  // namespace sync_notifier