[Sync] Move ModelType and related classes to 'syncer' namespace

sync/engine/apply_updates_command_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/format_macros.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
@@ skipping 21 matching lines @@
 using sessions::SyncSession;
 using std::string;
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::UNITTEST;
 using syncable::WriteTransaction;
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
-  AddDefaultFieldValue(syncable::BOOKMARKS, &result);
+  AddDefaultFieldValue(syncer::BOOKMARKS, &result);
   return result;
 }
 } // namespace
 
 // A test fixture for tests exercising ApplyUpdatesCommand.
 class ApplyUpdatesCommandTest : public SyncerCommandTest {
  public:
  protected:
   ApplyUpdatesCommandTest() {}
   virtual ~ApplyUpdatesCommandTest() {}
 
   virtual void SetUp() {
     workers()->clear();
     mutable_routing_info()->clear();
     workers()->push_back(
         make_scoped_refptr(new FakeModelWorker(GROUP_UI)));
     workers()->push_back(
         make_scoped_refptr(new FakeModelWorker(GROUP_PASSWORD)));
-    (*mutable_routing_info())[syncable::BOOKMARKS] = GROUP_UI;
-    (*mutable_routing_info())[syncable::PASSWORDS] = GROUP_PASSWORD;
-    (*mutable_routing_info())[syncable::NIGORI] = GROUP_PASSIVE;
+    (*mutable_routing_info())[syncer::BOOKMARKS] = GROUP_UI;
+    (*mutable_routing_info())[syncer::PASSWORDS] = GROUP_PASSWORD;
+    (*mutable_routing_info())[syncer::NIGORI] = GROUP_PASSIVE;
     SyncerCommandTest::SetUp();
     entry_factory_.reset(new TestEntryFactory(directory()));
     ExpectNoGroupsToChange(apply_updates_command_);
   }
 
   ApplyUpdatesCommand apply_updates_command_;
   FakeEncryptor encryptor_;
   TestIdFactory id_factory_;
   scoped_ptr<TestEntryFactory> entry_factory_;
  private:
@@ skipping 57 matching lines @@
       << "Simple update shouldn't result in conflicts, even if out-of-order";
   EXPECT_EQ(5, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "All updates should have been successfully applied";
 }
 
 // Runs the ApplyUpdatesCommand on an item that has both local and remote
 // modifications (IS_UNSYNCED and IS_UNAPPLIED_UPDATE).  We expect the command
 // to detect that this update can't be applied because it is in a CONFLICT
 // state.
 TEST_F(ApplyUpdatesCommandTest, SimpleConflict) {
-  entry_factory_->CreateUnappliedAndUnsyncedItem(
-      "item", syncable::BOOKMARKS);
+  entry_factory_->CreateUnappliedAndUnsyncedItem("item", syncer::BOOKMARKS);
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(1, status->conflict_progress()->SimpleConflictingItemsSize())
       << "Unsynced and unapplied item should be a simple conflict";
 }
 
 // Runs the ApplyUpdatesCommand on an item that has both local and remote
 // modifications *and* the remote modification cannot be applied without
 // violating the tree constraints.  We expect the command to detect that this
 // update can't be applied and that this situation can't be resolved with the
 // simple conflict processing logic; it is in a CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
   int64 handle = entry_factory_->CreateUnappliedAndUnsyncedItem(
-      "orphaned_by_server", syncable::BOOKMARKS);
+      "orphaned_by_server", syncer::BOOKMARKS);
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     entry.Put(syncable::SERVER_PARENT_ID,
               id_factory_.MakeServer("bogus_parent"));
   }
@@ skipping 17 matching lines @@
 // Runs the ApplyUpdatesCommand on an item with remote modifications that would
 // create a directory loop if the update were applied.  We expect the command to
 // detect that this update can't be applied because it is in a
 // CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDirectoryLoop) {
   // Item 'X' locally has parent of 'root'.  Server is updating it to have
   // parent of 'Y'.
   {
     // Create it as a child of root node.
     int64 handle = entry_factory_->CreateSyncedItem(
-        "X", syncable::BOOKMARKS, true);
+        "X", syncer::BOOKMARKS, true);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Re-parent from root to "Y"
     entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_PARENT_ID, id_factory_.MakeServer("Y"));
   }
 
   // Item 'Y' is child of 'X'.
   entry_factory_->CreateUnsyncedItem(
       id_factory_.MakeServer("Y"), id_factory_.MakeServer("X"), "Y", true,
-      syncable::BOOKMARKS, NULL);
+      syncer::BOOKMARKS, NULL);
 
   // If the server's update were applied, we would have X be a child of Y, and Y
   // as a child of X.  That's a directory loop.  The UpdateApplicator should
   // prevent the update from being applied and note that this is a hierarchy
   // conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
 
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize());
 
   // This should count as a hierarchy conflict.
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize());
 }
 
 // Runs the ApplyUpdatesCommand on a directory where the server sent us an
 // update to add a child to a locally deleted (and unsynced) parent.  We expect
 // the command to not apply the update and to indicate the update is in a
 // CONFLICT_HIERARCHY state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
   entry_factory_->CreateUnsyncedItem(
       Id::CreateFromServerId("parent"), id_factory_.root(),
-      "parent", true, syncable::BOOKMARKS, &parent_handle);
+      "parent", true, syncer::BOOKMARKS, &parent_handle);
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, parent_handle);
     entry.Put(syncable::IS_DEL, true);
   }
 
   // Create an incoming child from the server.
   entry_factory_->CreateUnappliedNewItemWithParent(
       "child", DefaultBookmarkSpecifics(), "parent");
 
@@ skipping 15 matching lines @@
 
 // Runs the ApplyUpdatesCommand on a directory where the server is trying to
 // delete a folder that has a recently added (and unsynced) child.  We expect
 // the command to not apply the update because it is in a CONFLICT_HIERARCHY
 // state.
 TEST_F(ApplyUpdatesCommandTest, HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted directory.
   {
     // Create it as a child of root node.
     int64 handle = entry_factory_->CreateSyncedItem(
-        "parent", syncable::BOOKMARKS, true);
+        "parent", syncer::BOOKMARKS, true);
 
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Delete it on the server.
     entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_PARENT_ID, id_factory_.root());
     entry.Put(syncable::SERVER_IS_DEL, true);
   }
 
   // Create a local child of the server-deleted directory.
   entry_factory_->CreateUnsyncedItem(
       id_factory_.MakeServer("child"), id_factory_.MakeServer("parent"),
-      "child", false, syncable::BOOKMARKS, NULL);
+      "child", false, syncer::BOOKMARKS, NULL);
 
   // The server's request to delete the directory must be ignored, otherwise our
   // unsynced new child would be orphaned.  This is a hierarchy conflict.
 
   ExpectGroupToChange(apply_updates_command_, GROUP_UI);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_UI);
 
@@ skipping 95 matching lines @@
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
       << "No update should be in conflict because they're all decryptable";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The updates that can be decrypted should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
-  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
+  AddDefaultFieldValue(syncer::BOOKMARKS, &encrypted_bookmark);
   string root_server_id = syncable::GetNullId().GetServerId();
   entry_factory_->CreateUnappliedNewItemWithParent(
       "folder", encrypted_bookmark, root_server_id);
   entry_factory_->CreateUnappliedNewItem("item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.mutable_password();
   entry_factory_->CreateUnappliedNewItem("item3", encrypted_password, false);
 
   ExpectGroupsToChange(apply_updates_command_, GROUP_UI, GROUP_PASSWORD);
   apply_updates_command_.ExecuteImpl(session());
@@ skipping 88 matching lines @@
         << "conflict";
     EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The undecryptable password update shouldn't be applied";
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdate) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.Put(syncable::PASSWORDS);
-  encrypted_types.Put(syncable::NIGORI);
+  syncer::ModelTypeSet encrypted_types;
+  encrypted_types.Put(syncer::PASSWORDS);
+  encrypted_types.Put(syncer::NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_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_encrypted());
   nigori->set_encrypt_bookmarks(true);
-  encrypted_types.Put(syncable::BOOKMARKS);
+  encrypted_types.Put(syncer::BOOKMARKS);
   entry_factory_->CreateUnappliedNewItem(
-      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
+      syncer::ModelTypeToRootTag(syncer::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   EXPECT_TRUE(
-      cryptographer->GetEncryptedTypes()
-          .Equals(syncable::ModelTypeSet::All()));
+      cryptographer->GetEncryptedTypes().Equals(syncer::ModelTypeSet::All()));
 }
 
 TEST_F(ApplyUpdatesCommandTest, NigoriUpdateForDisabledTypes) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.Put(syncable::PASSWORDS);
-  encrypted_types.Put(syncable::NIGORI);
+  syncer::ModelTypeSet encrypted_types;
+  encrypted_types.Put(syncer::PASSWORDS);
+  encrypted_types.Put(syncer::NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
   }
 
   // Nigori node updates should update the Cryptographer.
   Cryptographer other_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_encrypted());
   nigori->set_encrypt_sessions(true);
   nigori->set_encrypt_themes(true);
-  encrypted_types.Put(syncable::SESSIONS);
-  encrypted_types.Put(syncable::THEMES);
+  encrypted_types.Put(syncer::SESSIONS);
+  encrypted_types.Put(syncer::THEMES);
   entry_factory_->CreateUnappliedNewItem(
-      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
+      syncer::ModelTypeToRootTag(syncer::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->mutable_status_controller();
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   ASSERT_TRUE(status->update_progress());
   EXPECT_EQ(1, status->update_progress()->AppliedUpdatesSize())
       << "All updates should have been attempted";
   ASSERT_TRUE(status->conflict_progress());
   EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
       << "The nigori update shouldn't be in conflict";
   EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
       << "The nigori update should be applied";
 
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   EXPECT_TRUE(
-      cryptographer->GetEncryptedTypes()
-          .Equals(syncable::ModelTypeSet::All()));
+      cryptographer->GetEncryptedTypes().Equals(syncer::ModelTypeSet::All()));
 }
 
 // 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(ApplyUpdatesCommandTest, EncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.Put(syncable::PASSWORDS);
-  encrypted_types.Put(syncable::NIGORI);
+  syncer::ModelTypeSet encrypted_types;
+  encrypted_types.Put(syncer::PASSWORDS);
+  encrypted_types.Put(syncer::NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
 
     // With default encrypted_types, this should be true.
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_TRUE(handles.empty());
   }
 
   // Create unsynced bookmarks without encryption.
   // First item is a folder
   Id folder_id = id_factory_.NewLocalId();
   entry_factory_->CreateUnsyncedItem(folder_id, id_factory_.root(), "folder",
-                                     true, syncable::BOOKMARKS, NULL);
+                                     true, syncer::BOOKMARKS, NULL);
   // Next five items are children of the folder
   size_t i;
   size_t batch_s = 5;
   for (i = 0; i < batch_s; ++i) {
     entry_factory_->CreateUnsyncedItem(id_factory_.NewLocalId(), folder_id,
                                        base::StringPrintf("Item %"PRIuS"", i),
-                                       false, syncable::BOOKMARKS, NULL);
+                                       false, syncer::BOOKMARKS, NULL);
   }
   // Next five items are children of the root.
   for (; i < 2*batch_s; ++i) {
     entry_factory_->CreateUnsyncedItem(
         id_factory_.NewLocalId(), id_factory_.root(),
         base::StringPrintf("Item %"PRIuS"", i), false,
-        syncable::BOOKMARKS, NULL);
+        syncer::BOOKMARKS, NULL);
   }
 
   KeyParams params = {"localhost", "dummy", "foobar"};
   cryptographer->AddKey(params);
   sync_pb::EntitySpecifics specifics;
   sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
   cryptographer->GetKeys(nigori->mutable_encrypted());
   nigori->set_encrypt_bookmarks(true);
-  encrypted_types.Put(syncable::BOOKMARKS);
+  encrypted_types.Put(syncer::BOOKMARKS);
   entry_factory_->CreateUnappliedNewItem(
-      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
+      syncer::ModelTypeToRootTag(syncer::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
 
   {
     // Ensure we have unsynced nodes that aren't properly encrypted.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
@@ skipping 17 matching lines @@
     EXPECT_EQ(1, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The nigori update should be applied";
   }
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // If ProcessUnsyncedChangesForEncryption worked, all our unsynced changes
     // should be encrypted now.
-    EXPECT_TRUE(syncable::ModelTypeSet::All().Equals(
-                cryptographer->GetEncryptedTypes()));
+    EXPECT_TRUE(syncer::ModelTypeSet::All().Equals(
+        cryptographer->GetEncryptedTypes()));
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 
   // Simulate another nigori update that doesn't change anything.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::GET_BY_SERVER_TAG,
-                       syncable::ModelTypeToRootTag(syncable::NIGORI));
+                       syncer::ModelTypeToRootTag(syncer::NIGORI));
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::SERVER_VERSION, entry_factory_->GetNextRevision());
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
   }
   ExpectGroupToChange(apply_updates_command_, GROUP_PASSIVE);
   apply_updates_command_.ExecuteImpl(session());
   {
     sessions::StatusController* status = session()->mutable_status_controller();
     sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
     ASSERT_TRUE(status->update_progress());
     EXPECT_EQ(2, status->update_progress()->AppliedUpdatesSize())
         << "All updates should have been attempted";
     ASSERT_TRUE(status->conflict_progress());
     EXPECT_EQ(0, status->conflict_progress()->SimpleConflictingItemsSize())
         << "No updates should be in conflict";
     EXPECT_EQ(0, status->conflict_progress()->EncryptionConflictingItemsSize())
         << "No updates should be in conflict";
     EXPECT_EQ(2, status->update_progress()->SuccessfullyAppliedUpdateCount())
         << "The nigori update should be applied";
   }
   EXPECT_FALSE(cryptographer->has_pending_keys());
   EXPECT_TRUE(cryptographer->is_ready());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // All our changes should still be encrypted.
-    EXPECT_TRUE(syncable::ModelTypeSet::All().Equals(
+    EXPECT_TRUE(syncer::ModelTypeSet::All().Equals(
         cryptographer->GetEncryptedTypes()));
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 TEST_F(ApplyUpdatesCommandTest, CannotEncryptUnsyncedChanges) {
   // Storing the cryptographer separately is bad, but for this test we
   // know it's safe.
   Cryptographer* cryptographer;
-  syncable::ModelTypeSet encrypted_types;
-  encrypted_types.Put(syncable::PASSWORDS);
-  encrypted_types.Put(syncable::NIGORI);
+  syncer::ModelTypeSet encrypted_types;
+  encrypted_types.Put(syncer::PASSWORDS);
+  encrypted_types.Put(syncer::NIGORI);
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(encrypted_types));
 
     // With default encrypted_types, this should be true.
     EXPECT_TRUE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_TRUE(handles.empty());
   }
 
   // Create unsynced bookmarks without encryption.
   // First item is a folder
   Id folder_id = id_factory_.NewLocalId();
   entry_factory_->CreateUnsyncedItem(
       folder_id, id_factory_.root(), "folder", true,
-      syncable::BOOKMARKS, NULL);
+      syncer::BOOKMARKS, NULL);
   // Next five items are children of the folder
   size_t i;
   size_t batch_s = 5;
   for (i = 0; i < batch_s; ++i) {
     entry_factory_->CreateUnsyncedItem(id_factory_.NewLocalId(), folder_id,
                                        base::StringPrintf("Item %"PRIuS"", i),
-                                       false, syncable::BOOKMARKS, NULL);
+                                       false, syncer::BOOKMARKS, NULL);
   }
   // Next five items are children of the root.
   for (; i < 2*batch_s; ++i) {
     entry_factory_->CreateUnsyncedItem(
         id_factory_.NewLocalId(), id_factory_.root(),
         base::StringPrintf("Item %"PRIuS"", i), false,
-        syncable::BOOKMARKS, NULL);
+        syncer::BOOKMARKS, NULL);
   }
 
   // We encrypt with new keys, triggering the local cryptographer to be unready
   // and unable to decrypt data (once updated).
   Cryptographer other_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_encrypted());
   nigori->set_encrypt_bookmarks(true);
-  encrypted_types.Put(syncable::BOOKMARKS);
+  encrypted_types.Put(syncer::BOOKMARKS);
   entry_factory_->CreateUnappliedNewItem(
-      syncable::ModelTypeToRootTag(syncable::NIGORI), specifics, true);
+      syncer::ModelTypeToRootTag(syncer::NIGORI), specifics, true);
   EXPECT_FALSE(cryptographer->has_pending_keys());
 
   {
     // Ensure we have unsynced nodes that aren't properly encrypted.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
@@ skipping 17 matching lines @@
       << "The nigori update should be applied";
   EXPECT_FALSE(cryptographer->is_ready());
   EXPECT_TRUE(cryptographer->has_pending_keys());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // Since we have pending keys, we would have failed to encrypt, but the
     // cryptographer should be updated.
     EXPECT_FALSE(VerifyUnsyncedChangesAreEncrypted(&trans, encrypted_types));
     EXPECT_TRUE(cryptographer->GetEncryptedTypes().Equals(
-                syncable::ModelTypeSet().All()));
+                syncer::ModelTypeSet().All()));
     EXPECT_FALSE(cryptographer->is_ready());
     EXPECT_TRUE(cryptographer->has_pending_keys());
 
     Syncer::UnsyncedMetaHandles handles;
     GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 }  // namespace syncer