Remove initial_sync_ended bits

sync/syncable/syncable_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.
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 442 matching lines @@
     return 1 == dir_->kernel_->metahandles_to_purge->count(metahandle);
   }
 
   void CheckPurgeEntriesWithTypeInSucceeded(ModelTypeSet types_to_purge,
                                             bool before_reload) {
     SCOPED_TRACE(testing::Message("Before reload: ") << before_reload);
     {
       ReadTransaction trans(FROM_HERE, dir_.get());
       MetahandleSet all_set;
       dir_->GetAllMetaHandles(&trans, &all_set);
-      EXPECT_EQ(3U, all_set.size());
+      EXPECT_EQ(4U, all_set.size());
       if (before_reload)
-        EXPECT_EQ(4U, dir_->kernel_->metahandles_to_purge->size());
+        EXPECT_EQ(6U, dir_->kernel_->metahandles_to_purge->size());
       for (MetahandleSet::iterator iter = all_set.begin();
            iter != all_set.end(); ++iter) {
         Entry e(&trans, GET_BY_HANDLE, *iter);
         const ModelType local_type = e.GetModelType();
         const ModelType server_type = e.GetServerModelType();
 
         // Note the dance around incrementing |it|, since we sometimes erase().
         if ((IsRealDataType(local_type) &&
              types_to_purge.Has(local_type)) ||
             (IsRealDataType(server_type) &&
              types_to_purge.Has(server_type))) {
           FAIL() << "Illegal type should have been deleted.";
         }
       }
     }
 
     for (ModelTypeSet::Iterator it = types_to_purge.First();
          it.Good(); it.Inc()) {
-      EXPECT_FALSE(dir_->initial_sync_ended_for_type(it.Get()));
+      EXPECT_FALSE(dir_->InitialSyncEndedForType(it.Get()));
     }
     EXPECT_FALSE(types_to_purge.Has(BOOKMARKS));
-    EXPECT_TRUE(dir_->initial_sync_ended_for_type(BOOKMARKS));
+    EXPECT_TRUE(dir_->InitialSyncEndedForType(BOOKMARKS));
   }
 
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   scoped_ptr<Directory> dir_;
   NullDirectoryChangeDelegate delegate_;
 
   // Creates an empty entry and sets the ID field to a default one.
   void CreateEntry(const std::string& entryname) {
     CreateEntry(entryname, TestIdFactory::FromNumber(-99));
@@ skipping 1045 matching lines @@
   FilePath file_path_;
 };
 
 TEST_F(OnDiskSyncableDirectoryTest, TestPurgeEntriesWithTypeIn) {
   sync_pb::EntitySpecifics bookmark_specs;
   sync_pb::EntitySpecifics autofill_specs;
   sync_pb::EntitySpecifics preference_specs;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
   AddDefaultFieldValue(PREFERENCES, &preference_specs);
   AddDefaultFieldValue(AUTOFILL, &autofill_specs);
-  dir_->set_initial_sync_ended_for_type(BOOKMARKS, true);
-  dir_->set_initial_sync_ended_for_type(PREFERENCES, true);
-  dir_->set_initial_sync_ended_for_type(AUTOFILL, true);
 
   ModelTypeSet types_to_purge(PREFERENCES, AUTOFILL);
 
   TestIdFactory id_factory;
   // Create some items for each type.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
+
+    // Make it look like these types have completed initial sync.
+    CreateTypeRoot(&trans, dir_.get(), BOOKMARKS);
+    CreateTypeRoot(&trans, dir_.get(), PREFERENCES);
+    CreateTypeRoot(&trans, dir_.get(), AUTOFILL);
+
+    // Add more nodes for this type.  Technically, they should be placed under
+    // the proper type root nodes but the assertions in this test won't notice
+    // if their parent isn't quite right.
     MutableEntry item1(&trans, CREATE, trans.root_id(), "Item");
     ASSERT_TRUE(item1.good());
     item1.Put(SPECIFICS, bookmark_specs);
     item1.Put(SERVER_SPECIFICS, bookmark_specs);
     item1.Put(IS_UNSYNCED, true);
 
     MutableEntry item2(&trans, CREATE_NEW_UPDATE_ITEM,
                        id_factory.NewServerId());
     ASSERT_TRUE(item2.good());
     item2.Put(SERVER_SPECIFICS, bookmark_specs);
@@ skipping 22 matching lines @@
     ASSERT_TRUE(item6.good());
     item6.Put(SERVER_SPECIFICS, autofill_specs);
     item6.Put(IS_UNAPPLIED_UPDATE, true);
   }
 
   dir_->SaveChanges();
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
     MetahandleSet all_set;
     GetAllMetaHandles(&trans, &all_set);
-    ASSERT_EQ(7U, all_set.size());
+    ASSERT_EQ(10U, all_set.size());
   }
 
   dir_->PurgeEntriesWithTypeIn(types_to_purge);
 
   // We first query the in-memory data, and then reload the directory (without
   // saving) to verify that disk does not still have the data.
   CheckPurgeEntriesWithTypeInSucceeded(types_to_purge, true);
   SaveAndReloadDir();
   CheckPurgeEntriesWithTypeInSucceeded(types_to_purge, false);
 }
 
 TEST_F(OnDiskSyncableDirectoryTest, TestShareInfo) {
-  dir_->set_initial_sync_ended_for_type(AUTOFILL, true);
   dir_->set_store_birthday("Jan 31st");
   dir_->SetNotificationState("notification_state");
   const char* const bag_of_chips_array = "\0bag of chips";
   const std::string bag_of_chips_string =
       std::string(bag_of_chips_array, sizeof(bag_of_chips_array));
   dir_->set_bag_of_chips(bag_of_chips_string);
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
-    EXPECT_TRUE(dir_->initial_sync_ended_for_type(AUTOFILL));
-    EXPECT_FALSE(dir_->initial_sync_ended_for_type(BOOKMARKS));
     EXPECT_EQ("Jan 31st", dir_->store_birthday());
     EXPECT_EQ("notification_state", dir_->GetNotificationState());
     EXPECT_EQ(bag_of_chips_string, dir_->bag_of_chips());
   }
   dir_->set_store_birthday("April 10th");
   dir_->SetNotificationState("notification_state2");
   const char* const bag_of_chips2_array = "\0bag of chips2";
   const std::string bag_of_chips2_string =
       std::string(bag_of_chips2_array, sizeof(bag_of_chips2_array));
   dir_->set_bag_of_chips(bag_of_chips2_string);
   dir_->SaveChanges();
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
-    EXPECT_TRUE(dir_->initial_sync_ended_for_type(AUTOFILL));
-    EXPECT_FALSE(dir_->initial_sync_ended_for_type(BOOKMARKS));
     EXPECT_EQ("April 10th", dir_->store_birthday());
     EXPECT_EQ("notification_state2", dir_->GetNotificationState());
     EXPECT_EQ(bag_of_chips2_string, dir_->bag_of_chips());
   }
   dir_->SetNotificationState("notification_state2");
   // Restore the directory from disk.  Make sure that nothing's changed.
   SaveAndReloadDir();
   {
     ReadTransaction trans(FROM_HERE, dir_.get());
-    EXPECT_TRUE(dir_->initial_sync_ended_for_type(AUTOFILL));
-    EXPECT_FALSE(dir_->initial_sync_ended_for_type(BOOKMARKS));
     EXPECT_EQ("April 10th", dir_->store_birthday());
     EXPECT_EQ("notification_state2", dir_->GetNotificationState());
     EXPECT_EQ(bag_of_chips2_string, dir_->bag_of_chips());
   }
 }
 
 TEST_F(OnDiskSyncableDirectoryTest,
        TestSimpleFieldsPreservedDuringSaveChanges) {
   Id update_id = TestIdFactory::FromNumber(1);
   Id create_id;
@@ skipping 471 matching lines @@
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable
 }  // namespace syncer