[Invalidations] Add GetInvalidatorState() to Invalidator{,Frontend}

sync/notifier/sync_invalidation_listener.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/sync_invalidation_listener.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 16 matching lines @@
 namespace syncer {
 
 SyncInvalidationListener::Delegate::~Delegate() {}
 
 SyncInvalidationListener::SyncInvalidationListener(
     scoped_ptr<notifier::PushClient> push_client)
     : push_client_(push_client.get()),
       sync_system_resources_(push_client.Pass(),
                              ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       delegate_(NULL),
-      ticl_state_(DEFAULT_NOTIFICATION_ERROR),
-      push_client_state_(DEFAULT_NOTIFICATION_ERROR) {
+      ticl_state_(DEFAULT_INVALIDATION_ERROR),
+      push_client_state_(DEFAULT_INVALIDATION_ERROR) {
   DCHECK(CalledOnValidThread());
   push_client_->AddObserver(this);
 }
 
 SyncInvalidationListener::~SyncInvalidationListener() {
   DCHECK(CalledOnValidThread());
   push_client_->RemoveObserver(this);
   Stop();
   DCHECK(!delegate_);
 }
@@ skipping 49 matching lines @@
 
 void SyncInvalidationListener::UpdateCredentials(
     const std::string& email, const std::string& token) {
   DCHECK(CalledOnValidThread());
   sync_system_resources_.network()->UpdateCredentials(email, token);
 }
 
 void SyncInvalidationListener::UpdateRegisteredIds(const ObjectIdSet& ids) {
   DCHECK(CalledOnValidThread());
   registered_ids_ = ids;
-  // |ticl_state_| can go to NO_NOTIFICATION_ERROR even without a
+  // |ticl_state_| can go to INVALIDATIONS_ENABLED even without a
   // working XMPP connection (as observed by us), so check it instead
   // of GetState() (see http://crbug.com/139424).
-  if (ticl_state_ == NO_NOTIFICATION_ERROR && registration_manager_.get()) {
+  if (ticl_state_ == INVALIDATIONS_ENABLED && registration_manager_.get()) {
     DoRegistrationUpdate();
   }
 }
 
 void SyncInvalidationListener::Ready(
     invalidation::InvalidationClient* client) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
-  ticl_state_ = NO_NOTIFICATION_ERROR;
+  ticl_state_ = INVALIDATIONS_ENABLED;
   EmitStateChange();
   DoRegistrationUpdate();
 }
 
 void SyncInvalidationListener::Invalidate(
     invalidation::InvalidationClient* client,
     const invalidation::Invalidation& invalidation,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
@@ skipping 136 matching lines @@
 
 void SyncInvalidationListener::InformError(
     invalidation::InvalidationClient* client,
     const invalidation::ErrorInfo& error_info) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
   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_state_ = NOTIFICATION_CREDENTIALS_REJECTED;
+    ticl_state_ = INVALIDATION_CREDENTIALS_REJECTED;
   } else {
-    ticl_state_ = TRANSIENT_NOTIFICATION_ERROR;
+    ticl_state_ = TRANSIENT_INVALIDATION_ERROR;
   }
   EmitStateChange();
 }
 
 void SyncInvalidationListener::WriteState(const std::string& state) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "WriteState";
   invalidation_state_tracker_.Call(
       FROM_HERE, &InvalidationStateTracker::SetInvalidationState, state);
 }
@@ skipping 19 matching lines @@
 
   registration_manager_.reset();
   sync_system_resources_.Stop();
   invalidation_client_->Stop();
 
   invalidation_client_.reset();
   delegate_ = NULL;
 
   invalidation_state_tracker_.Reset();
   max_invalidation_versions_.clear();
-  ticl_state_ = DEFAULT_NOTIFICATION_ERROR;
-  push_client_state_ = DEFAULT_NOTIFICATION_ERROR;
+  ticl_state_ = DEFAULT_INVALIDATION_ERROR;
+  push_client_state_ = DEFAULT_INVALIDATION_ERROR;
 }
 
-NotificationsDisabledReason SyncInvalidationListener::GetState() const {
+InvalidatorState SyncInvalidationListener::GetState() const {
   DCHECK(CalledOnValidThread());
-  if (ticl_state_ == NOTIFICATION_CREDENTIALS_REJECTED ||
-      push_client_state_ == NOTIFICATION_CREDENTIALS_REJECTED) {
+  if (ticl_state_ == INVALIDATION_CREDENTIALS_REJECTED ||
+      push_client_state_ == INVALIDATION_CREDENTIALS_REJECTED) {
     // If either the ticl or the push client rejected our credentials,
-    // return NOTIFICATION_CREDENTIALS_REJECTED.
-    return NOTIFICATION_CREDENTIALS_REJECTED;
+    // return INVALIDATION_CREDENTIALS_REJECTED.
+    return INVALIDATION_CREDENTIALS_REJECTED;
   }
-  if (ticl_state_ == NO_NOTIFICATION_ERROR &&
-      push_client_state_ == NO_NOTIFICATION_ERROR) {
+  if (ticl_state_ == INVALIDATIONS_ENABLED &&
+      push_client_state_ == INVALIDATIONS_ENABLED) {
     // If the ticl is ready and the push client notifications are
-    // enabled, return NO_NOTIFICATION_ERROR.
-    return NO_NOTIFICATION_ERROR;
+    // enabled, return INVALIDATIONS_ENABLED.
+    return INVALIDATIONS_ENABLED;
   }
   // Otherwise, we have a transient error.
-  return TRANSIENT_NOTIFICATION_ERROR;
+  return TRANSIENT_INVALIDATION_ERROR;
 }
 
 void SyncInvalidationListener::EmitStateChange() {
   DCHECK(CalledOnValidThread());
-  if (GetState() == NO_NOTIFICATION_ERROR) {
-    delegate_->OnNotificationsEnabled();
-  } else {
-    delegate_->OnNotificationsDisabled(GetState());
-  }
+  delegate_->OnInvalidatorStateChange(GetState());
 }
 
 void SyncInvalidationListener::OnNotificationsEnabled() {
   DCHECK(CalledOnValidThread());
-  push_client_state_ = NO_NOTIFICATION_ERROR;
+  push_client_state_ = INVALIDATIONS_ENABLED;
   EmitStateChange();
 }
 
 void SyncInvalidationListener::OnNotificationsDisabled(
     notifier::NotificationsDisabledReason reason) {
   DCHECK(CalledOnValidThread());
   push_client_state_ = FromNotifierReason(reason);
   EmitStateChange();
 }
 
 void SyncInvalidationListener::OnIncomingNotification(
     const notifier::Notification& notification) {
   DCHECK(CalledOnValidThread());
   // Do nothing, since this is already handled by |invalidation_client_|.
 }
 
 }  // namespace syncer