Try the original CL "Always persist bookmark IDs" again with the fix to...

chrome/browser/bookmarks/bookmark_codec_unittest.cc

 // Copyright (c) 2006-2009 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/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_test_utils.h"
@@ skipping 88 matching lines @@
     // Computed and stored checksums should not be empty and should be equal.
     EXPECT_FALSE(computed_checksum.empty());
     EXPECT_FALSE(stored_checksum.empty());
     EXPECT_EQ(computed_checksum, stored_checksum);
 
     *checksum = computed_checksum;
     return value.release();
   }
 
   bool Decode(BookmarkCodec* codec, BookmarkModel* model, const Value& value) {
-    int max_id;
+    int64 max_id;
     bool result = codec->Decode(AsMutable(model->GetBookmarkBarNode()),
                                 AsMutable(model->other_node()),
                                 &max_id, value);
     model->set_next_node_id(max_id);
     return result;
   }
 
   BookmarkModel* DecodeHelper(const Value& value,
                               const std::string& expected_stored_checksum,
                               std::string* computed_checksum,
@@ skipping 74 matching lines @@
       *value.get(), enc_checksum, &dec_checksum, true));
 
   // Undo the change and make sure the checksum is same as original.
   ASSERT_TRUE(child1_value->SetString(BookmarkCodec::kNameKey, title));
   scoped_ptr<BookmarkModel> decoded_model2(DecodeHelper(
       *value.get(), enc_checksum, &dec_checksum, false));
 }
 
 TEST_F(BookmarkCodecTest, PersistIDsTest) {
   scoped_ptr<BookmarkModel> model_to_encode(CreateTestModel3());
-  BookmarkCodec encoder(true);
+  BookmarkCodec encoder;
   scoped_ptr<Value> model_value(encoder.Encode(model_to_encode.get()));
 
   BookmarkModel decoded_model(NULL);
-  BookmarkCodec decoder(true);
+  BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, &decoded_model, *model_value.get()));
   BookmarkModelTestUtils::AssertModelsEqual(model_to_encode.get(),
                                             &decoded_model,
                                             true);
 
   // Add a couple of more items to the decoded bookmark model and make sure
   // ID persistence is working properly.
   const BookmarkNode* bookmark_bar = decoded_model.GetBookmarkBarNode();
   decoded_model.AddURL(
       bookmark_bar, bookmark_bar->GetChildCount(), kUrl3Title, GURL(kUrl3Url));
   const BookmarkNode* group2_node = decoded_model.AddGroup(
       bookmark_bar, bookmark_bar->GetChildCount(), kGroup2Title);
   decoded_model.AddURL(group2_node, 0, kUrl4Title, GURL(kUrl4Url));
 
-  BookmarkCodec encoder2(true);
+  BookmarkCodec encoder2;
   scoped_ptr<Value> model_value2(encoder2.Encode(&decoded_model));
 
   BookmarkModel decoded_model2(NULL);
-  BookmarkCodec decoder2(true);
+  BookmarkCodec decoder2;
   ASSERT_TRUE(Decode(&decoder2, &decoded_model2, *model_value2.get()));
   BookmarkModelTestUtils::AssertModelsEqual(&decoded_model,
                                             &decoded_model2,
                                             true);
 }
 
 class UniqueIDGeneratorTest : public testing::Test {
  protected:
   void TestMixed(UniqueIDGenerator* gen) {
     // Few unique numbers.
-    for (int i = 1; i <= 5; ++i) {
+    for (int64 i = 1; i <= 5; ++i) {
       EXPECT_EQ(i, gen->GetUniqueID(i));
     }
 
     // All numbers from 1 to 5 should produce numbers 6 to 10.
-    for (int i = 1; i <= 5; ++i) {
+    for (int64 i = 1; i <= 5; ++i) {
       EXPECT_EQ(5 + i, gen->GetUniqueID(i));
     }
 
     // 10 should produce 11, then 11 should produce 12, and so on.
-    for (int i = 1; i <= 5; ++i) {
+    for (int64 i = 1; i <= 5; ++i) {
       EXPECT_EQ(10 + i, gen->GetUniqueID(9 + i));
     }
 
     // Any numbers between 1 and 15 should produce a new numbers in sequence.
     EXPECT_EQ(16, gen->GetUniqueID(10));
     EXPECT_EQ(17, gen->GetUniqueID(2));
     EXPECT_EQ(18, gen->GetUniqueID(14));
     EXPECT_EQ(19, gen->GetUniqueID(7));
     EXPECT_EQ(20, gen->GetUniqueID(4));
 
     // Numbers not yet generated should work.
     EXPECT_EQ(100, gen->GetUniqueID(100));
     EXPECT_EQ(21, gen->GetUniqueID(21));
     EXPECT_EQ(200, gen->GetUniqueID(200));
 
     // Now any existing number should produce numbers starting from 201.
     EXPECT_EQ(201, gen->GetUniqueID(1));
     EXPECT_EQ(202, gen->GetUniqueID(20));
     EXPECT_EQ(203, gen->GetUniqueID(21));
     EXPECT_EQ(204, gen->GetUniqueID(100));
     EXPECT_EQ(205, gen->GetUniqueID(200));
   }
 };
 
 TEST_F(UniqueIDGeneratorTest, SerialNumbersTest) {
   UniqueIDGenerator gen;
-  for (int i = 1; i <= 10; ++i) {
+  for (int64 i = 1; i <= 10; ++i) {
     EXPECT_EQ(i, gen.GetUniqueID(i));
   }
 }
 
 TEST_F(UniqueIDGeneratorTest, UniqueSortedNumbersTest) {
   UniqueIDGenerator gen;
-  for (int i = 1; i <= 10; i += 2) {
+  for (int64 i = 1; i <= 10; i += 2) {
     EXPECT_EQ(i, gen.GetUniqueID(i));
   }
 }
 
 TEST_F(UniqueIDGeneratorTest, UniqueUnsortedConsecutiveNumbersTest) {
   UniqueIDGenerator gen;
   int numbers[] = {2, 10, 6, 3, 8, 5, 1, 7, 4, 9};
-  for (int i = 0; i < ARRAYSIZE(numbers); ++i) {
+  for (int64 i = 0; i < ARRAYSIZE(numbers); ++i) {
     EXPECT_EQ(numbers[i], gen.GetUniqueID(numbers[i]));
   }
 }
 
 TEST_F(UniqueIDGeneratorTest, UniqueUnsortedNumbersTest) {
   UniqueIDGenerator gen;
   int numbers[] = {20, 100, 60, 30, 80, 50, 10, 70, 40, 90};
-  for (int i = 0; i < ARRAYSIZE(numbers); ++i) {
+  for (int64 i = 0; i < ARRAYSIZE(numbers); ++i) {
     EXPECT_EQ(numbers[i], gen.GetUniqueID(numbers[i]));
   }
 }
 
 TEST_F(UniqueIDGeneratorTest, AllDuplicatesTest) {
   UniqueIDGenerator gen;
-  for (int i = 1; i <= 10; ++i) {
+  for (int64 i = 1; i <= 10; ++i) {
     EXPECT_EQ(i, gen.GetUniqueID(1));
   }
 }
 
 TEST_F(UniqueIDGeneratorTest, MixedTest) {
   UniqueIDGenerator gen;
   TestMixed(&gen);
 }
 
 TEST_F(UniqueIDGeneratorTest, ResetTest) {
   UniqueIDGenerator gen;
-  for (int i = 0; i < 5; ++i) {
+  for (int64 i = 0; i < 5; ++i) {
     TestMixed(&gen);
     gen.Reset();
   }
 }