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

chrome/browser/bookmarks/bookmark_storage.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/bookmarks/bookmark_storage.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/json_writer.h"
@@ skipping 50 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FileDeleteTask);
 };
 
 }  // namespace
 
 class BookmarkStorage::LoadTask : public Task {
  public:
   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() {
     bool bookmark_file_exists = file_util::PathExists(path_);
     if (bookmark_file_exists) {
       JSONFileValueSerializer serializer(path_);
       scoped_ptr<Value> root(serializer.Deserialize(NULL));
 
       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);
 
         start_time = TimeTicks::Now();
         AddBookmarksToIndex(details_->bb_node());
         AddBookmarksToIndex(details_->other_folder_node());
         UMA_HISTOGRAM_TIMES("Bookmarks.CreateBookmarkIndexTime",
                             TimeTicks::Now() - start_time);
       }
     }
@@ skipping 15 matching lines @@
     } else {
       for (int i = 0; i < node->GetChildCount(); ++i)
         AddBookmarksToIndex(node->GetChild(i));
     }
   }
 
   const FilePath path_;
   MessageLoop* loop_;
   scoped_refptr<BookmarkStorage> storage_;
   LoadDetails* details_;
-  bool persist_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadTask);
 };
 
 // BookmarkStorage -------------------------------------------------------------
 
 BookmarkStorage::BookmarkStorage(Profile* profile, BookmarkModel* model)
     : profile_(profile),
       model_(model),
       backend_thread_(g_browser_process->file_thread()),
@@ skipping 14 matching lines @@
   DCHECK(!details_.get());
   DCHECK(details);
   details_.reset(details);
   DoLoadBookmarks(writer_.path());
 }
 
 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);
 }
 
 void BookmarkStorage::MigrateFromHistory() {
   // We need to wait until history has finished loading before reading
   // from generated bookmarks file.
   HistoryService* history =
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (!history) {
     // This happens in unit tests.
@@ skipping 25 matching lines @@
 
 void BookmarkStorage::BookmarkModelDeleted() {
   // We need to save now as otherwise by the time SaveNow is invoked
   // the model is gone.
   if (writer_.HasPendingWrite())
     SaveNow();
   model_ = NULL;
 }
 
 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);
   return serializer.Serialize(*(value.get()));
 }
 
 void BookmarkStorage::OnLoadFinished(bool file_exists, const FilePath& path) {
   if (path == writer_.path() && !file_exists) {
     // The file doesn't exist. This means one of two things:
     // 1. A clean profile.
@@ skipping 50 matching lines @@
 }
 
 void BookmarkStorage::RunTaskOnBackendThread(Task* task) const {
   if (backend_thread()) {
     backend_thread()->message_loop()->PostTask(FROM_HERE, task);
   } else {
     task->Run();
     delete task;
   }
 }