Remove initial_sync_ended bits

sync/engine/apply_control_data_updates_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 "base/format_macros.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "sync/engine/apply_control_data_updates.h"
 #include "sync/engine/syncer.h"
@@ skipping 49 matching lines @@
 
 // Verify that applying a nigori node sets initial sync ended properly,
 // updates the set of encrypted types, and updates the cryptographer.
 TEST_F(ApplyControlDataUpdatesTest, NigoriUpdate) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types;
   encrypted_types.PutAll(SyncEncryptionHandler::SensitiveTypes());
 
-  // We start with initial_sync_ended == false.  This is wrong, since we would
-  // have no nigori node if that were the case.  However, it makes it easier to
-  // verify that ApplyControlDataUpdates sets initial_sync_ended correctly.
-  EXPECT_FALSE(directory()->initial_sync_ended_types().Has(NIGORI));
-
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_cryptographer(cryptographer->encryptor());
   KeyParams params = {"localhost", "dummy", "foobar"};
   other_cryptographer.AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
   other_cryptographer.GetKeys(nigori->mutable_encryption_keybag());
   nigori->set_encrypt_everything(true);
   entry_factory_->CreateUnappliedNewItem(
       ModelTypeToRootTag(NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ApplyControlDataUpdates(session());
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // Create some local unsynced and unencrypted data. Apply a nigori update that
 // turns on encryption for the unsynced data. Ensure we properly encrypt the
 // data as part of the nigori update. Apply another nigori update with no
 // changes. Ensure we ignore already-encrypted unsynced data and that nothing
 // breaks.
 TEST_F(ApplyControlDataUpdatesTest, EncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
@@ skipping 262 matching lines @@
           entry_factory_->GetLocalSpecificsForItem(nigori_handle).
               nigori().encryption_keybag()));
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().encrypt_everything());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // Verify we handle a nigori node conflict by merging encryption keys and
 // types, but preserve the custom passphrase state of the server.
 // Initial sync ended should be set.
 TEST_F(ApplyControlDataUpdatesTest,
        NigoriConflictPendingKeysLocalEncryptEverythingCustom) {
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
@@ skipping 58 matching lines @@
           entry_factory_->GetLocalSpecificsForItem(nigori_handle).
               nigori().encryption_keybag()));
   EXPECT_FALSE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().encrypt_everything());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // If the conflicting nigori has a subset of the local keys, the conflict
 // resolution should preserve the full local keys. Initial sync ended should be
 // set.
 TEST_F(ApplyControlDataUpdatesTest,
        NigoriConflictOldKeys) {
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
@@ skipping 51 matching lines @@
           entry_factory_->GetLocalSpecificsForItem(nigori_handle).
               nigori().encryption_keybag()));
   EXPECT_FALSE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().encrypt_everything());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // If both nigoris are migrated, but we also set a custom passphrase locally,
 // the local nigori should be preserved.
 TEST_F(ApplyControlDataUpdatesTest,
        NigoriConflictBothMigratedLocalCustom) {
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
   KeyParams old_params = {"localhost", "dummy", "old"};
@@ skipping 62 matching lines @@
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().encrypt_everything());
   EXPECT_EQ(sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE,
             entry_factory_->GetLocalSpecificsForItem(nigori_handle).
                 nigori().passphrase_type());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // If both nigoris are migrated, but a custom passphrase with a new key was
 // set remotely, the remote nigori should be preserved.
 TEST_F(ApplyControlDataUpdatesTest,
        NigoriConflictBothMigratedServerCustom) {
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
   KeyParams old_params = {"localhost", "dummy", "old"};
@@ skipping 63 matching lines @@
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().encrypt_everything());
   EXPECT_EQ(sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE,
             entry_factory_->GetLocalSpecificsForItem(nigori_handle).
                 nigori().passphrase_type());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // If the local nigori is migrated but the server is not, preserve the local
 // nigori.
 TEST_F(ApplyControlDataUpdatesTest,
        NigoriConflictLocalMigrated) {
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
   KeyParams old_params = {"localhost", "dummy", "old"};
@@ skipping 59 matching lines @@
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().encrypt_everything());
   EXPECT_EQ(sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE,
             entry_factory_->GetLocalSpecificsForItem(nigori_handle).
                 nigori().passphrase_type());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->GetEncryptedTypes(&trans)
         .Equals(ModelTypeSet::All()));
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // If the server nigori is migrated but the local is not, preserve the server
 // nigori.
 TEST_F(ApplyControlDataUpdatesTest,
        NigoriConflictServerMigrated) {
   Cryptographer* cryptographer;
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
   KeyParams old_params = {"localhost", "dummy", "old"};
@@ skipping 64 matching lines @@
               nigori().encryption_keybag()));
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().keybag_is_frozen());
   EXPECT_TRUE(entry_factory_->GetLocalSpecificsForItem(nigori_handle).
       nigori().has_keystore_decryptor_token());
   EXPECT_EQ(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE,
             entry_factory_->GetLocalSpecificsForItem(nigori_handle).
                 nigori().passphrase_type());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
-    EXPECT_TRUE(directory()->initial_sync_ended_types().Has(NIGORI));
   }
 }
 
 // Check that we can apply a simple control datatype node successfully.
 TEST_F(ApplyControlDataUpdatesTest, ControlApply) {
-  EXPECT_FALSE(directory()->initial_sync_ended_types().Has(EXPERIMENTS));
-
   std::string experiment_id = "experiment";
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(true);
   int64 experiment_handle = entry_factory_->CreateUnappliedNewItem(
       experiment_id, specifics, false);
   ApplyControlDataUpdates(session());
 
-  EXPECT_TRUE(directory()->initial_sync_ended_types().Has(EXPERIMENTS));
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(experiment_handle));
   EXPECT_TRUE(
       entry_factory_->GetLocalSpecificsForItem(experiment_handle).
           experiments().keystore_encryption().enabled());
 }
 
 // Verify that we apply top level folders before their children.
 TEST_F(ApplyControlDataUpdatesTest, ControlApplyParentBeforeChild) {
-  EXPECT_FALSE(directory()->initial_sync_ended_types().Has(EXPERIMENTS));
-
   std::string parent_id = "parent";
   std::string experiment_id = "experiment";
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(true);
   int64 experiment_handle = entry_factory_->CreateUnappliedNewItemWithParent(
       experiment_id, specifics, parent_id);
   int64 parent_handle = entry_factory_->CreateUnappliedNewItem(
       parent_id, specifics, true);
   ApplyControlDataUpdates(session());
 
-  EXPECT_TRUE(directory()->initial_sync_ended_types().Has(EXPERIMENTS));
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(parent_handle));
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(experiment_handle));
   EXPECT_TRUE(
       entry_factory_->GetLocalSpecificsForItem(experiment_handle).
           experiments().keystore_encryption().enabled());
 }
 
 // Verify that we handle control datatype conflicts by preserving the server
 // data.
 TEST_F(ApplyControlDataUpdatesTest, ControlConflict) {
-  EXPECT_FALSE(directory()->initial_sync_ended_types().Has(EXPERIMENTS));
-
   std::string experiment_id = "experiment";
   sync_pb::EntitySpecifics local_specifics, server_specifics;
   server_specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(true);
   local_specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(false);
   int64 experiment_handle = entry_factory_->CreateSyncedItem(
       experiment_id, EXPERIMENTS, false);
   entry_factory_->SetServerSpecificsForItem(experiment_handle,
                                             server_specifics);
   entry_factory_->SetLocalSpecificsForItem(experiment_handle,
                                            local_specifics);
   ApplyControlDataUpdates(session());
 
-  EXPECT_TRUE(directory()->initial_sync_ended_types().Has(EXPERIMENTS));
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(experiment_handle));
   EXPECT_TRUE(
       entry_factory_->GetLocalSpecificsForItem(experiment_handle).
           experiments().keystore_encryption().enabled());
 }
 
 }  // namespace syncer