[Sync] Propagate XMPP auth errors to SyncNotifierObservers

sync/notifier/chrome_invalidation_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 "sync/notifier/chrome_invalidation_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 13 matching lines @@
 const char kApplicationName[] = "chrome-sync";
 
 }  // namespace
 
 namespace sync_notifier {
 
 ChromeInvalidationClient::Listener::~Listener() {}
 
 ChromeInvalidationClient::ChromeInvalidationClient(
     scoped_ptr<notifier::PushClient> push_client)
-    : chrome_system_resources_(push_client.Pass(),
+    : push_client_(push_client.get()),
+      chrome_system_resources_(push_client.Pass(),
                                ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       listener_(NULL),
-      ticl_ready_(false) {
+      ticl_sync_notifier_state_(NOTIFICATIONS_OFF),
+      push_client_sync_notifier_state_(NOTIFICATIONS_OFF) {
   DCHECK(CalledOnValidThread());
+  push_client_->AddObserver(this);
 }
 
 ChromeInvalidationClient::~ChromeInvalidationClient() {
   DCHECK(CalledOnValidThread());
+  push_client_->RemoveObserver(this);
   Stop();
   DCHECK(!listener_);
 }
 
 void ChromeInvalidationClient::Start(
     const std::string& client_id, const std::string& client_info,
     const std::string& state,
     const InvalidationVersionMap& initial_max_invalidation_versions,
     const browser_sync::WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
@@ skipping 38 matching lines @@
   registration_manager_.reset(
       new RegistrationManager(invalidation_client_.get()));
 }
 
 void ChromeInvalidationClient::UpdateCredentials(
     const std::string& email, const std::string& token) {
   DCHECK(CalledOnValidThread());
   chrome_system_resources_.network()->UpdateCredentials(email, token);
 }
 
-void ChromeInvalidationClient::Stop() {
-  DCHECK(CalledOnValidThread());
-  if (!invalidation_client_.get()) {
-    return;
-  }
-
-  registration_manager_.reset();
-  chrome_system_resources_.Stop();
-  invalidation_client_->Stop();
-
-  invalidation_client_.reset();
-  listener_ = NULL;
-
-  invalidation_state_tracker_.Reset();
-  max_invalidation_versions_.clear();
-}
-
 void ChromeInvalidationClient::RegisterTypes(syncable::ModelTypeSet types) {
   DCHECK(CalledOnValidThread());
   registered_types_ = types;
-  if (ticl_ready_ && registration_manager_.get()) {
+  if (GetSyncNotifierState() == NOTIFICATIONS_ON &&
+      registration_manager_.get()) {
     registration_manager_->SetRegisteredTypes(registered_types_);
   }
   // TODO(akalin): Clear invalidation versions for unregistered types.
 }
 
 void ChromeInvalidationClient::Ready(
     invalidation::InvalidationClient* client) {
-  ticl_ready_ = true;
-  listener_->OnSessionStatusChanged(true);
+  ticl_sync_notifier_state_ = NOTIFICATIONS_ON;
+  EmitStateChange();
   registration_manager_->SetRegisteredTypes(registered_types_);
 }
 
 void ChromeInvalidationClient::Invalidate(
     invalidation::InvalidationClient* client,
     const invalidation::Invalidation& invalidation,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "Invalidate: " << InvalidationToString(invalidation);
   syncable::ModelType model_type;
@@ skipping 138 matching lines @@
     const std::string& prefix,
     int prefix_length) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "AllRegistrationsLost";
   registration_manager_->MarkAllRegistrationsLost();
 }
 
 void ChromeInvalidationClient::InformError(
     invalidation::InvalidationClient* client,
     const invalidation::ErrorInfo& error_info) {
-  listener_->OnSessionStatusChanged(false);
-  LOG(ERROR) << "Invalidation client encountered an error";
-  // TODO(ghc): handle the error.
+  LOG(ERROR) << "Ticl error " << error_info.error_reason() << ": "
+             << error_info.error_message()
+             << " (transient = " << error_info.is_transient() << ")";
+  if (error_info.error_reason() == invalidation::ErrorReason::AUTH_FAILURE) {
+    ticl_sync_notifier_state_ = CREDENTIALS_REJECTED;
+  } else {
+    ticl_sync_notifier_state_ = NOTIFICATIONS_OFF;
+  }
+  EmitStateChange();
 }
 
 void ChromeInvalidationClient::WriteState(const std::string& state) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "WriteState";
   invalidation_state_tracker_.Call(
       FROM_HERE, &InvalidationStateTracker::SetInvalidationState, state);
 }
 
+void ChromeInvalidationClient::OnPushClientStateChange(
+    notifier::PushClientState push_client_state) {
+  DCHECK(CalledOnValidThread());
+  push_client_sync_notifier_state_ =
+      PushClientStateToSyncNotifierState(push_client_state);
+  EmitStateChange();
+}
+
+SyncNotifierState ChromeInvalidationClient::GetSyncNotifierState() const {
+  DCHECK(CalledOnValidThread());
+  if (ticl_sync_notifier_state_ == CREDENTIALS_REJECTED ||
+      push_client_sync_notifier_state_ == CREDENTIALS_REJECTED) {
+    // If either state is CREDENTIALS_REJECTED, return
+    // CREDENTIALS_REJECTED.
+    return CREDENTIALS_REJECTED;
+  }
+  if (ticl_sync_notifier_state_ == NOTIFICATIONS_ON &&
+      push_client_sync_notifier_state_ == NOTIFICATIONS_ON) {
+    // Emit NOTIFICATIONS_ON only when both states are
+    // NOTIFICATIONS_ON.
+    return NOTIFICATIONS_ON;
+  }
+  // Otherwise return NOTIFICATIONS_OFF.
+  return NOTIFICATIONS_OFF;
+}
+
+void ChromeInvalidationClient::Stop() {
+  DCHECK(CalledOnValidThread());
+  if (!invalidation_client_.get()) {
+    return;
+  }
+
+  registration_manager_.reset();
+  chrome_system_resources_.Stop();
+  invalidation_client_->Stop();
+
+  invalidation_client_.reset();
+  listener_ = NULL;
+
+  invalidation_state_tracker_.Reset();
+  max_invalidation_versions_.clear();
+  ticl_sync_notifier_state_ = NOTIFICATIONS_OFF;
+  push_client_sync_notifier_state_ = NOTIFICATIONS_OFF;
+}
+
+void ChromeInvalidationClient::EmitStateChange() {
+  DCHECK(CalledOnValidThread());
+  listener_->OnSyncNotifierStateChange(GetSyncNotifierState());
+}
+
+void ChromeInvalidationClient::OnIncomingNotification(
+    const notifier::Notification& notification) {
+  DCHECK(CalledOnValidThread());
+  // Do nothing, since this is already handled by |invalidation_client_|.
+}
+
 }  // namespace sync_notifier