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

chrome/browser/bookmarks/bookmark_model.h

 // 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.
 
 #ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_
 #define CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_
 
 #include "build/build_config.h"
 
 #include <set>
@@ skipping 35 matching lines @@
  public:
   enum Type {
     URL,
     FOLDER,
     BOOKMARK_BAR,
     OTHER_NODE
   };
   // 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_; }
   void SetType(BookmarkNode::Type type) { type_ = type; }
 
   // Returns the time the bookmark/group was added.
   const base::Time& date_added() const { return date_added_; }
   // Sets the time the bookmark/group was added.
   void set_date_added(const base::Time& date) { date_added_ = date; }
 
@@ skipping 40 matching lines @@
 
   // Resets the properties of the node from the supplied entry.
   // This is used by the bookmark model and not really useful outside of it.
   void Reset(const history::StarredEntry& entry);
 
   // TODO(sky): Consider adding last visit time here, it'll greatly simplify
   // HistoryContentsProvider.
 
  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_;
 
   // The favicon.
   SkBitmap favicon_;
 
   // If non-zero, it indicates we're loading the favicon and this is the handle
   // from the HistoryService.
   HistoryService::Handle favicon_load_handle_;
@@ skipping 142 matching lines @@
   // Returns true if there is a bookmark for the specified URL. This method is
   // thread safe. See BookmarkService for more details on this.
   virtual bool IsBookmarked(const GURL& url);
 
   // Blocks until loaded; this is NOT invoked on the main thread. See
   // BookmarkService for more details on this.
   virtual void BlockTillLoaded();
 
   // 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,
                                int index,
                                const std::wstring& title);
 
   // Adds a url at the specified position.
   const BookmarkNode* AddURL(const BookmarkNode* parent,
                              int index,
                              const std::wstring& title,
@@ skipping 42 matching lines @@
     return is_root(node) ||
            is_bookmark_bar_node(node) ||
            is_other_bookmarks_node(node);
   }
 
   // Sets the store to NULL, making it so the BookmarkModel does not persist
   // any changes to disk. This is only useful during testing to speed up
   // 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_; }
 
  private:
   // Used to order BookmarkNodes by URL.
   class NodeURLComparator {
    public:
     bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) const {
       return n1->GetURL() < n2->GetURL();
     }
@@ skipping 25 matching lines @@
 
   // Adds the node at the specified position and sends notification. If
   // was_bookmarked is true, it indicates a bookmark already existed for the
   // URL.
   BookmarkNode* AddNode(BookmarkNode* parent,
                         int index,
                         BookmarkNode* node,
                         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);
 
   // Sets the date modified time of the specified node.
   void SetDateGroupModified(const BookmarkNode* parent, const base::Time time);
 
   // Creates the bookmark bar/other nodes. These call into
   // CreateRootNodeFromStarredEntry.
   BookmarkNode* CreateBookmarkNode();
@@ skipping 19 matching lines @@
 
   // If we're waiting on a favicon for node, the load request is canceled.
   void CancelPendingFavIconLoadRequests(BookmarkNode* node);
 
   // NotificationObserver.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        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();
 
   // Creates and returns a new LoadDetails. It's up to the caller to delete
   // the returned object.
   BookmarkStorage::LoadDetails* CreateLoadDetails();
 
-  // Registers bookmarks related prefs.
-  void RegisterPreferences();
-  // Loads bookmark related preferences.
-  void LoadPreferences();
-
   NotificationRegistrar registrar_;
 
   Profile* profile_;
 
   // 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_;
 
   // The root node. This contains the bookmark bar node and the 'other' node as
   // children.
   BookmarkNode root_;
 
   BookmarkNode* bookmark_bar_node_;
   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_;
 
   // Set of nodes ordered by URL. This is not a map to avoid copying the
   // urls.
   // WARNING: nodes_ordered_by_url_set_ is accessed on multiple threads. As
   // such, be sure and wrap all usage of it around url_lock_.
   typedef std::multiset<BookmarkNode*, NodeURLComparator> NodesOrderedByURLSet;
   NodesOrderedByURLSet nodes_ordered_by_url_set_;
   Lock url_lock_;
 
   // Used for loading favicons and the empty history request.
   CancelableRequestConsumerTSimple<BookmarkNode*> load_consumer_;
 
   // Reads/writes bookmarks to disk.
   scoped_refptr<BookmarkStorage> store_;
 
   scoped_ptr<BookmarkIndex> index_;
 
   base::WaitableEvent loaded_signal_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
 };
 
 #endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_