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

Valgrind issue. The fix is in bookmark_storage.h - initialized the newly
added member ids_reassigned_ of LoadDetails class.

See http://codereview.chromium.org/149310 for the original CL.

TEST=NONE
BUG=16068

Review URL: http://codereview.chromium.org/155456

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@20565 0039d316-1c4b-4281-b951-d872f2087c98

20 files changed, 195 insertions, 195 deletions

diff --git a/chrome/browser/bookmarks/bookmark_codec.cc b/chrome/browser/bookmarks/bookmark_codec.cc
index 4e4f5ed..92f6dcf 100644
--- a/chrome/browser/bookmarks/bookmark_codec.cc
+++ b/chrome/browser/bookmarks/bookmark_codec.cc
@@ -17,7 +17,7 @@ UniqueIDGenerator::UniqueIDGenerator() {
   Reset();
 }
 
-int UniqueIDGenerator::GetUniqueID(int id) {
+int64 UniqueIDGenerator::GetUniqueID(int64 id) {
   // If the given ID is already assigned, generate new ID.
   if (IsIdAssigned(id))
     id = current_max_ + 1;
@@ -31,7 +31,7 @@ int UniqueIDGenerator::GetUniqueID(int id) {
   return id;
 }
 
-bool UniqueIDGenerator::IsIdAssigned(int id) const {
+bool UniqueIDGenerator::IsIdAssigned(int64 id) const {
   // If the set is already instantiated, then use the set to determine if the
   // given ID is assigned. Otherwise use the current maximum to determine if the
   // given ID is assigned.
@@ -41,7 +41,7 @@ bool UniqueIDGenerator::IsIdAssigned(int id) const {
     return id <= current_max_;
 }
 
-void UniqueIDGenerator::RecordId(int id) {
+void UniqueIDGenerator::RecordId(int64 id) {
   // If the set is instantiated, then use the set.
   if (assigned_ids_.get()) {
     assigned_ids_->insert(id);
@@ -55,8 +55,8 @@ void UniqueIDGenerator::RecordId(int id) {
     ++current_max_;
     return;
   }
-  assigned_ids_.reset(new std::set<int>);
-  for (int i = 0; i <= current_max_; ++i)
+  assigned_ids_.reset(new std::set<int64>);
+  for (int64 i = 0; i <= current_max_; ++i)
     assigned_ids_->insert(i);
   assigned_ids_->insert(id);
 }
@@ -85,11 +85,7 @@ const wchar_t* BookmarkCodec::kTypeFolder = L"folder";
 static const int kCurrentVersion = 1;
 
 BookmarkCodec::BookmarkCodec()
-    : persist_ids_(false) {
-}
-
-BookmarkCodec::BookmarkCodec(bool persist_ids)
-    : persist_ids_(persist_ids) {
+    : ids_reassigned_(false) {
 }
 
 Value* BookmarkCodec::Encode(BookmarkModel* model) {
@@ -98,6 +94,7 @@ Value* BookmarkCodec::Encode(BookmarkModel* model) {
 
 Value* BookmarkCodec::Encode(const BookmarkNode* bookmark_bar_node,
                              const BookmarkNode* other_folder_node) {
+  ids_reassigned_ = false;
   InitializeChecksum();
   DictionaryValue* roots = new DictionaryValue();
   roots->Set(kRootFolderNameKey, EncodeNode(bookmark_bar_node));
@@ -116,12 +113,16 @@ Value* BookmarkCodec::Encode(const BookmarkNode* bookmark_bar_node,
 
 bool BookmarkCodec::Decode(BookmarkNode* bb_node,
                            BookmarkNode* other_folder_node,
-                           int* max_id,
+                           int64* max_id,
                            const Value& value) {
+  // TODO(munjal): Instead of paying the price of ID generator in al lcases, we
+  // should only pay the price if we detect the file has changed and do a second
+  // pass to reassign IDs. See issue 16357.
   id_generator_.Reset();
+  ids_reassigned_ = false;
   stored_checksum_.clear();
   InitializeChecksum();
-  bool success = DecodeHelper(bb_node, other_folder_node, max_id, value);
+  bool success = DecodeHelper(bb_node, other_folder_node, value);
   FinalizeChecksum();
   *max_id = id_generator_.current_max() + 1;
   return success;
@@ -130,10 +131,8 @@ bool BookmarkCodec::Decode(BookmarkNode* bb_node,
 Value* BookmarkCodec::EncodeNode(const BookmarkNode* node) {
   DictionaryValue* value = new DictionaryValue();
   std::string id;
-  if (persist_ids_) {
-    id = IntToString(node->id());
-    value->SetString(kIdKey, id);
-  }
+  id = Int64ToString(node->id());
+  value->SetString(kIdKey, id);
   const std::wstring& title = node->GetTitle();
   value->SetString(kNameKey, title);
   value->SetString(kDateAddedKey,
@@ -160,7 +159,6 @@ Value* BookmarkCodec::EncodeNode(const BookmarkNode* node) {
 
 bool BookmarkCodec::DecodeHelper(BookmarkNode* bb_node,
                                  BookmarkNode* other_folder_node,
-                                 int* max_id,
                                  const Value& value) {
   if (value.GetType() != Value::TYPE_DICTIONARY)
     return false;  // Unexpected type.
@@ -231,13 +229,14 @@ bool BookmarkCodec::DecodeNode(const DictionaryValue& value,
                                BookmarkNode* parent,
                                BookmarkNode* node) {
   std::string id_string;
-  int id = 0;
-  if (persist_ids_) {
-    if (value.GetString(kIdKey, &id_string))
-      if (!StringToInt(id_string, &id))
-        return false;
-  }
-  id = id_generator_.GetUniqueID(id);
+  int64 id = 0;
+  if (value.GetString(kIdKey, &id_string))
+    if (!StringToInt64(id_string, &id))
+      return false;
+  int64 new_id = id_generator_.GetUniqueID(id);
+  if (new_id != id)
+    ids_reassigned_ = true;
+  id = new_id;
 
   std::wstring title;
   if (!value.GetString(kNameKey, &title))
diff --git a/chrome/browser/bookmarks/bookmark_codec.h b/chrome/browser/bookmarks/bookmark_codec.h
index e6292a8..2c13cef 100644
--- a/chrome/browser/bookmarks/bookmark_codec.h
+++ b/chrome/browser/bookmarks/bookmark_codec.h
@@ -22,7 +22,7 @@ class DictionaryValue;
 class ListValue;
 class Value;
 
-// Utility class to help assign unique integer IDs.
+// Utility class to help assign unique 64-bit IDs.
 class UniqueIDGenerator {
  public:
   UniqueIDGenerator();
@@ -31,25 +31,26 @@ class UniqueIDGenerator {
   // returns the id itself, otherwise generates a new unique id in a simple way
   // and returns that.
   // NOTE that if id is 0, a new unique id is returned.
-  int GetUniqueID(int id);
+  int64 GetUniqueID(int64 id);
 
   // Resets the ID generator to initial state.
   void Reset();
 
   // Returns the current maximum.
-  int current_max() const { return current_max_; }
+  int64 current_max() const { return current_max_; }
 
  private:
   // Checks if the given ID is already assigned.
-  bool IsIdAssigned(int id) const;
+  bool IsIdAssigned(int64 id) const;
 
   // Records the given ID as assigned.
-  void RecordId(int id);
+  void RecordId(int64 id);
 
   // Maximum value we have seen so far.
-  int current_max_;
+  int64 current_max_;
+
   // All IDs assigned so far.
-  scoped_ptr<std::set<int> > assigned_ids_;
+  scoped_ptr<std::set<int64> > assigned_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(UniqueIDGenerator);
 };
@@ -59,14 +60,11 @@ class UniqueIDGenerator {
 
 class BookmarkCodec {
  public:
-  // Creates an instance of the codec. Encodes/decodes bookmark IDs also if
-  // persist_ids is true. The default constructor will not encode/decode IDs.
-  // During decoding, if persist_ids is true and if the IDs in the file are not
-  // unique, we will reassign IDs to make them unique. There are no guarantees
-  // on how the IDs are reassigned or about doing minimal reassignments to
-  // achieve uniqueness.
+  // Creates an instance of the codec. During decoding, if the IDs in the file
+  // are not unique, we will reassign IDs to make them unique. There are no
+  // guarantees on how the IDs are reassigned or about doing minimal
+  // reassignments to achieve uniqueness.
   BookmarkCodec();
-  explicit BookmarkCodec(bool persist_ids);
 
   // Encodes the model to a JSON value. It's up to the caller to delete the
   // returned object. This is invoked to encode the contents of the bookmark bar
@@ -88,7 +86,7 @@ class BookmarkCodec {
   // |max_node_id| is set to the max id of the nodes.
   bool Decode(BookmarkNode* bb_node,
               BookmarkNode* other_folder_node,
-              int* max_node_id,
+              int64* max_node_id,
               const Value& value);
 
   // Returns the checksum computed during last encoding/decoding call.
@@ -101,6 +99,10 @@ class BookmarkCodec {
   // user.
   const std::string& stored_checksum() const { return stored_checksum_; }
 
+  // Returns whether the IDs were reassigned during decoding. Always returns
+  // false after encoding.
+  bool ids_reassigned() const { return ids_reassigned_; }
+
   // Names of the various keys written to the Value.
   static const wchar_t* kRootsKey;
   static const wchar_t* kRootFolderNameKey;
@@ -127,7 +129,6 @@ class BookmarkCodec {
   // Helper to perform decoding.
   bool DecodeHelper(BookmarkNode* bb_node,
                     BookmarkNode* other_folder_node,
-                    int* max_id,
                     const Value& value);
 
   // Decodes the children of the specified node. Returns true on success.
@@ -160,11 +161,12 @@ class BookmarkCodec {
   void InitializeChecksum();
   void FinalizeChecksum();
 
-  // Whether to persist IDs or not.
-  bool persist_ids_;
   // Unique ID generator used during decoding.
   UniqueIDGenerator id_generator_;
 
+  // Whether or not IDs were reassigned by the codec.
+  bool ids_reassigned_;
+
   // MD5 context used to compute MD5 hash of all bookmark data.
   MD5Context md5_context_;
 
diff --git a/chrome/browser/bookmarks/bookmark_codec_unittest.cc b/chrome/browser/bookmarks/bookmark_codec_unittest.cc
index d6a3424..ed3996e 100644
--- a/chrome/browser/bookmarks/bookmark_codec_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_codec_unittest.cc
@@ -106,7 +106,7 @@ class BookmarkCodecTest : public testing::Test {
   }
 
   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);
@@ -201,11 +201,11 @@ TEST_F(BookmarkCodecTest, ChecksumManualEditTest) {
 
 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,
@@ -220,11 +220,11 @@ TEST_F(BookmarkCodecTest, PersistIDsTest) {
       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,
@@ -235,17 +235,17 @@ 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));
     }
 
@@ -272,14 +272,14 @@ class UniqueIDGeneratorTest : public testing::Test {
 
 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));
   }
 }
@@ -287,7 +287,7 @@ TEST_F(UniqueIDGeneratorTest, UniqueSortedNumbersTest) {
 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]));
   }
 }
@@ -295,14 +295,14 @@ TEST_F(UniqueIDGeneratorTest, UniqueUnsortedConsecutiveNumbersTest) {
 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));
   }
 }
@@ -314,7 +314,7 @@ TEST_F(UniqueIDGeneratorTest, MixedTest) {
 
 TEST_F(UniqueIDGeneratorTest, ResetTest) {
   UniqueIDGenerator gen;
-  for (int i = 0; i < 5; ++i) {
+  for (int64 i = 0; i < 5; ++i) {
     TestMixed(&gen);
     gen.Reset();
   }
diff --git a/chrome/browser/bookmarks/bookmark_drag_data.cc b/chrome/browser/bookmarks/bookmark_drag_data.cc
index 732d119..bf3ae05 100644
--- a/chrome/browser/bookmarks/bookmark_drag_data.cc
+++ b/chrome/browser/bookmarks/bookmark_drag_data.cc
@@ -41,7 +41,7 @@ void BookmarkDragData::Element::WriteToPickle(Pickle* pickle) const {
   pickle->WriteBool(is_url);
   pickle->WriteString(url.spec());
   pickle->WriteWString(title);
-  pickle->WriteInt(id_);
+  pickle->WriteInt64(id_);
   if (!is_url) {
     pickle->WriteSize(children.size());
     for (std::vector<Element>::const_iterator i = children.begin();
@@ -57,7 +57,7 @@ bool BookmarkDragData::Element::ReadFromPickle(Pickle* pickle,
   if (!pickle->ReadBool(iterator, &is_url) ||
       !pickle->ReadString(iterator, &url_spec) ||
       !pickle->ReadWString(iterator, &title) ||
-      !pickle->ReadInt(iterator, &id_)) {
+      !pickle->ReadInt64(iterator, &id_)) {
     return false;
   }
   url = GURL(url_spec);
diff --git a/chrome/browser/bookmarks/bookmark_drag_data.h b/chrome/browser/bookmarks/bookmark_drag_data.h
index 88cb6d4..9af3c20 100644
--- a/chrome/browser/bookmarks/bookmark_drag_data.h
+++ b/chrome/browser/bookmarks/bookmark_drag_data.h
@@ -62,7 +62,7 @@ struct BookmarkDragData {
     bool ReadFromPickle(Pickle* pickle, void** iterator);
 
     // ID of the node.
-    int id_;
+    int64 id_;
   };
 
   BookmarkDragData() { }
diff --git a/chrome/browser/bookmarks/bookmark_model.cc b/chrome/browser/bookmarks/bookmark_model.cc
index 5d87da1..9bcc8c3 100644
--- a/chrome/browser/bookmarks/bookmark_model.cc
+++ b/chrome/browser/bookmarks/bookmark_model.cc
@@ -35,12 +35,12 @@ BookmarkNode::BookmarkNode(const GURL& url)
   Initialize(0);
 }
 
-BookmarkNode::BookmarkNode(int id, const GURL& url)
+BookmarkNode::BookmarkNode(int64 id, const GURL& url)
     : url_(url){
   Initialize(id);
 }
 
-void BookmarkNode::Initialize(int id) {
+void BookmarkNode::Initialize(int64 id) {
   id_ = id;
   loaded_favicon_ = false;
   favicon_load_handle_ = 0;
@@ -77,9 +77,6 @@ void BookmarkNode::Reset(const history::StarredEntry& entry) {
 
 namespace {
 
-// Constant for persist IDs prefernece.
-const wchar_t kPrefPersistIDs[] = L"bookmarks.persist_ids";
-
 // Comparator used when sorting bookmarks. Folders are sorted first, then
   // bookmarks.
 class SortComparator : public std::binary_function<const BookmarkNode*,
@@ -110,7 +107,6 @@ class SortComparator : public std::binary_function<const BookmarkNode*,
 BookmarkModel::BookmarkModel(Profile* profile)
     : profile_(profile),
       loaded_(false),
-      persist_ids_(false),
       file_changed_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
@@ -122,8 +118,6 @@ BookmarkModel::BookmarkModel(Profile* profile)
     // Profile is null during testing.
     DoneLoading(CreateLoadDetails());
   }
-  RegisterPreferences();
-  LoadPreferences();
 }
 
 BookmarkModel::~BookmarkModel() {
@@ -282,7 +276,7 @@ bool BookmarkModel::IsBookmarked(const GURL& url) {
   return IsBookmarkedNoLock(url);
 }
 
-const BookmarkNode* BookmarkModel::GetNodeByID(int id) {
+const BookmarkNode* BookmarkModel::GetNodeByID(int64 id) {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(&root_, id);
 }
@@ -408,19 +402,6 @@ void BookmarkModel::ClearStore() {
   store_ = NULL;
 }
 
-void BookmarkModel::SetPersistIDs(bool value) {
-  if (value == persist_ids_)
-    return;
-  persist_ids_ = value;
-  if (profile_) {
-    PrefService* pref_service = profile_->GetPrefs();
-    pref_service->SetBoolean(kPrefPersistIDs, persist_ids_);
-  }
-  // Need to save the bookmark data if the value of persist IDs changes.
-  if (store_.get())
-    store_->ScheduleSave();
-}
-
 bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
   BookmarkNode tmp_node(url);
   return (nodes_ordered_by_url_set_.find(&tmp_node) !=
@@ -477,6 +458,15 @@ void BookmarkModel::DoneLoading(
   next_node_id_ = details->max_id();
   if (details->computed_checksum() != details->stored_checksum())
     SetFileChanged();
+  if (details->computed_checksum() != details->stored_checksum() ||
+      details->ids_reassigned()) {
+    // If bookmarks file changed externally, the IDs may have changed
+    // externally. In that case, the decoder may have reassigned IDs to make
+    // them unique. So when the file has changed externally, we should save the
+    // bookmarks file to persist new IDs.
+    if (store_.get())
+      store_->ScheduleSave();
+  }
   index_.reset(details->index());
   details->release();
 
@@ -587,7 +577,7 @@ void BookmarkModel::BlockTillLoaded() {
 }
 
 const BookmarkNode* BookmarkModel::GetNodeByID(const BookmarkNode* node,
-                                               int id) {
+                                               int64 id) {
   if (node->id() == id)
     return node;
 
@@ -725,18 +715,12 @@ void BookmarkModel::PopulateNodesByURL(BookmarkNode* node) {
     PopulateNodesByURL(node->GetChild(i));
 }
 
-int BookmarkModel::generate_next_node_id() {
+int64 BookmarkModel::generate_next_node_id() {
   return next_node_id_++;
 }
 
 void BookmarkModel::SetFileChanged() {
   file_changed_ = true;
-  // If bookmarks file changed externally, the IDs may have changed externally.
-  // in that case, the decoder may have reassigned IDs to make them unique.
-  // So when the file has changed externally and IDs are persisted, we should
-  // save the bookmarks file to persist new IDs.
-  if (persist_ids_ && store_.get())
-    store_->ScheduleSave();
 }
 
 BookmarkStorage::LoadDetails* BookmarkModel::CreateLoadDetails() {
@@ -745,18 +729,3 @@ BookmarkStorage::LoadDetails* BookmarkModel::CreateLoadDetails() {
   return new BookmarkStorage::LoadDetails(
       bb_node, other_folder_node, new BookmarkIndex(), next_node_id_);
 }
-
-void BookmarkModel::RegisterPreferences() {
-  if (!profile_)
-    return;
-  PrefService* pref_service = profile_->GetPrefs();
-  if (!pref_service->IsPrefRegistered(kPrefPersistIDs))
-    pref_service->RegisterBooleanPref(kPrefPersistIDs, false);
-}
-
-void BookmarkModel::LoadPreferences() {
-  if (!profile_)
-    return;
-  PrefService* pref_service = profile_->GetPrefs();
-  persist_ids_ = pref_service->GetBoolean(kPrefPersistIDs);
-}
diff --git a/chrome/browser/bookmarks/bookmark_model.h b/chrome/browser/bookmarks/bookmark_model.h
index 9726624..c8ba083 100644
--- a/chrome/browser/bookmarks/bookmark_model.h
+++ b/chrome/browser/bookmarks/bookmark_model.h
@@ -53,19 +53,18 @@ class BookmarkNode : public TreeNode<BookmarkNode> {
   // Creates a new node with the specified url and id of 0
   explicit BookmarkNode(const GURL& url);
   // Creates a new node with the specified url and id.
-  BookmarkNode(int id, const GURL& url);
+  BookmarkNode(int64 id, const GURL& url);
   virtual ~BookmarkNode() {}
 
   // Returns the URL.
   const GURL& GetURL() const { return url_; }
 
   // Returns a unique id for this node.
-  //
-  // NOTE: this id is only unique for the session and NOT unique across
-  // sessions. Don't persist it!
-  int id() const { return id_; }
+  // For bookmark nodes that are managed by the bookmark model, the IDs are
+  // persisted across sessions.
+  int64 id() const { return id_; }
   // Sets the id to the given value.
-  void set_id(int id) { id_ = id; }
+  void set_id(int64 id) { id_ = id; }
 
   // Returns the type of this node.
   BookmarkNode::Type GetType() const { return type_; }
@@ -126,10 +125,10 @@ class BookmarkNode : public TreeNode<BookmarkNode> {
 
  private:
   // helper to initialize various fields during construction.
-  void Initialize(int id);
+  void Initialize(int64 id);
 
   // Unique identifier for this node.
-  int id_;
+  int64 id_;
 
   // Whether the favicon has been loaded.
   bool loaded_favicon_;
@@ -292,7 +291,7 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
 
   // Returns the node with the specified id, or NULL if there is no node with
   // the specified id.
-  const BookmarkNode* GetNodeByID(int id);
+  const BookmarkNode* GetNodeByID(int64 id);
 
   // Adds a new group node at the specified position.
   const BookmarkNode* AddGroup(const BookmarkNode* parent,
@@ -355,10 +354,6 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   // testing.
   void ClearStore();
 
-  // Sets/returns whether or not bookmark IDs are persisted or not.
-  bool PersistIDs() const { return persist_ids_; }
-  void SetPersistIDs(bool value);
-
   // Returns whether the bookmarks file changed externally.
   bool file_changed() const { return file_changed_; }
 
@@ -404,7 +399,7 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
                         bool was_bookmarked);
 
   // Implementation of GetNodeByID.
-  const BookmarkNode* GetNodeByID(const BookmarkNode* node, int id);
+  const BookmarkNode* GetNodeByID(const BookmarkNode* node, int64 id);
 
   // Returns true if the parent and index are valid.
   bool IsValidIndex(const BookmarkNode* parent, int index, bool allow_end);
@@ -444,13 +439,12 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
                        const NotificationDetails& details);
 
   // Generates and returns the next node ID.
-  int generate_next_node_id();
+  int64 generate_next_node_id();
 
   // Sets the maximum node ID to the given value.
   // This is used by BookmarkCodec to report the maximum ID after it's done
-  // decoding since during decoding codec can assign IDs to nodes if IDs are
-  // persisted.
-  void set_next_node_id(int id) { next_node_id_ = id; }
+  // decoding since during decoding codec assigns node IDs.
+  void set_next_node_id(int64 id) { next_node_id_ = id; }
 
   // Records that the bookmarks file was changed externally.
   void SetFileChanged();
@@ -459,11 +453,6 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   // the returned object.
   BookmarkStorage::LoadDetails* CreateLoadDetails();
 
-  // Registers bookmarks related prefs.
-  void RegisterPreferences();
-  // Loads bookmark related preferences.
-  void LoadPreferences();
-
   NotificationRegistrar registrar_;
 
   Profile* profile_;
@@ -471,9 +460,6 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   // Whether the initial set of data has been loaded.
   bool loaded_;
 
-  // Whether to persist bookmark IDs.
-  bool persist_ids_;
-
   // Whether the bookmarks file was changed externally. This is set after
   // loading is complete and once set the value never changes.
   bool file_changed_;
@@ -486,7 +472,7 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   BookmarkNode* other_node_;
 
   // The maximum ID assigned to the bookmark nodes in the model.
-  int next_node_id_;
+  int64 next_node_id_;
 
   // The observers.
   ObserverList<BookmarkModelObserver> observers_;
diff --git a/chrome/browser/bookmarks/bookmark_model_unittest.cc b/chrome/browser/bookmarks/bookmark_model_unittest.cc
index 05d0843..627a058 100644
--- a/chrome/browser/bookmarks/bookmark_model_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_model_unittest.cc
@@ -593,7 +593,7 @@ class BookmarkModelTestWithProfile : public testing::Test,
 
   void VerifyNoDuplicateIDs(BookmarkModel* model) {
     TreeNodeIterator<const BookmarkNode> it(model->root_node());
-    base::hash_set<int> ids;
+    base::hash_set<int64> ids;
     while (it.has_next())
       ASSERT_TRUE(ids.insert(it.Next()->id()).second);
   }
diff --git a/chrome/browser/bookmarks/bookmark_storage.cc b/chrome/browser/bookmarks/bookmark_storage.cc
index a530158..d7dbe19 100644
--- a/chrome/browser/bookmarks/bookmark_storage.cc
+++ b/chrome/browser/bookmarks/bookmark_storage.cc
@@ -68,13 +68,11 @@ class BookmarkStorage::LoadTask : public Task {
   LoadTask(const FilePath& path,
            MessageLoop* loop,
            BookmarkStorage* storage,
-           LoadDetails* details,
-           bool persist_ids)
+           LoadDetails* details)
       : path_(path),
         loop_(loop),
         storage_(storage),
-        details_(details),
-        persist_ids_(persist_ids) {
+        details_(details) {
   }
 
   virtual void Run() {
@@ -86,14 +84,15 @@ class BookmarkStorage::LoadTask : public Task {
       if (root.get()) {
         // Building the index cane take a while, so we do it on the background
         // thread.
-        int max_node_id = 0;
-        BookmarkCodec codec(persist_ids_);
+        int64 max_node_id = 0;
+        BookmarkCodec codec;
         TimeTicks start_time = TimeTicks::Now();
         codec.Decode(details_->bb_node(), details_->other_folder_node(),
                      &max_node_id, *root.get());
         details_->set_max_id(std::max(max_node_id, details_->max_id()));
         details_->set_computed_checksum(codec.computed_checksum());
         details_->set_stored_checksum(codec.stored_checksum());
+        details_->set_ids_reassigned(codec.ids_reassigned());
         UMA_HISTOGRAM_TIMES("Bookmarks.DecodeTime",
                             TimeTicks::Now() - start_time);
 
@@ -129,7 +128,6 @@ class BookmarkStorage::LoadTask : public Task {
   MessageLoop* loop_;
   scoped_refptr<BookmarkStorage> storage_;
   LoadDetails* details_;
-  bool persist_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadTask);
 };
@@ -164,8 +162,7 @@ void BookmarkStorage::DoLoadBookmarks(const FilePath& path) {
   Task* task = new LoadTask(path,
                             backend_thread() ? MessageLoop::current() : NULL,
                             this,
-                            details_.get(),
-                            model_->PersistIDs());
+                            details_.get());
   RunTaskOnBackendThread(task);
 }
 
@@ -211,7 +208,7 @@ void BookmarkStorage::BookmarkModelDeleted() {
 }
 
 bool BookmarkStorage::SerializeData(std::string* output) {
-  BookmarkCodec codec(model_->PersistIDs());
+  BookmarkCodec codec;
   scoped_ptr<Value> value(codec.Encode(model_));
   JSONStringValueSerializer serializer(output);
   serializer.set_pretty_print(true);
diff --git a/chrome/browser/bookmarks/bookmark_storage.h b/chrome/browser/bookmarks/bookmark_storage.h
index cc18b60..3b83468 100644
--- a/chrome/browser/bookmarks/bookmark_storage.h
+++ b/chrome/browser/bookmarks/bookmark_storage.h
@@ -44,11 +44,12 @@ class BookmarkStorage : public NotificationObserver,
     LoadDetails(BookmarkNode* bb_node,
                 BookmarkNode* other_folder_node,
                 BookmarkIndex* index,
-                int max_id)
+                int64 max_id)
         : bb_node_(bb_node),
           other_folder_node_(other_folder_node),
           index_(index),
-          max_id_(max_id) {
+          max_id_(max_id),
+          ids_reassigned_(false) {
     }
 
     void release() {
@@ -62,8 +63,8 @@ class BookmarkStorage : public NotificationObserver,
     BookmarkIndex* index() { return index_.get(); }
 
     // Max id of the nodes.
-    void set_max_id(int max_id) { max_id_ = max_id; }
-    int max_id() const { return max_id_; }
+    void set_max_id(int64 max_id) { max_id_ = max_id; }
+    int64 max_id() const { return max_id_; }
 
     // Computed checksum.
     void set_computed_checksum(const std::string& value) {
@@ -77,13 +78,18 @@ class BookmarkStorage : public NotificationObserver,
     }
     const std::string& stored_checksum() const { return stored_checksum_; }
 
+    // Whether ids were reassigned.
+    void set_ids_reassigned(bool value) { ids_reassigned_ = value; }
+    bool ids_reassigned() const { return ids_reassigned_; }
+
    private:
     scoped_ptr<BookmarkNode> bb_node_;
     scoped_ptr<BookmarkNode> other_folder_node_;
     scoped_ptr<BookmarkIndex> index_;
-    int max_id_;
+    int64 max_id_;
     std::string computed_checksum_;
     std::string stored_checksum_;
+    bool ids_reassigned_;
 
     DISALLOW_COPY_AND_ASSIGN(LoadDetails);
   };
diff --git a/chrome/browser/extensions/extension_bookmarks_module.cc b/chrome/browser/extensions/extension_bookmarks_module.cc
index 9c9d635..808050a 100644
--- a/chrome/browser/extensions/extension_bookmarks_module.cc
+++ b/chrome/browser/extensions/extension_bookmarks_module.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/extensions/extension_bookmarks_module.h"
 
 #include "base/json_writer.h"
+#include "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
@@ -25,11 +26,11 @@ class ExtensionBookmarks {
   static DictionaryValue* GetNodeDictionary(const BookmarkNode* node,
                                             bool recurse) {
     DictionaryValue* dict = new DictionaryValue();
-    dict->SetInteger(keys::kIdKey, node->id());
+    dict->SetString(keys::kIdKey, Int64ToString(node->id()));
 
     const BookmarkNode* parent = node->GetParent();
     if (parent)
-      dict->SetInteger(keys::kParentIdKey, parent->id());
+      dict->SetString(keys::kParentIdKey, Int64ToString(parent->id()));
 
     if (!node->is_folder()) {
       dict->SetString(keys::kUrlKey, node->GetURL().spec());
@@ -68,7 +69,7 @@ class ExtensionBookmarks {
     list->Append(dict);
   }
 
-  static bool RemoveNode(BookmarkModel* model, int id, bool recursive,
+  static bool RemoveNode(BookmarkModel* model, int64 id, bool recursive,
                          std::string* error) {
     const BookmarkNode* node = model->GetNodeByID(id);
     if (!node) {
@@ -114,6 +115,15 @@ void BookmarksFunction::Run() {
   SendResponse(RunImpl());
 }
 
+bool BookmarksFunction::GetBookmarkIdAsInt64(
+    const std::string& id_string, int64* id) {
+  if (StringToInt64(id_string, id))
+    return true;
+
+  error_ = keys::kInvalidIdError;
+  return false;
+}
+
 void BookmarksFunction::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
@@ -161,11 +171,12 @@ void ExtensionBookmarkEventRouter::BookmarkNodeMoved(
     int new_index) {
   ListValue args;
   const BookmarkNode* node = new_parent->GetChild(new_index);
-  args.Append(new FundamentalValue(node->id()));
+  args.Append(new StringValue(Int64ToString(node->id())));
   DictionaryValue* object_args = new DictionaryValue();
-  object_args->SetInteger(keys::kParentIdKey, new_parent->id());
+  object_args->SetString(keys::kParentIdKey, Int64ToString(new_parent->id()));
   object_args->SetInteger(keys::kIndexKey, new_index);
-  object_args->SetInteger(keys::kOldParentIdKey, old_parent->id());
+  object_args->SetString(keys::kOldParentIdKey,
+                         Int64ToString(old_parent->id()));
   object_args->SetInteger(keys::kOldIndexKey, old_index);
   args.Append(object_args);
 
@@ -179,7 +190,7 @@ void ExtensionBookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
                                                      int index) {
   ListValue args;
   const BookmarkNode* node = parent->GetChild(index);
-  args.Append(new FundamentalValue(node->id()));
+  args.Append(new StringValue(Int64ToString(node->id())));
   DictionaryValue* obj = ExtensionBookmarks::GetNodeDictionary(node, false);
 
   // Remove id since it's already being passed as the first argument.
@@ -205,9 +216,9 @@ void ExtensionBookmarkEventRouter::BookmarkNodeRemoved(
     int index,
     const BookmarkNode* node) {
   ListValue args;
-  args.Append(new FundamentalValue(node->id()));
+  args.Append(new StringValue(Int64ToString(node->id())));
   DictionaryValue* object_args = new DictionaryValue();
-  object_args->SetInteger(keys::kParentIdKey, parent->id());
+  object_args->SetString(keys::kParentIdKey, Int64ToString(parent->id()));
   object_args->SetInteger(keys::kIndexKey, index);
   args.Append(object_args);
 
@@ -219,7 +230,7 @@ void ExtensionBookmarkEventRouter::BookmarkNodeRemoved(
 void ExtensionBookmarkEventRouter::BookmarkNodeChanged(
     BookmarkModel* model, const BookmarkNode* node) {
   ListValue args;
-  args.Append(new FundamentalValue(node->id()));
+  args.Append(new StringValue(Int64ToString(node->id())));
 
   // TODO(erikkay) The only two things that BookmarkModel sends this
   // notification for are title and favicon.  Since we're currently ignoring
@@ -243,12 +254,12 @@ void ExtensionBookmarkEventRouter::BookmarkNodeFavIconLoaded(
 void ExtensionBookmarkEventRouter::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
   ListValue args;
-  args.Append(new FundamentalValue(node->id()));
+  args.Append(new StringValue(Int64ToString(node->id())));
   int childCount = node->GetChildCount();
   ListValue* children = new ListValue();
   for (int i = 0; i < childCount; ++i) {
     const BookmarkNode* child = node->GetChild(i);
-    Value* child_id = new FundamentalValue(child->id());
+    Value* child_id = new StringValue(Int64ToString(child->id()));
     children->Append(child_id);
   }
   args.Append(children);
@@ -268,8 +279,11 @@ bool GetBookmarksFunction::RunImpl() {
     size_t count = ids->GetSize();
     EXTENSION_FUNCTION_VALIDATE(count > 0);
     for (size_t i = 0; i < count; ++i) {
-      int id = 0;
-      EXTENSION_FUNCTION_VALIDATE(ids->GetInteger(i, &id));
+      int64 id;
+      std::string id_string;
+      EXTENSION_FUNCTION_VALIDATE(ids->GetString(i, &id_string));
+      if (!GetBookmarkIdAsInt64(id_string, &id))
+        return false;
       const BookmarkNode* node = model->GetNodeByID(id);
       if (!node) {
         error_ = keys::kNoNodeError;
@@ -279,8 +293,11 @@ bool GetBookmarksFunction::RunImpl() {
       }
     }
   } else {
-    int id;
-    EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&id));
+    int64 id;
+    std::string id_string;
+    EXTENSION_FUNCTION_VALIDATE(args_->GetAsString(&id_string));
+    if (!GetBookmarkIdAsInt64(id_string, &id))
+      return false;
     const BookmarkNode* node = model->GetNodeByID(id);
     if (!node) {
       error_ = keys::kNoNodeError;
@@ -295,8 +312,11 @@ bool GetBookmarksFunction::RunImpl() {
 
 bool GetBookmarkChildrenFunction::RunImpl() {
   BookmarkModel* model = profile()->GetBookmarkModel();
-  int id;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&id));
+  int64 id;
+  std::string id_string;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetAsString(&id_string));
+  if (!GetBookmarkIdAsInt64(id_string, &id))
+    return false;
   scoped_ptr<ListValue> json(new ListValue());
   const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
@@ -350,8 +370,9 @@ bool RemoveBookmarkFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(1, &recursive));
 
   BookmarkModel* model = profile()->GetBookmarkModel();
-  int id;
-  if (args->GetInteger(0, &id)) {
+  int64 id;
+  std::string id_string;
+  if (args->GetString(0, &id_string) && StringToInt64(id_string, &id)) {
     return ExtensionBookmarks::RemoveNode(model, id, recursive, &error_);
   } else {
     ListValue* ids;
@@ -359,7 +380,9 @@ bool RemoveBookmarkFunction::RunImpl() {
     size_t count = ids->GetSize();
     EXTENSION_FUNCTION_VALIDATE(count > 0);
     for (size_t i = 0; i < count; ++i) {
-      EXTENSION_FUNCTION_VALIDATE(ids->GetInteger(i, &id));
+      EXTENSION_FUNCTION_VALIDATE(ids->GetString(i, &id_string));
+      if (!GetBookmarkIdAsInt64(id_string, &id))
+        return false;
       if (!ExtensionBookmarks::RemoveNode(model, id, recursive, &error_))
         return false;
     }
@@ -372,13 +395,16 @@ bool CreateBookmarkFunction::RunImpl() {
   DictionaryValue* json = static_cast<DictionaryValue*>(args_);
 
   BookmarkModel* model = profile()->GetBookmarkModel();
-  int parentId;
+  int64 parentId;
   if (!json->HasKey(keys::kParentIdKey)) {
     // Optional, default to "other bookmarks".
     parentId = model->other_node()->id();
   } else {
-    EXTENSION_FUNCTION_VALIDATE(json->GetInteger(keys::kParentIdKey,
-                                                 &parentId));
+    std::string parentId_string;
+    EXTENSION_FUNCTION_VALIDATE(json->GetString(keys::kParentIdKey,
+                                                &parentId_string));
+    if (!GetBookmarkIdAsInt64(parentId_string, &parentId))
+      return false;
   }
   const BookmarkNode* parent = model->GetNodeByID(parentId);
   if (!parent) {
@@ -431,8 +457,11 @@ bool CreateBookmarkFunction::RunImpl() {
 bool MoveBookmarkFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_LIST));
   const ListValue* args = static_cast<const ListValue*>(args_);
-  int id;
-  EXTENSION_FUNCTION_VALIDATE(args->GetInteger(0, &id));
+  int64 id;
+  std::string id_string;
+  EXTENSION_FUNCTION_VALIDATE(args->GetString(0, &id_string));
+  if (!GetBookmarkIdAsInt64(id_string, &id))
+    return false;
   DictionaryValue* destination;
   EXTENSION_FUNCTION_VALIDATE(args->GetDictionary(1, &destination));
 
@@ -493,8 +522,11 @@ bool SetBookmarkTitleFunction::RunImpl() {
   json->GetString(keys::kTitleKey, &title);  // Optional (empty is clear).
 
   BookmarkModel* model = profile()->GetBookmarkModel();
-  int id = 0;
-  EXTENSION_FUNCTION_VALIDATE(json->GetInteger(keys::kIdKey, &id));
+  int64 id = 0;
+  std::string id_string;
+  EXTENSION_FUNCTION_VALIDATE(json->GetString(keys::kIdKey, &id_string));
+  if (!GetBookmarkIdAsInt64(id_string, &id))
+    return false;
   const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
diff --git a/chrome/browser/extensions/extension_bookmarks_module.h b/chrome/browser/extensions/extension_bookmarks_module.h
index cfa32de..7cfc1ca2 100644
--- a/chrome/browser/extensions/extension_bookmarks_module.h
+++ b/chrome/browser/extensions/extension_bookmarks_module.h
@@ -70,6 +70,12 @@ class BookmarksFunction : public AsyncExtensionFunction,
   virtual void Run();
   virtual bool RunImpl() = 0;
 
+ protected:
+  // Helper to get the bookmark id as int64 from the given string id.
+  // Sets error_ to an errro string if the given id string can't be parsed
+  // as an int64. In case of error, doesn't change id and returns false.
+  bool GetBookmarkIdAsInt64(const std::string& id_string, int64* id);
+
  private:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
diff --git a/chrome/browser/extensions/extension_bookmarks_module_constants.cc b/chrome/browser/extensions/extension_bookmarks_module_constants.cc
index cdf602d..24d7c92 100644
--- a/chrome/browser/extensions/extension_bookmarks_module_constants.cc
+++ b/chrome/browser/extensions/extension_bookmarks_module_constants.cc
@@ -22,6 +22,7 @@ const char kNoNodeError[] = "Can't find bookmark for id.";
 const char kNoParentError[] = "Can't find parent bookmark for id.";
 const char kFolderNotEmptyError[] =
     "Can't remove non-empty folder (use recursive to force).";
+const char kInvalidIdError[] = "Bookmark id is invalid.";
 const char kInvalidIndexError[] = "Index out of bounds.";
 const char kInvalidUrlError[] = "Invalid URL.";
 const char kModifySpecialError[] = "Can't modify the root bookmark folders.";
diff --git a/chrome/browser/extensions/extension_bookmarks_module_constants.h b/chrome/browser/extensions/extension_bookmarks_module_constants.h
index 3b504e6..665747c 100644
--- a/chrome/browser/extensions/extension_bookmarks_module_constants.h
+++ b/chrome/browser/extensions/extension_bookmarks_module_constants.h
@@ -26,6 +26,7 @@ extern const wchar_t kDateGroupModifiedKey[];
 extern const char kNoNodeError[];
 extern const char kNoParentError[];
 extern const char kFolderNotEmptyError[];
+extern const char kInvalidIdError[];
 extern const char kInvalidIndexError[];
 extern const char kInvalidUrlError[];
 extern const char kModifySpecialError[];
diff --git a/chrome/browser/gtk/bookmark_editor_gtk.cc b/chrome/browser/gtk/bookmark_editor_gtk.cc
index 1a6171c..9824f44 100644
--- a/chrome/browser/gtk/bookmark_editor_gtk.cc
+++ b/chrome/browser/gtk/bookmark_editor_gtk.cc
@@ -152,7 +152,7 @@ void BookmarkEditorGtk::Init(GtkWindow* parent_window) {
 
   if (show_tree_) {
     GtkTreeIter selected_iter;
-    int selected_id = node_ ? node_->GetParent()->id() : 0;
+    int64 selected_id = node_ ? node_->GetParent()->id() : 0;
     tree_store_ = bookmark_utils::MakeFolderTreeStore();
     bookmark_utils::AddToTreeStore(bb_model_, selected_id,
                                    tree_store_, &selected_iter);
@@ -328,7 +328,7 @@ void BookmarkEditorGtk::AddNewGroup(GtkTreeIter* parent, GtkTreeIter* child) {
       bookmark_utils::GetFolderIcon(),
       bookmark_utils::FOLDER_NAME,
       l10n_util::GetStringUTF8(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME).c_str(),
-      bookmark_utils::ITEM_ID, 0,
+      bookmark_utils::ITEM_ID, static_cast<int64>(0),
       -1);
 }
 
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.cc b/chrome/browser/gtk/bookmark_manager_gtk.cc
index d43b422..77a7c6a 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.cc
+++ b/chrome/browser/gtk/bookmark_manager_gtk.cc
@@ -37,8 +37,8 @@ const int kRecentlyBookmarkedCount = 50;
 // IDs for the recently added and search nodes. These values assume that node
 // IDs will be strictly non-negative, which is an implementation detail of
 // BookmarkModel, so this is sort of a hack.
-const int kRecentID = -1;
-const int kSearchID = -2;
+const int64 kRecentID = -1;
+const int64 kSearchID = -2;
 
 // Padding between "Search:" and the entry field, in pixels.
 const int kSearchPadding = 5;
diff --git a/chrome/browser/gtk/bookmark_tree_model.cc b/chrome/browser/gtk/bookmark_tree_model.cc
index ab3b24e..34eedb0 100644
--- a/chrome/browser/gtk/bookmark_tree_model.cc
+++ b/chrome/browser/gtk/bookmark_tree_model.cc
@@ -41,7 +41,7 @@ void RecursiveResolve(BookmarkModel* bb_model, const BookmarkNode* bb_node,
   GtkTreeIter child_iter;
   if (gtk_tree_model_iter_children(tree_model, &child_iter, parent_iter)) {
     do {
-      int id = bookmark_utils::GetIdFromTreeIter(tree_model, &child_iter);
+      int64 id = bookmark_utils::GetIdFromTreeIter(tree_model, &child_iter);
       std::wstring title =
           bookmark_utils::GetTitleFromTreeIter(tree_model, &child_iter);
       const BookmarkNode* child_bb_node = NULL;
@@ -74,10 +74,10 @@ namespace bookmark_utils {
 
 GtkTreeStore* MakeFolderTreeStore() {
   return gtk_tree_store_new(FOLDER_STORE_NUM_COLUMNS, GDK_TYPE_PIXBUF,
-                            G_TYPE_STRING, G_TYPE_INT);
+                            G_TYPE_STRING, G_TYPE_INT64);
 }
 
-void AddToTreeStore(BookmarkModel* model, int selected_id,
+void AddToTreeStore(BookmarkModel* model, int64 selected_id,
                     GtkTreeStore* store, GtkTreeIter* selected_iter) {
   const BookmarkNode* root_node = model->root_node();
   for (int i = 0; i < root_node->GetChildCount(); ++i) {
@@ -86,7 +86,7 @@ void AddToTreeStore(BookmarkModel* model, int selected_id,
   }
 }
 
-void AddToTreeStoreAt(const BookmarkNode* node, int selected_id,
+void AddToTreeStoreAt(const BookmarkNode* node, int64 selected_id,
                       GtkTreeStore* store, GtkTreeIter* selected_iter,
                       GtkTreeIter* parent) {
   if (!node->is_folder())
@@ -128,7 +128,7 @@ const BookmarkNode* CommitTreeStoreDifferencesBetween(
     DCHECK(GetIdFromTreeIter(tree_model, &tree_root) != 0)
         << "It should be impossible to add another toplevel node";
 
-    int id = GetIdFromTreeIter(tree_model, &tree_root);
+    int64 id = GetIdFromTreeIter(tree_model, &tree_root);
     const BookmarkNode* child_node = NULL;
     for (int j = 0; j < root_node->GetChildCount(); ++j) {
       const BookmarkNode* node = root_node->GetChild(j);
@@ -148,12 +148,12 @@ const BookmarkNode* CommitTreeStoreDifferencesBetween(
   return node_to_return;
 }
 
-int GetIdFromTreeIter(GtkTreeModel* model, GtkTreeIter* iter) {
+int64 GetIdFromTreeIter(GtkTreeModel* model, GtkTreeIter* iter) {
   GValue value = { 0, };
-  int ret_val = -1;
+  int64 ret_val = -1;
   gtk_tree_model_get_value(model, iter, ITEM_ID, &value);
-  if (G_VALUE_HOLDS_INT(&value))
-    ret_val = g_value_get_int(&value);
+  if (G_VALUE_HOLDS_INT64(&value))
+    ret_val = g_value_get_int64(&value);
   else
     NOTREACHED() << "Impossible type mismatch";
 
diff --git a/chrome/browser/gtk/bookmark_tree_model.h b/chrome/browser/gtk/bookmark_tree_model.h
index c691212..96e9fd5 100644
--- a/chrome/browser/gtk/bookmark_tree_model.h
+++ b/chrome/browser/gtk/bookmark_tree_model.h
@@ -6,6 +6,7 @@
 #define CHROME_BROWSER_GTK_BOOKMARK_TREE_MODEL_H_
 
 #include <string>
+#include "base/basictypes.h"
 
 class BookmarkModel;
 class BookmarkNode;
@@ -36,12 +37,12 @@ GtkTreeStore* MakeFolderTreeStore();
 // |recursive| indicates whether to recurse into sub-directories (if false,
 // the tree store will effectively be a list). |only_folders| indicates whether
 // to include bookmarks in the tree, or to only show folders.
-void AddToTreeStore(BookmarkModel* model, int selected_id,
+void AddToTreeStore(BookmarkModel* model, int64 selected_id,
                     GtkTreeStore* store, GtkTreeIter* selected_iter);
 
 // As above, but inserts just the tree rooted at |node| as a child of |parent|.
 // If |parent| is NULL, add it at the top level.
-void AddToTreeStoreAt(const BookmarkNode* node, int selected_id,
+void AddToTreeStoreAt(const BookmarkNode* node, int64 selected_id,
                       GtkTreeStore* store, GtkTreeIter* selected_iter,
                       GtkTreeIter* parent);
 
@@ -53,7 +54,7 @@ const BookmarkNode* CommitTreeStoreDifferencesBetween(
     GtkTreeIter* selected);
 
 // Returns the id field of the row pointed to by |iter|.
-int GetIdFromTreeIter(GtkTreeModel* model, GtkTreeIter* iter);
+int64 GetIdFromTreeIter(GtkTreeModel* model, GtkTreeIter* iter);
 
 // Returns the title field of the row pointed to by |iter|.
 std::wstring GetTitleFromTreeIter(GtkTreeModel* model, GtkTreeIter* iter);
diff --git a/chrome/browser/views/bookmark_editor_view.cc b/chrome/browser/views/bookmark_editor_view.cc
index 5843504..9001d2b 100644
--- a/chrome/browser/views/bookmark_editor_view.cc
+++ b/chrome/browser/views/bookmark_editor_view.cc
@@ -443,7 +443,7 @@ void BookmarkEditorView::ExpandAndSelect() {
   tree_view_->ExpandAll();
 
   const BookmarkNode* to_select = node_ ? node_->GetParent() : parent_;
-  int group_id_to_select = to_select->id();
+  int64 group_id_to_select = to_select->id();
   DCHECK(group_id_to_select);  // GetMostRecentParent should never return NULL.
   EditorNode* b_node =
       FindNodeWithID(tree_model_->GetRoot(), group_id_to_select);
@@ -478,7 +478,7 @@ void BookmarkEditorView::CreateNodes(const BookmarkNode* bb_node,
 
 BookmarkEditorView::EditorNode* BookmarkEditorView::FindNodeWithID(
     BookmarkEditorView::EditorNode* node,
-    int id) {
+    int64 id) {
   if (node->value == id)
     return node;
   for (int i = 0; i < node->GetChildCount(); ++i) {
diff --git a/chrome/browser/views/bookmark_editor_view.h b/chrome/browser/views/bookmark_editor_view.h
index a03d3e9..98f5269 100644
--- a/chrome/browser/views/bookmark_editor_view.h
+++ b/chrome/browser/views/bookmark_editor_view.h
@@ -113,7 +113,7 @@ class BookmarkEditorView : public BookmarkEditor,
 
  private:
   // Type of node in the tree.
-  typedef TreeNodeWithValue<int> EditorNode;
+  typedef TreeNodeWithValue<int64> EditorNode;
 
   // Model for the TreeView. Trivial subclass that doesn't allow titles with
   // empty strings.
@@ -175,7 +175,7 @@ class BookmarkEditorView : public BookmarkEditor,
   void CreateNodes(const BookmarkNode* bb_node, EditorNode* b_node);
 
   // Returns the node with the specified id, or NULL if one can't be found.
-  EditorNode* FindNodeWithID(BookmarkEditorView::EditorNode* node, int id);
+  EditorNode* FindNodeWithID(BookmarkEditorView::EditorNode* node, int64 id);
 
   // Invokes ApplyEdits with the selected node.
   void ApplyEdits();