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

sync/notifier/non_blocking_invalidator.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_invalidator.h"
 
 #include <cstddef>
 
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
       const WeakHandle<InvalidationStateTracker>& invalidation_state_tracker,
       const std::string& client_info);
   void Teardown();
   void UpdateRegisteredIds(const ObjectIdSet& ids);
   void SetUniqueId(const std::string& unique_id);
   void SetStateDeprecated(const std::string& state);
   void UpdateCredentials(const std::string& email, const std::string& token);
 
   // InvalidationHandler implementation (all called on I/O thread by
   // InvalidationNotifier).
-  virtual void OnNotificationsEnabled() OVERRIDE;
-  virtual void OnNotificationsDisabled(
-      NotificationsDisabledReason reason) OVERRIDE;
-  virtual void OnIncomingNotification(
+  virtual void OnInvalidatorStateChange(InvalidatorState reason) OVERRIDE;
+  virtual void OnIncomingInvalidation(
       const ObjectIdStateMap& id_state_map,
-      IncomingNotificationSource source) OVERRIDE;
+      IncomingInvalidationSource source) OVERRIDE;
 
  private:
   friend class
       base::RefCountedThreadSafe<NonBlockingInvalidator::Core>;
   // Called on parent or I/O thread.
   ~Core();
 
   // The variables below should be used only on the I/O thread.
   const WeakHandle<InvalidationHandler> delegate_observer_;
   scoped_ptr<InvalidationNotifier> invalidation_notifier_;
@@ skipping 55 matching lines @@
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->SetStateDeprecated(state);
 }
 
 void NonBlockingInvalidator::Core::UpdateCredentials(const std::string& email,
                                                      const std::string& token) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   invalidation_notifier_->UpdateCredentials(email, token);
 }
 
-void NonBlockingInvalidator::Core::OnNotificationsEnabled() {
+void NonBlockingInvalidator::Core::OnInvalidatorStateChange(
+    InvalidatorState reason) {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+  delegate_observer_.Call(
+      FROM_HERE, &InvalidationHandler::OnInvalidatorStateChange, reason);
+}
+
+void NonBlockingInvalidator::Core::OnIncomingInvalidation(
+    const ObjectIdStateMap& id_state_map, IncomingInvalidationSource source) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
-                          &InvalidationHandler::OnNotificationsEnabled);
-}
-
-void NonBlockingInvalidator::Core::OnNotificationsDisabled(
-    NotificationsDisabledReason reason) {
-  DCHECK(network_task_runner_->BelongsToCurrentThread());
-  delegate_observer_.Call(
-      FROM_HERE, &InvalidationHandler::OnNotificationsDisabled, reason);
-}
-
-void NonBlockingInvalidator::Core::OnIncomingNotification(
-    const ObjectIdStateMap& id_state_map, IncomingNotificationSource source) {
-  DCHECK(network_task_runner_->BelongsToCurrentThread());
-  delegate_observer_.Call(FROM_HERE,
-                          &InvalidationHandler::OnIncomingNotification,
+                          &InvalidationHandler::OnIncomingInvalidation,
                           id_state_map,
                           source);
 }
 
 NonBlockingInvalidator::NonBlockingInvalidator(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
     const std::string& initial_invalidation_state,
     const WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
@@ skipping 46 matching lines @@
               registrar_.GetAllRegisteredIds()))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidator::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.UnregisterHandler(handler);
 }
 
+InvalidatorState NonBlockingInvalidator::GetInvalidatorState() const {
+  DCHECK(parent_task_runner_->BelongsToCurrentThread());
+  return registrar_.GetInvalidatorState();
+}
+
 void NonBlockingInvalidator::SetUniqueId(const std::string& unique_id) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::SetUniqueId,
                      core_.get(), unique_id))) {
     NOTREACHED();
   }
 }
 
@@ skipping 12 matching lines @@
                                                const std::string& token) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::UpdateCredentials,
                      core_.get(), email, token))) {
     NOTREACHED();
   }
 }
 
-void NonBlockingInvalidator::SendNotification(
+void NonBlockingInvalidator::SendInvalidation(
     const ObjectIdStateMap& id_state_map) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  // InvalidationClient doesn't implement SendNotification(), so no
+  // InvalidationClient doesn't implement SendInvalidation(), so no
   // need to forward on the call.
 }
 
-void NonBlockingInvalidator::OnNotificationsEnabled() {
+void NonBlockingInvalidator::OnInvalidatorStateChange(InvalidatorState state) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  registrar_.EmitOnNotificationsEnabled();
+  registrar_.UpdateInvalidatorState(state);
 }
 
-void NonBlockingInvalidator::OnNotificationsDisabled(
-    NotificationsDisabledReason reason) {
-  DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  registrar_.EmitOnNotificationsDisabled(reason);
-}
-
-void NonBlockingInvalidator::OnIncomingNotification(
+void NonBlockingInvalidator::OnIncomingInvalidation(
         const ObjectIdStateMap& id_state_map,
-        IncomingNotificationSource source) {
+        IncomingInvalidationSource source) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.DispatchInvalidationsToHandlers(id_state_map, source);
 }
 
 }  // namespace syncer