Enable Null Syncable ID which is different than Root ID.

sync/engine/directory_update_handler_unittest.cc

 // Copyright 2014 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 "sync/engine/directory_update_handler.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "sync/engine/syncer_proto_util.h"
@@ skipping 11 matching lines @@
 #include "sync/syncable/syncable_read_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "sync/test/engine/test_syncable_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
+using syncable::Id;
 using syncable::UNITTEST;
 
 static const int64 kDefaultVersion = 1000;
 
 // A test harness for tests that focus on processing updates.
 //
 // Update processing is what occurs when we first download updates.  It converts
 // the received protobuf message into information in the syncable::Directory.
 // Any invalid or redundant updates will be dropped at this point.
 class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
@@ skipping 34 matching lines @@
       DirectoryUpdateHandler* handler,
       const sync_pb::DataTypeProgressMarker& progress);
 
   scoped_refptr<FakeModelWorker> ui_worker() {
     return ui_worker_;
   }
 
   bool EntryExists(const std::string& id) {
     syncable::ReadTransaction trans(FROM_HERE, dir());
     syncable::Entry e(&trans, syncable::GET_BY_ID,
-                      syncable::Id::CreateFromServerId(id));
+                      Id::CreateFromServerId(id));
     return e.good() && !e.GetIsDel();
   }
 
  protected:
   // Used in the construction of DirectoryTypeDebugInfoEmitters.
   ObserverList<TypeDebugInfoObserver> type_observers_;
 
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
@@ skipping 32 matching lines @@
 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ==";
 
 // Test that the bookmark tag is set on newly downloaded items.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Add a bookmark item to the update message.
-  std::string root = syncable::GetNullId().GetServerId();
-  syncable::Id server_id = syncable::Id::CreateFromServerId("b1");
+  std::string root = Id::GetRoot().GetServerId();
+  Id server_id = Id::CreateFromServerId("b1");
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_originator_cache_guid(
       std::string(kCacheGuid, arraysize(kCacheGuid)-1));
-  syncable::Id client_id = syncable::Id::CreateFromClientString("-2");
+  Id client_id = Id::CreateFromClientString("-2");
   e->set_originator_client_item_id(client_id.GetServerId());
   e->set_position_in_parent(0);
 
   // Add it to the applicable updates list.
   SyncEntityList bookmark_updates;
   bookmark_updates.push_back(e.get());
 
   // Process the update.
   UpdateSyncEntities(&handler, bookmark_updates, &status);
 
@@ skipping 12 matching lines @@
 
 // Test the receipt of a type root node.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ReceiveServerCreatedBookmarkFolders) {
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Create an update that mimics the bookmark root.
-  syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
-  std::string root = syncable::GetNullId().GetServerId();
+  Id server_id = Id::CreateFromServerId("xyz");
+  std::string root = Id::GetRoot().GetServerId();
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_server_defined_unique_tag("google_chrome_bookmarks");
   e->set_folder(true);
 
   // Add it to the applicable updates list.
   SyncEntityList bookmark_updates;
   bookmark_updates.push_back(e.get());
 
   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
@@ skipping 12 matching lines @@
   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
 }
 
 // Test the receipt of a non-bookmark item.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
   DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_);
   DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
-  std::string root = syncable::GetNullId().GetServerId();
-  syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
+  std::string root = Id::GetRoot().GetServerId();
+  Id server_id = Id::CreateFromServerId("xyz");
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, AUTOFILL);
   e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I=");
 
   // Add it to the applicable updates list.
   SyncEntityList autofill_updates;
   autofill_updates.push_back(e.get());
 
   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
 
@@ skipping 40 matching lines @@
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   context.set_context("context");
   context.set_version(1);
 
   scoped_ptr<sync_pb::SyncEntity> type_root =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")),
-                   syncable::GetNullId().GetServerId(),
-                   SYNCED_NOTIFICATIONS);
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("root")),
+                   Id::GetRoot().GetServerId(), SYNCED_NOTIFICATIONS);
   type_root->set_server_defined_unique_tag(
       ModelTypeToRootTag(SYNCED_NOTIFICATIONS));
   type_root->set_folder(true);
 
   scoped_ptr<sync_pb::SyncEntity> e1 =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")),
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")),
                    type_root->id_string(),
                    SYNCED_NOTIFICATIONS);
 
   scoped_ptr<sync_pb::SyncEntity> e2 =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e2")),
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e2")),
                    type_root->id_string(),
                    SYNCED_NOTIFICATIONS);
   e2->set_version(kDefaultVersion + 100);
 
   // Add to the applicable updates list.
   SyncEntityList updates;
   updates.push_back(type_root.get());
   updates.push_back(e1.get());
   updates.push_back(e2.get());
 
@@ skipping 30 matching lines @@
   progress.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
 
   sync_pb::DataTypeContext old_context;
   old_context.set_version(1);
   old_context.set_context("data");
   old_context.set_data_type_id(field_number);
 
   scoped_ptr<sync_pb::SyncEntity> type_root =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")),
-                   syncable::GetNullId().GetServerId(),
-                   SYNCED_NOTIFICATIONS);
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("root")),
+                   Id::GetRoot().GetServerId(), SYNCED_NOTIFICATIONS);
   type_root->set_server_defined_unique_tag(
       ModelTypeToRootTag(SYNCED_NOTIFICATIONS));
   type_root->set_folder(true);
   scoped_ptr<sync_pb::SyncEntity> e1 =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")),
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")),
                    type_root->id_string(),
                    SYNCED_NOTIFICATIONS);
 
   SyncEntityList updates;
   updates.push_back(type_root.get());
   updates.push_back(e1.get());
 
   // The first response should be processed fine.
   EXPECT_EQ(SYNCER_OK,
             handler.ProcessGetUpdatesResponse(
@@ skipping 10 matching lines @@
         &trans, SYNCED_NOTIFICATIONS, &dir_context);
     EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString());
   }
 
   sync_pb::DataTypeContext new_context;
   new_context.set_version(0);
   new_context.set_context("old");
   new_context.set_data_type_id(field_number);
 
   scoped_ptr<sync_pb::SyncEntity> e2 =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e2")),
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e2")),
                    type_root->id_string(),
                    SYNCED_NOTIFICATIONS);
   updates.clear();
   updates.push_back(e2.get());
 
   // The second response, with an old context version, should result in an
   // error and the updates should be dropped.
   EXPECT_EQ(DATATYPE_TRIGGERED_RETRY,
             handler.ProcessGetUpdatesResponse(
                 progress, new_context, updates, &status));
@@ skipping 22 matching lines @@
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
   context.set_context("context");
   context.set_version(1);
 
   scoped_ptr<sync_pb::SyncEntity> type_root =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")),
-                   syncable::GetNullId().GetServerId(),
-                   ARTICLES);
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("root")),
+                   Id::GetRoot().GetServerId(), ARTICLES);
   type_root->set_server_defined_unique_tag(ModelTypeToRootTag(ARTICLES));
   type_root->set_folder(true);
 
   scoped_ptr<sync_pb::SyncEntity> e1 =
-      CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")),
+      CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")),
                    type_root->id_string(),
                    ARTICLES);
   sync_pb::AttachmentIdProto* attachment_id = e1->add_attachment_id();
   *attachment_id = CreateAttachmentIdProto();
 
   SyncEntityList updates;
   updates.push_back(type_root.get());
   updates.push_back(e1.get());
 
   // Process and apply updates.
   EXPECT_EQ(
       SYNCER_OK,
       handler.ProcessGetUpdatesResponse(progress, context, updates, &status));
   handler.ApplyUpdates(&status);
 
   ASSERT_TRUE(EntryExists(type_root->id_string()));
   ASSERT_TRUE(EntryExists(e1->id_string()));
   {
     syncable::ReadTransaction trans(FROM_HERE, dir());
     syncable::Entry e(&trans,
                       syncable::GET_BY_ID,
-                      syncable::Id::CreateFromServerId(e1->id_string()));
+                      Id::CreateFromServerId(e1->id_string()));
 
     // See that the attachment_metadata is correct.
     sync_pb::AttachmentMetadata attachment_metadata = e.GetAttachmentMetadata();
     ASSERT_EQ(1, attachment_metadata.record_size());
     ASSERT_EQ(attachment_id->SerializeAsString(),
               attachment_metadata.record(0).id().SerializeAsString());
     ASSERT_TRUE(attachment_metadata.record(0).is_on_server());
 
     // See that attachment_metadata and server_attachment_metadata are equal.
     ASSERT_EQ(attachment_metadata.SerializeAsString(),
@@ skipping 109 matching lines @@
   sync_pb::EntitySpecifics result;
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 } // namespace
 
 // Test update application for a few bookmark items.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
   sessions::StatusController status;
 
-  std::string root_server_id = syncable::GetNullId().GetServerId();
+  std::string root_server_id = Id::GetRoot().GetServerId();
   int64 parent_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "parent", DefaultBookmarkSpecifics(), root_server_id);
   int64 child_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "child", DefaultBookmarkSpecifics(), "parent");
 
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counter = GetBookmarksUpdateCounters();
@@ skipping 17 matching lines @@
     EXPECT_FALSE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
     EXPECT_FALSE(child.GetIsUnappliedUpdate());
   }
 }
 
 // Test that the applicator can handle updates delivered out of order.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        BookmarkChildrenBeforeParent) {
   // Start with some bookmarks whose parents are unknown.
-  std::string root_server_id = syncable::GetNullId().GetServerId();
+  std::string root_server_id = Id::GetRoot().GetServerId();
   int64 a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
   int64 x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
 
   // Update application will fail.
   sessions::StatusController status1;
   ApplyBookmarkUpdates(&status1);
   EXPECT_EQ(0, status1.num_updates_applied());
   EXPECT_EQ(2, status1.num_hierarchy_conflicts());
@@ skipping 156 matching lines @@
   }
 }
 
 // Test update application where the update has been orphaned by a local folder
 // deletion.  The update application attempt should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
   entry_factory()->CreateUnsyncedItem(
-      syncable::Id::CreateFromServerId("parent"), TestIdFactory::root(),
+      Id::CreateFromServerId("parent"), TestIdFactory::root(),
       "parent", true, BOOKMARKS, &parent_handle);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans,
                                  syncable::GET_BY_HANDLE,
                                  parent_handle);
     entry.PutIsDel(true);
   }
 
   // Create an incoming child from the server.
@@ skipping 92 matching lines @@
     EXPECT_TRUE(y.GetIsUnappliedUpdate());
     EXPECT_FALSE(x.GetIsUnsynced());
     EXPECT_FALSE(y.GetIsUnsynced());
   }
 }
 
 // Attempt application of a mix of items.  Some update application attempts will
 // fail due to hierarchy conflicts.  Others should succeed.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
-  std::string root_server_id = syncable::GetNullId().GetServerId();
+  std::string root_server_id = Id::GetRoot().GetServerId();
   int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64 k1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
   int64 u2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
   int64 k3_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
@@ skipping 70 matching lines @@
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
 // Attempt application of encrypted items when the passphrase is not known.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
-  std::string root_server_id = syncable::GetNullId().GetServerId();
+  std::string root_server_id = Id::GetRoot().GetServerId();
   int64 folder_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "folder",
       encrypted_bookmark,
       root_server_id);
   int64 bookmark_handle = entry_factory()->CreateUnappliedNewItem(
       "item2",
       encrypted_bookmark,
       false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.mutable_password();
@@ skipping 175 matching lines @@
   const UpdateCounters& counters = GetArticlesUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied);
   EXPECT_EQ(1, counters.num_local_overwrites);
   EXPECT_EQ(0, counters.num_server_overwrites);
   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   EXPECT_EQ(server_metadata.SerializeAsString(),
             local_metadata.SerializeAsString());
 }
 
 }  // namespace syncer