Supporting undoing bookmark deletion without creating new ID.

components/bookmarks/browser/bookmark_model.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// RemvCopyright 2014 The Chromium Authors. All rights reserved.

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

fix

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

Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/bookmarks/browser/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 85 matching lines @@
     : client_(client),
       loaded_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
       mobile_node_(NULL),
       next_node_id_(1),
       observers_(
           base::ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
       loaded_signal_(true, false),
-      extensive_changes_(0) {
+      extensive_changes_(0),
+      undoable_remove_enabled_(false) {
   DCHECK(client_);
 }
 
 BookmarkModel::~BookmarkModel() {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkModelBeingDeleted(this));
 
   if (store_.get()) {
     // The store maintains a reference back to us. We need to tell it we're gone
     // so that it doesn't try and invoke a method back on us again.
     store_->BookmarkModelDeleted();
   }
+
+  DiscardAllUndoableRemovedNodes();
 }
 
 void BookmarkModel::Shutdown() {
   if (loaded_)
     return;
 
   // See comment in HistoryService::ShutdownOnUIThread where this is invoked for
   // details. It is also called when the BookmarkModel is deleted.
   loaded_signal_.Signal();
 }
@@ skipping 332 matching lines @@
     // Rerequest the favicon.
     BookmarkNode* mutable_node = AsMutable(node);
     mutable_node->InvalidateFavicon();
     CancelPendingFaviconLoadRequests(mutable_node);
     FOR_EACH_OBSERVER(BookmarkModelObserver,
                       observers_,
                       BookmarkNodeFaviconChanged(this, node));
   }
 }
 
+void BookmarkModel::EnableUndoableRemove() {
+  undoable_remove_enabled_ = true;
+}
+
+void BookmarkModel::DisableUndoableRemove() {
+  DiscardAllUndoableRemovedNodes();
+  undoable_remove_enabled_ = false;
+}
+
+void BookmarkModel::UndoRemove(int64_t node_id) {
+  DCHECK(undoable_remove_enabled_);
+  auto iter = undoable_deleted_nodes_.find(node_id);
+  if (iter == undoable_deleted_nodes_.end())
+    return;
+  // If the parent node cannot be found, no need to track the deleted node.
+  const BookmarkNode* parent = GetBookmarkNodeByID(
+      this, iter->second.parent_node_id);
+  if (parent)
+    AddNode(AsMutable(parent), iter->second.index, iter->second.node);
+  undoable_deleted_nodes_.erase(iter);
+}
+
+void BookmarkModel::DiscardUndoableRemovedNode(int64_t node_id) {
+  DCHECK(undoable_remove_enabled_);
+  auto iter = undoable_deleted_nodes_.find(node_id);
+  if (iter == undoable_deleted_nodes_.end())
+    return;
+  delete iter->second.node;
+  undoable_deleted_nodes_.erase(iter);
+}
+
+void BookmarkModel::DiscardAllUndoableRemovedNodes() {
+  for (auto iter = undoable_deleted_nodes_.begin();
+       iter != undoable_deleted_nodes_.end(); ++iter) {
+    delete iter->second.node;
+  }
+  undoable_deleted_nodes_.clear();
+}
+
 void BookmarkModel::SetDateAdded(const BookmarkNode* node, Time date_added) {
   DCHECK(node && !is_permanent_node(node));
 
   if (node->date_added() == date_added)
     return;
 
   AsMutable(node)->set_date_added(date_added);
 
   // Syncing might result in dates newer than the folder's last modified date.
   if (date_added > node->parent()->date_folder_modified()) {
@@ skipping 370 matching lines @@
     RemoveNodeAndGetRemovedUrls(node.get(), &removed_urls);
   }
 
   if (store_.get())
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(
       BookmarkModelObserver,
       observers_,
       BookmarkNodeRemoved(this, parent, index, node.get(), removed_urls));
+
+  if (!undoable_remove_enabled_)
+    return;
+  int64_t node_id = node->id();
+  RestorableDeletedNodeInfo restore_info;
+  restore_info.parent_node_id = parent->id();
+  restore_info.index = index;
+  restore_info.node = node.release();
+  undoable_deleted_nodes_[node_id] = restore_info;
 }
 
 void BookmarkModel::RemoveNodeFromInternalMaps(BookmarkNode* node) {
   index_->Remove(node);
   // NOTE: this is called in such a way that url_lock_ is already held. As
   // such, this doesn't explicitly grab the lock.
   url_lock_.AssertAcquired();
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(node);
   DCHECK(i != nodes_ordered_by_url_set_.end());
   // i points to the first node with the URL, advance until we find the
@@ skipping 170 matching lines @@
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
       client_->GetLoadExtraNodesCallback(),
       new BookmarkIndex(client_, accept_languages),
       next_node_id_));
 }
 
 }  // namespace bookmarks