Supporting undoing bookmark deletion without creating new ID.

components/bookmarks/browser/bookmark_model.h

 // Copyright 2014 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 COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_
 #define COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_
 
 #include <stdint.h>
 #include <map>
 #include <set>
@@ skipping 290 matching lines @@
   // http://www.google.com) and the given icon URL (e.g.
   // http://www.google.com/favicon.ico) have changed. It is valid to call
   // OnFaviconsChanged() with non-empty |page_urls| and an empty |icon_url| and
   // vice versa.
   void OnFaviconsChanged(const std::set<GURL>& page_urls,
                          const GURL& icon_url);
 
   // Returns the client used by this BookmarkModel.
   BookmarkClient* client() const { return client_; }
 
+  // Turns on/off the capability to undo removing nodes.
+  void EnableUndoableRemove();

[sky, 2015/10/02 15:40:30]

I think all the bookkeeping of undo should be kept in the undo area. To enable
BookmarkUndoService we should add an interface called BookmarkModelUndoDelegate.
At the appropriate times (remove, insert, change...) BookmarkModel will call
into the BookmarkModelUndoDelegate. 

Why do we need an interface interface? At a minimum this interface is given
ownership of removed nodes. This is unique. No doubt there will be other unique
abilities that need to be given to the BookmarkModelUndoDelegate.

[jianli, 2015/10/06 22:08:24]

Done.

+  void DisableUndoableRemove();
+
+  // Undo deleting the node with |node_id| by putting it back to its original
+  // position.
+  void UndoRemove(int64_t node_id);
+
+  // Throws aways the undo info for the deleted node. After this, the deleted
+  // node can no longer be restored.
+  void DiscardUndoableRemovedNode(int64_t node_id);
+
  private:
   friend class BookmarkCodecTest;
   friend class BookmarkModelFaviconTest;
   friend class BookmarkStorage;
   friend class ScopedGroupBookmarkActions;
   friend class TestBookmarkClient;
 
   // Used to order BookmarkNodes by URL.
   class NodeURLComparator {
    public:
     bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) const {
       return n1->url() < n2->url();
     }
   };
 
+  // Used to track all the info necessary to bring back a deleted node.
+  struct RestorableDeletedNodeInfo {
+    int64_t parent_node_id;
+    int index;
+    BookmarkNode* node;
+  };
+
   // Implementation of IsBookmarked. Before calling this the caller must obtain
   // a lock on |url_lock_|.
   bool IsBookmarkedNoLock(const GURL& url);
 
   // Removes the node from internal maps and recurses through all children. If
   // the node is a url, its url is added to removed_urls.
   //
   // This does NOT delete the node.
   void RemoveNode(BookmarkNode* node, std::set<GURL>* removed_urls);
 
@@ skipping 62 matching lines @@
   // 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 assigns node IDs.
   void set_next_node_id(int64_t id) { next_node_id_ = id; }
 
   // Creates and returns a new BookmarkLoadDetails. It's up to the caller to
   // delete the returned object.
   scoped_ptr<BookmarkLoadDetails> CreateLoadDetails(
       const std::string& accept_languages);
 
+  // Discards all removed nodes that are tracked for restoring.
+  void DiscardAllUndoableRemovedNodes();
+
   BookmarkClient* const client_;
 
   // Whether the initial set of data has been loaded.
   bool loaded_;
 
   // The root node. This contains the bookmark bar node, the 'other' node and
   // the mobile node as children.
   BookmarkNode root_;
 
   BookmarkPermanentNode* bookmark_bar_node_;
@@ skipping 24 matching lines @@
 
   base::WaitableEvent loaded_signal_;
 
   // See description of IsDoingExtensiveChanges above.
   int extensive_changes_;
 
   scoped_ptr<BookmarkExpandedStateTracker> expanded_state_tracker_;
 
   std::set<std::string> non_cloned_keys_;
 
+  // Whether or not to support undoing node removal.
+  bool undoable_remove_enabled_;
+
+  // Tracks those deleted nodes that can be restored by the undo operations.
+  std::map<int64_t, RestorableDeletedNodeInfo> undoable_deleted_nodes_;
+
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
 };
 
 }  // namespace bookmarks
 
 #endif  // COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_