[Sync] Remove static initializers

chrome/browser/sync/engine/apply_updates_command_unittest.cc

 // Copyright (c) 2011 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/stringprintf.h"
 #include "base/tracked.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
@@ skipping 74 matching lines @@
                               bool is_unique) {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
     WriteTransaction trans(FROM_HERE, UNITTEST, dir);
     MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
         Id::CreateFromServerId(item_id));
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::SERVER_VERSION, next_revision_++);
     entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     entry.Put(syncable::SERVER_NON_UNIQUE_NAME, item_id);
-    entry.Put(syncable::SERVER_PARENT_ID, syncable::kNullId);
+    entry.Put(syncable::SERVER_PARENT_ID, syncable::GetNullId());
     entry.Put(syncable::SERVER_IS_DIR, false);
     entry.Put(syncable::SERVER_SPECIFICS, specifics);
     if (is_unique)  // For top-level nodes.
       entry.Put(syncable::UNIQUE_SERVER_TAG, item_id);
   }
 
   // Create an unsynced item in the database.  If item_id is a local ID, it
   // will be treated as a create-new.  Otherwise, if it's a server ID, we'll
   // fake the server data so that it looks like it exists on the server.
   // Returns the methandle of the created item in |metahandle_out| if not NULL.
@@ skipping 31 matching lines @@
   }
 
   ApplyUpdatesCommand apply_updates_command_;
   TestIdFactory id_factory_;
  private:
   int64 next_revision_;
   DISALLOW_COPY_AND_ASSIGN(ApplyUpdatesCommandTest);
 };
 
 TEST_F(ApplyUpdatesCommandTest, Simple) {
-  string root_server_id = syncable::kNullId.GetServerId();
+  string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("parent",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
   CreateUnappliedNewItemWithParent("child",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
 
   apply_updates_command_.ExecuteImpl(session());
 
   sessions::StatusController* status = session()->status_controller();
 
   sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
   EXPECT_EQ(2, status->update_progress().AppliedUpdatesSize())
       << "All updates should have been attempted";
   EXPECT_EQ(0, status->conflict_progress().ConflictingItemsSize())
       << "Simple update shouldn't result in conflicts";
   EXPECT_EQ(2, status->update_progress().SuccessfullyAppliedUpdateCount())
       << "All items should have been successfully applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, UpdateWithChildrenBeforeParents) {
   // Set a bunch of updates which are difficult to apply in the order
   // they're received due to dependencies on other unseen items.
-  string root_server_id = syncable::kNullId.GetServerId();
+  string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("a_child_created_first",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
   CreateUnappliedNewItemWithParent("x_child_created_first",
                                    DefaultBookmarkSpecifics(),
                                    "parent");
   CreateUnappliedNewItemWithParent("parent",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
   CreateUnappliedNewItemWithParent("a_child_created_second",
@@ skipping 31 matching lines @@
   EXPECT_EQ(2, status->update_progress().AppliedUpdatesSize())
       << "All updates should have been attempted";
   EXPECT_EQ(2, status->conflict_progress().ConflictingItemsSize())
       << "All updates with an unknown ancestors should be in conflict";
   EXPECT_EQ(0, status->update_progress().SuccessfullyAppliedUpdateCount())
       << "No item with an unknown ancestor should be applied";
 }
 
 TEST_F(ApplyUpdatesCommandTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
-  string root_server_id = syncable::kNullId.GetServerId();
+  string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("first_unknown_item",
                                    DefaultBookmarkSpecifics(),
                                    "unknown_parent");
   CreateUnappliedNewItemWithParent("first_known_item",
                                    DefaultBookmarkSpecifics(),
                                    root_server_id);
   CreateUnappliedNewItemWithParent("second_unknown_item",
                                    DefaultBookmarkSpecifics(),
                                    "unknown_parent");
   CreateUnappliedNewItemWithParent("second_known_item",
@@ skipping 52 matching lines @@
       << "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();
   AddDefaultExtensionValue(syncable::BOOKMARKS, &encrypted_bookmark);
-  string root_server_id = syncable::kNullId.GetServerId();
+  string root_server_id = syncable::GetNullId().GetServerId();
   CreateUnappliedNewItemWithParent("folder",
                                    encrypted_bookmark,
                                    root_server_id);
   CreateUnappliedNewItem("item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.MutableExtension(sync_pb::password);
   CreateUnappliedNewItem("item3", encrypted_password, false);
 
   apply_updates_command_.ExecuteImpl(session());
 
@@ skipping 364 matching lines @@
     encrypted_types.insert(syncable::BOOKMARKS);
     EXPECT_EQ(encrypted_types, cryptographer->GetEncryptedTypes());
 
     Syncer::UnsyncedMetaHandles handles;
     SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     EXPECT_EQ(2*batch_s+1, handles.size());
   }
 }
 
 }  // namespace browser_sync