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

sync/internal_api/sync_manager_impl_unittest.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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 888 matching lines @@
   ModelTypeSet GetEncryptedTypes() {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     return GetEncryptedTypesWithTrans(&trans);
   }
 
   ModelTypeSet GetEncryptedTypesWithTrans(BaseTransaction* trans) {
     return trans->GetDirectory()->GetNigoriHandler()->
         GetEncryptedTypes(trans->GetWrappedTrans());
   }
 
-  void SimulateEnableNotificationsForTest() {
+  void SimulateInvalidatorStateChangeForTest(InvalidatorState state) {
     DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
-    sync_manager_.OnNotificationsEnabled();
-  }
-
-  void SimulateDisableNotificationsForTest(
-      NotificationsDisabledReason reason) {
-    DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
-    sync_manager_.OnNotificationsDisabled(reason);
+    sync_manager_.OnInvalidatorStateChange(state);
   }
 
   void TriggerOnIncomingNotificationForTest(ModelTypeSet model_types) {
     DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
     ModelTypeStateMap type_state_map =
         ModelTypeSetToStateMap(model_types, std::string());
-    sync_manager_.OnIncomingNotification(
+    sync_manager_.OnIncomingInvalidation(
         ModelTypeStateMapToObjectIdStateMap(type_state_map),
-        REMOTE_NOTIFICATION);
+        REMOTE_INVALIDATION);
   }
 
   void SetProgressMarkerForType(ModelType type, bool set) {
     if (set) {
       sync_pb::DataTypeProgressMarker marker;
       marker.set_token("token");
       marker.set_data_type_id(GetSpecificsFieldNumberFromModelType(type));
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     } else {
       sync_pb::DataTypeProgressMarker marker;
@@ skipping 52 matching lines @@
   EXPECT_FALSE(fake_invalidator_->IsHandlerRegistered(&fake_handler));
 }
 
 TEST_F(SyncManagerTest, ProcessJsMessage) {
   const JsArgList kNoArgs;
 
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue disabled_args;
   disabled_args.Append(
-      Value::CreateStringValue("TRANSIENT_NOTIFICATION_ERROR"));
+      Value::CreateStringValue("TRANSIENT_INVALIDATION_ERROR"));
 
   EXPECT_CALL(reply_handler,
               HandleJsReply("getNotificationState",
                             HasArgsAsList(disabled_args)));
 
   // This message should be dropped.
   SendJsMessage("unknownMessage", kNoArgs, reply_handler.AsWeakHandle());
 
   SendJsMessage("getNotificationState", kNoArgs, reply_handler.AsWeakHandle());
 }
@@ skipping 267 matching lines @@
   ASSERT_TRUE(node_list->GetDictionary(0, &first_result));
   EXPECT_TRUE(first_result->HasKey("ID"));
   EXPECT_TRUE(first_result->HasKey("NON_UNIQUE_NAME"));
 }
 
 TEST_F(SyncManagerTest, OnNotificationStateChange) {
   InSequence dummy;
   StrictMock<MockJsEventHandler> event_handler;
 
   DictionaryValue enabled_details;
-  enabled_details.SetString("state", "NO_NOTIFICATION_ERROR");
+  enabled_details.SetString("state", "INVALIDATIONS_ENABLED");
   DictionaryValue disabled_details;
-  disabled_details.SetString("state", "TRANSIENT_NOTIFICATION_ERROR");
+  disabled_details.SetString("state", "TRANSIENT_INVALIDATION_ERROR");
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onNotificationStateChange",
                             HasDetailsAsDictionary(enabled_details)));
   EXPECT_CALL(event_handler,
               HandleJsEvent("onNotificationStateChange",
                             HasDetailsAsDictionary(disabled_details)));
 
-  SimulateEnableNotificationsForTest();
-  SimulateDisableNotificationsForTest(TRANSIENT_NOTIFICATION_ERROR);
+  SimulateInvalidatorStateChangeForTest(INVALIDATIONS_ENABLED);
+  SimulateInvalidatorStateChangeForTest(TRANSIENT_INVALIDATION_ERROR);
 
   SetJsEventHandler(event_handler.AsWeakHandle());
-  SimulateEnableNotificationsForTest();
-  SimulateDisableNotificationsForTest(TRANSIENT_NOTIFICATION_ERROR);
+  SimulateInvalidatorStateChangeForTest(INVALIDATIONS_ENABLED);
+  SimulateInvalidatorStateChangeForTest(TRANSIENT_INVALIDATION_ERROR);
   SetJsEventHandler(WeakHandle<JsEventHandler>());
 
-  SimulateEnableNotificationsForTest();
-  SimulateDisableNotificationsForTest(TRANSIENT_NOTIFICATION_ERROR);
+  SimulateInvalidatorStateChangeForTest(INVALIDATIONS_ENABLED);
+  SimulateInvalidatorStateChangeForTest(TRANSIENT_INVALIDATION_ERROR);
 
   // Should trigger the replies.
   PumpLoop();
 }
 
 TEST_F(SyncManagerTest, OnIncomingNotification) {
   StrictMock<MockJsEventHandler> event_handler;
 
   const ModelTypeSet empty_model_types;
   const ModelTypeSet model_types(
       BOOKMARKS, THEMES);
 
   // Build expected_args to have a single argument with the string
   // equivalents of model_types.
   DictionaryValue expected_details;
   {
     ListValue* model_type_list = new ListValue();
-    expected_details.SetString("source", "REMOTE_NOTIFICATION");
+    expected_details.SetString("source", "REMOTE_INVALIDATION");
     expected_details.Set("changedTypes", model_type_list);
     for (ModelTypeSet::Iterator it = model_types.First();
          it.Good(); it.Inc()) {
       model_type_list->Append(
           Value::CreateStringValue(ModelTypeToString(it.Get())));
     }
   }
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onIncomingNotification",
@@ skipping 1550 matching lines @@
 
   // Verify only the non-disabled types remain after cleanup.
   sync_manager_.PurgeDisabledTypes(enabled_types, new_enabled_types);
   EXPECT_TRUE(new_enabled_types.Equals(
       Union(sync_manager_.InitialSyncEndedTypes(), partial_enabled_types)));
   EXPECT_TRUE(disabled_types.Equals(
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
 }
 
 }  // namespace