[Sync] Remove CleanupDisabledTypes command and move purge logic into SyncManager.

sync/internal_api/syncapi_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 901 matching lines @@
       return false;
     entry.Put(IS_UNSYNCED, false);
     return true;
   }
 
   virtual InternalComponentsFactory* GetFactory() {
     return new TestInternalComponentsFactory(
         TestInternalComponentsFactory::IN_MEMORY);
   }
 
+  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;
+      sync_manager_.directory()->SetDownloadProgress(type, marker);
+    }
+  }
+
+  void SetInitialSyncEndedForType(ModelType type, bool value) {
+    sync_manager_.directory()->set_initial_sync_ended_for_type(type, value);
+  }
+
  private:
   // Needed by |sync_manager_|.
   MessageLoop message_loop_;
   // Needed by |sync_manager_|.
   ScopedTempDir temp_dir_;
   // Sync Id's for the roots of the enabled datatypes.
   std::map<ModelType, int64> type_roots_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   StrictMock<SyncNotifierMock>* sync_notifier_mock_;
 
@@ skipping 1595 matching lines @@
  public:
   SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
   virtual InternalComponentsFactory* GetFactory() OVERRIDE {
     scheduler_ = new MockSyncScheduler();
     return new ComponentsFactory(scheduler_);
   }
   MockSyncScheduler* scheduler_;
 };
 
 // Test that the configuration params are properly created and sent to
-// ScheduleConfigure. No callback should be invoked.
+// ScheduleConfigure. No callback should be invoked. Any disabled datatypes
+// should be purged (but only the types that were just disabled).

[tim (not reviewing), 2012/07/26 21:39:45]

I don't see a test that covers a case where both partial and disabled types need
to be purged.  Might be useful?  (Or maybe I missed it).

[Nicolas Zea, 2012/07/26 23:29:59]

The purging of both at startup is actually going away once Richard's refactor to
make the registrar aware of loaded data lands (it'll happens as part of the
first configuresyncer call). I added a TODO in the SyncManagerImpl to make that
clear.

That said, went ahead and added verification that partial types aren't purged
unless they're disabled, and updated the tests to also work once Richard's patch
lands.

 TEST_F(SyncManagerTestWithMockScheduler, BasicConfiguration) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
   ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
   ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&new_routing_info);
+  ModelTypeSet disabled_types(THEMES, SESSIONS);
+  new_routing_info.erase(THEMES);
+  new_routing_info.erase(SESSIONS);
 
   ConfigurationParams params;
   EXPECT_CALL(*scheduler_, Start(SyncScheduler::CONFIGURATION_MODE));
   EXPECT_CALL(*scheduler_, ScheduleConfiguration(_)).
       WillOnce(DoAll(SaveArg<0>(&params), Return(true)));
 
+  // Set data for all types.
+  for (ModelTypeSet::Iterator iter = ModelTypeSet::All().First(); iter.Good();
+       iter.Inc()) {
+    SetProgressMarkerForType(iter.Get(), true);
+    SetInitialSyncEndedForType(iter.Get(), true);
+  }
+
   CallbackCounter ready_task_counter, retry_task_counter;
   sync_manager_.ConfigureSyncer(
       reason,
       types_to_download,
       new_routing_info,
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&ready_task_counter)),
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&retry_task_counter)));
   EXPECT_EQ(0, ready_task_counter.times_called());
   EXPECT_EQ(0, retry_task_counter.times_called());
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
             params.source);
   EXPECT_TRUE(types_to_download.Equals(params.types_to_download));
   EXPECT_EQ(new_routing_info, params.routing_info);
+
+  // Verify only the disabled types were purged.
+  EXPECT_TRUE(Intersection(sync_manager_.InitialSyncEndedTypes(),
+                           disabled_types).Empty());
+  EXPECT_TRUE(disabled_types.Equals(
+      sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
 }
 
 // Test that the retry callback is invoked on configuration failure.
 TEST_F(SyncManagerTestWithMockScheduler, ConfigurationRetry) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
   ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
   ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&new_routing_info);
 
   ConfigurationParams params;
@@ skipping 53 matching lines @@
 
   // Ensure only bookmarks and nigori lost their progress marker. Preferences
   // should still have it.
   partial_types =
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All());
   EXPECT_TRUE(partial_types.Has(NIGORI));
   EXPECT_TRUE(partial_types.Has(BOOKMARKS));
   EXPECT_FALSE(partial_types.Has(PREFERENCES));
 }
 
+// Test CleanipDisabledTypes properly purges all disabled types as specified
+// by the previous and current enabled params.
+TEST_F(SyncManagerTest, CleanupDisabledTypes) {
+  ModelSafeRoutingInfo routing_info;
+  GetModelSafeRoutingInfo(&routing_info);
+  ModelTypeSet enabled_types = GetRoutingInfoTypes(routing_info);
+  ModelTypeSet disabled_types = Difference(ModelTypeSet::All(), enabled_types);
+
+  // Set data for all types.
+  for (ModelTypeSet::Iterator iter = ModelTypeSet::All().First(); iter.Good();
+       iter.Inc()) {
+    SetProgressMarkerForType(iter.Get(), true);
+    SetInitialSyncEndedForType(iter.Get(), true);
+  }
+
+  // Verify only the enabled types remain after cleanup.
+  sync_manager_.CleanupDisabledTypes(ModelTypeSet::All(), enabled_types);
+  EXPECT_TRUE(enabled_types.Equals(sync_manager_.InitialSyncEndedTypes()));
+  EXPECT_TRUE(disabled_types.Equals(
+      sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
+
+  // Disable some more types.
+  disabled_types.Put(BOOKMARKS);
+  disabled_types.Put(PREFERENCES);
+  ModelTypeSet new_enabled_types =
+      Difference(ModelTypeSet::All(), disabled_types);
+
+  // Verify only the non-disabled types remain after cleanup.
+  sync_manager_.CleanupDisabledTypes(enabled_types, new_enabled_types);
+  EXPECT_TRUE(new_enabled_types.Equals(sync_manager_.InitialSyncEndedTypes()));
+  EXPECT_TRUE(disabled_types.Equals(
+      sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
+}
+
 }  // namespace