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

sync/internal_api/sync_manager_impl.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/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 150 matching lines @@
     return delay;
   }
 };
 
 SyncManagerImpl::SyncManagerImpl(const std::string& name)
     : name_(name),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       change_delegate_(NULL),
       initialized_(false),
       observing_ip_address_changes_(false),
-      notifications_disabled_reason_(TRANSIENT_NOTIFICATION_ERROR),
+      invalidator_state_(DEFAULT_INVALIDATION_ERROR),
       throttled_data_type_tracker_(&allstatus_),
       traffic_recorder_(kMaxMessagesToRecord, kMaxMessageSizeToRecord),
       encryptor_(NULL),
       unrecoverable_error_handler_(NULL),
       report_unrecoverable_error_function_(NULL) {
   // Pre-fill |notification_info_map_|.
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     notification_info_map_.insert(
         std::make_pair(ModelTypeFromInt(i), NotificationInfo()));
   }
@@ skipping 821 matching lines @@
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot.model_neutral_state().num_successful_commits > 0);
     if (is_notifiable_commit) {
       if (invalidator_.get()) {
         const ObjectIdStateMap& id_state_map =
             ModelTypeStateMapToObjectIdStateMap(event.snapshot.source().types);
-        invalidator_->SendNotification(id_state_map);
+        invalidator_->SendInvalidation(id_state_map);
       } else {
-        DVLOG(1) << "Not sending notification: invalidator_ is NULL";
+        DVLOG(1) << "Not sending invalidation: invalidator_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnStopSyncingPermanently());
     return;
   }
 
@@ skipping 47 matching lines @@
                      name, js_message_handler.Run(args));
 }
 
 void SyncManagerImpl::BindJsMessageHandler(
     const std::string& name,
     UnboundJsMessageHandler unbound_message_handler) {
   js_message_handlers_[name] =
       base::Bind(unbound_message_handler, base::Unretained(this));
 }
 
-void SyncManagerImpl::OnNotificationStateChange(
-    NotificationsDisabledReason reason) {
-  const std::string& reason_str = NotificationsDisabledReasonToString(reason);
-  notifications_disabled_reason_ = reason;
-  DVLOG(1) << "Notification state changed to: " << reason_str;
-  const bool notifications_enabled =
-      (notifications_disabled_reason_ == NO_NOTIFICATION_ERROR);
-  allstatus_.SetNotificationsEnabled(notifications_enabled);
-  scheduler_->SetNotificationsEnabled(notifications_enabled);
-
-  // TODO(akalin): Treat a CREDENTIALS_REJECTED state as an auth
-  // error.
-
-  if (js_event_handler_.IsInitialized()) {
-    DictionaryValue details;
-    details.Set("state", Value::CreateStringValue(reason_str));
-    js_event_handler_.Call(FROM_HERE,
-                           &JsEventHandler::HandleJsEvent,
-                           "onNotificationStateChange",
-                           JsEventDetails(&details));
-  }
-}
-
 DictionaryValue* SyncManagerImpl::NotificationInfoToValue(
     const NotificationInfoMap& notification_info) {
   DictionaryValue* value = new DictionaryValue();
 
   for (NotificationInfoMap::const_iterator it = notification_info.begin();
       it != notification_info.end(); ++it) {
     const std::string& model_type_str = ModelTypeToString(it->first);
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
 std::string SyncManagerImpl::NotificationInfoToString(
     const NotificationInfoMap& notification_info) {
   scoped_ptr<DictionaryValue> value(
       NotificationInfoToValue(notification_info));
   std::string str;
   base::JSONWriter::Write(value.get(), &str);
   return str;
 }
 
 JsArgList SyncManagerImpl::GetNotificationState(
     const JsArgList& args) {
   const std::string& notification_state =
-      NotificationsDisabledReasonToString(notifications_disabled_reason_);
+      InvalidatorStateToString(invalidator_state_);
   DVLOG(1) << "GetNotificationState: " << notification_state;
   ListValue return_args;
   return_args.Append(Value::CreateStringValue(notification_state));
   return JsArgList(&return_args);
 }
 
 JsArgList SyncManagerImpl::GetNotificationInfo(
     const JsArgList& args) {
   DVLOG(1) << "GetNotificationInfo: "
            << NotificationInfoToString(notification_info_map_);
@@ skipping 111 matching lines @@
 void SyncManagerImpl::UpdateNotificationInfo(
     const ModelTypeStateMap& type_state_map) {
   for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
        it != type_state_map.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
     info->payload = it->second.payload;
   }
 }
 
-void SyncManagerImpl::OnNotificationsEnabled() {
-  OnNotificationStateChange(NO_NOTIFICATION_ERROR);
+void SyncManagerImpl::OnInvalidatorStateChange(InvalidatorState state) {
+  const std::string& state_str = InvalidatorStateToString(state);
+  invalidator_state_ = state;
+  DVLOG(1) << "Invalidator state changed to: " << state_str;
+  const bool notifications_enabled =
+      (invalidator_state_ == INVALIDATIONS_ENABLED);
+  allstatus_.SetNotificationsEnabled(notifications_enabled);
+  scheduler_->SetNotificationsEnabled(notifications_enabled);
+
+  // TODO(akalin): Treat a CREDENTIALS_REJECTED state as an auth
+  // error.
+
+  if (js_event_handler_.IsInitialized()) {
+    DictionaryValue details;
+    details.SetString("state", state_str);
+    js_event_handler_.Call(FROM_HERE,
+                           &JsEventHandler::HandleJsEvent,
+                           "onNotificationStateChange",
+                           JsEventDetails(&details));
+  }
 }
 
-void SyncManagerImpl::OnNotificationsDisabled(
-    NotificationsDisabledReason reason) {
-  OnNotificationStateChange(reason);
-}
-
-void SyncManagerImpl::OnIncomingNotification(
+void SyncManagerImpl::OnIncomingInvalidation(
     const ObjectIdStateMap& id_state_map,
-    IncomingNotificationSource source) {
+    IncomingInvalidationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const ModelTypeStateMap& type_state_map =
       ObjectIdStateMapToModelTypeStateMap(id_state_map);
-  if (source == LOCAL_NOTIFICATION) {
+  if (source == LOCAL_INVALIDATION) {
     scheduler_->ScheduleNudgeWithStatesAsync(
         TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
         NUDGE_SOURCE_LOCAL_REFRESH,
         type_state_map, FROM_HERE);
   } else if (!type_state_map.empty()) {
     scheduler_->ScheduleNudgeWithStatesAsync(
         TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
         NUDGE_SOURCE_NOTIFICATION,
         type_state_map, FROM_HERE);
     allstatus_.IncrementNotificationsReceived();
     UpdateNotificationInfo(type_state_map);
     debug_info_event_listener_.OnIncomingNotification(type_state_map);
   } else {
-    LOG(WARNING) << "Sync received notification without any type information.";
+    LOG(WARNING) << "Sync received invalidation without any type information.";
   }
 
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     ListValue* changed_types = new ListValue();
     details.Set("changedTypes", changed_types);
     for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
          it != type_state_map.end(); ++it) {
       const std::string& model_type_str =
           ModelTypeToString(it->first);
       changed_types->Append(Value::CreateStringValue(model_type_str));
     }
-    details.SetString("source", (source == LOCAL_NOTIFICATION) ?
-        "LOCAL_NOTIFICATION" : "REMOTE_NOTIFICATION");
+    details.SetString("source", (source == LOCAL_INVALIDATION) ?
+        "LOCAL_INVALIDATION" : "REMOTE_INVALIDATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
   }
 }
 
 SyncStatus SyncManagerImpl::GetDetailedStatus() const {
   return allstatus_.status();
 }
@@ skipping 39 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer