Bookmark Undo service for multiple level undo/redo of bookmarks.

chrome/browser/undo/bookmark_undo_service.cc

+// Copyright 2013 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/undo/bookmark_undo_service.h"
+
+#include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/bookmarks/bookmark_node_data.h"
+#include "chrome/browser/bookmarks/bookmark_utils.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/undo/bookmark_undo_service_factory.h"
+#include "chrome/browser/undo/undo_manager_utils.h"
+#include "chrome/browser/undo/undo_operation.h"
+
+namespace {
+
+// Helper to get a mutable bookmark node.
+BookmarkNode* AsMutable(const BookmarkNode* node) {
+  return const_cast<BookmarkNode*>(node);
+}
+
+// RenumberBookmarkIdFunctor --------------------------------------------------
+
+class RenumberBookmarkIdFunctor {

[sky, 2013/07/26 15:35:42]

Please add a description.

[Tom Cassiotis, 2013/08/06 18:46:11]

Code removed.

+ public:
+  RenumberBookmarkIdFunctor(int64 old_id, int64 new_id);
+  void operator()(UndoOperation* undo_object);
+
+ private:
+  int64 old_id_;
+  int64 new_id_;
+};
+
+// BookmarkUndoOperation ------------------------------------------------------
+
+// Base class for all bookmark related UndoOperations that facilitates access to
+// the BookmarkUndoService.
+class BookmarkUndoOperation : public UndoOperation {
+ public:
+  explicit BookmarkUndoOperation(Profile* profile);
+  virtual ~BookmarkUndoOperation() {}
+
+  virtual void RenumberBookmarkId(int64 old_id, int64 new_id) = 0;

[sky, 2013/07/26 15:35:42]

Description here too. In general you want descriptions for all non-obvious
classes methods and members.

[Tom Cassiotis, 2013/08/06 18:46:11]

Done.

+
+  BookmarkModel* GetBookmarkModel() const;
+  BookmarkUndoService* GetBookmarkUndoService() const;
+
+ private:
+  Profile* profile_;
+};
+
+BookmarkUndoOperation::BookmarkUndoOperation(Profile* profile)
+    : profile_(profile) {
+}
+
+BookmarkModel* BookmarkUndoOperation::GetBookmarkModel() const {
+  return BookmarkModelFactory::GetForProfile(profile_);
+}
+
+BookmarkUndoService* BookmarkUndoOperation::GetBookmarkUndoService() const {
+  return BookmarkUndoServiceFactory::GetForProfile(profile_);
+}
+
+// RenumberBookmarkIdFunctor --------------------------------------------------
+
+RenumberBookmarkIdFunctor::RenumberBookmarkIdFunctor(int64 old_id, int64 new_id)
+    : old_id_(old_id),
+      new_id_(new_id) {
+}
+
+void RenumberBookmarkIdFunctor::operator()(UndoOperation* undo_operation) {
+  BookmarkUndoOperation* bookmark_operation =
+      static_cast<BookmarkUndoOperation*>(undo_operation);
+  bookmark_operation->RenumberBookmarkId(old_id_, new_id_);
+}
+
+// BookmarkAddOperation -------------------------------------------------------
+
+// Handles the undo of the insertion of a bookmark or folder.
+class BookmarkAddOperation : public BookmarkUndoOperation {
+ public:
+  BookmarkAddOperation(Profile* profile, const BookmarkNode* parent, int index);
+  virtual ~BookmarkAddOperation() {}
+
+  // UndoOperation:
+  virtual void Undo() OVERRIDE;
+
+  // BookmarkUndoOperation:
+  virtual void RenumberBookmarkId(int64 old_id, int64 new_id) OVERRIDE;
+
+ private:
+  int64 parent_id_;
+  int index_;
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkAddOperation);
+};
+
+BookmarkAddOperation::BookmarkAddOperation(Profile* profile,
+                                           const BookmarkNode* parent,
+                                           int index)
+  : BookmarkUndoOperation(profile),
+    parent_id_(parent->id()),
+    index_(index) {
+}
+
+void BookmarkAddOperation::Undo() {
+  BookmarkModel* model = GetBookmarkModel();
+  const BookmarkNode* parent = model->GetNodeByID(parent_id_);
+  DCHECK(parent);
+
+  model->Remove(parent, index_);
+}
+
+void BookmarkAddOperation::RenumberBookmarkId(int64 old_id, int64 new_id) {
+  if (parent_id_ == old_id)
+    parent_id_ = new_id;
+}
+
+// BookmarkRemoveOperation ----------------------------------------------------
+
+// Handles the undo of the deletion of a bookmark node. For a bookmark folder,
+// the information for all descendant bookmark nodes is maintained.
+//
+// The BookmarkModel allows only single bookmark node to be removed.
+class BookmarkRemoveOperation : public BookmarkUndoOperation {
+ public:
+  BookmarkRemoveOperation(Profile* profile,
+                          const BookmarkNode* parent,
+                          int old_index,
+                          const BookmarkNode* node);
+  virtual ~BookmarkRemoveOperation() {}
+
+  // UndoOperation:
+  virtual void Undo() OVERRIDE;
+
+  // BookmarkUndoOperation:
+  virtual void RenumberBookmarkId(int64 old_id, int64 new_id) OVERRIDE;
+
+ private:
+  void GetNewBookmarkIds(const BookmarkNodeData::Element& element,
+                         const BookmarkNode* parent,
+                         int index_added_at) const;
+
+  int64 parent_id_;
+  int old_index_;
+  BookmarkNodeData removed_node_;
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkRemoveOperation);
+};
+
+BookmarkRemoveOperation::BookmarkRemoveOperation(Profile* profile,
+                                                 const BookmarkNode* parent,
+                                                 int old_index,
+                                                 const BookmarkNode* node)
+  : BookmarkUndoOperation(profile),
+    parent_id_(parent->id()),
+    old_index_(old_index),
+    removed_node_(node) {
+}
+
+void BookmarkRemoveOperation::Undo() {
+  DCHECK(removed_node_.is_valid());
+  BookmarkModel* model = GetBookmarkModel();
+  const BookmarkNode* parent = model->GetNodeByID(parent_id_);
+  DCHECK(parent);
+
+  bookmark_utils::CloneBookmarkNode(model,
+                                    removed_node_.elements,
+                                    parent,
+                                    old_index_);
+  GetNewBookmarkIds(removed_node_.elements[0], parent, old_index_);
+}
+
+void BookmarkRemoveOperation::GetNewBookmarkIds(
+    const BookmarkNodeData::Element& element,
+    const BookmarkNode* parent,
+    int index_added_at) const {
+  BookmarkModel* model = GetBookmarkModel();
+  BookmarkUndoService* undo_service = GetBookmarkUndoService();
+
+  const BookmarkNode* node = parent->GetChild(index_added_at);
+  if (element.id() != node->id()) {
+    RenumberBookmarkIdFunctor fn(element.id(), node->id());
+    undo_service->undo_manager()->ForEachUndoOperation(fn);
+  }
+  if (!element.is_url) {
+    for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
+      GetNewBookmarkIds(element.children[i], node, 0);
+  }
+}
+
+void BookmarkRemoveOperation::RenumberBookmarkId(int64 old_id, int64 new_id) {
+  if (parent_id_ == old_id)
+    parent_id_ = new_id;
+}
+
+// BookmarkEditOperation ------------------------------------------------------
+
+// Handles the undo of the modification of a bookmark node.
+class BookmarkEditOperation : public BookmarkUndoOperation {
+ public:
+  BookmarkEditOperation(Profile* profile,
+                        const BookmarkNode* node);
+  virtual ~BookmarkEditOperation() {}
+
+  // UndoOperation:
+  virtual void Undo() OVERRIDE;
+
+  // BookmarkUndoOperation:
+  virtual void RenumberBookmarkId(int64 old_id, int64 new_id) OVERRIDE;
+
+ private:
+  int64 node_id_;
+  BookmarkNodeData original_bookmark_;
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkEditOperation);
+};
+
+BookmarkEditOperation::BookmarkEditOperation(Profile* profile,
+                                             const BookmarkNode* node)
+    : BookmarkUndoOperation(profile),
+      node_id_(node->id()),
+      original_bookmark_(node) {
+}
+
+void BookmarkEditOperation::Undo() {
+  DCHECK(original_bookmark_.is_valid());
+  BookmarkModel* model = GetBookmarkModel();
+  const BookmarkNode* node = model->GetNodeByID(node_id_);
+  DCHECK(node);
+
+  model->SetTitle(node, original_bookmark_.elements[0].title);
+  if (original_bookmark_.elements[0].is_url)
+     model->SetURL(node, original_bookmark_.elements[0].url);
+}
+
+void BookmarkEditOperation::RenumberBookmarkId(int64 old_id, int64 new_id) {
+  if (node_id_ == old_id)
+    node_id_ = new_id;
+}
+
+// BookmarkMoveOperation ------------------------------------------------------
+
+// Handles the undo of a bookmark being moved to a new location.
+class BookmarkMoveOperation : public BookmarkUndoOperation {
+ public:
+  BookmarkMoveOperation(Profile* profile,
+                        const BookmarkNode* old_parent,
+                        int old_index,
+                        const BookmarkNode* new_parent,
+                        int new_index);
+  virtual ~BookmarkMoveOperation() {}
+
+  // UndoOperation:
+  virtual void Undo() OVERRIDE;
+
+  // BookmarkUndoOperation:
+  virtual void RenumberBookmarkId(int64 old_id, int64 new_id) OVERRIDE;
+
+ private:
+  int64 old_parent_id_;
+  int64 new_parent_id_;
+  int old_index_;
+  int new_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkMoveOperation);
+};
+
+BookmarkMoveOperation::BookmarkMoveOperation(Profile* profile,
+                                             const BookmarkNode* old_parent,
+                                             int old_index,
+                                             const BookmarkNode* new_parent,
+                                             int new_index)
+    : BookmarkUndoOperation(profile),
+      old_parent_id_(old_parent->id()),
+      old_index_(old_index),
+      new_parent_id_(new_parent->id()),
+      new_index_(new_index) {
+}
+
+void BookmarkMoveOperation::Undo() {
+  BookmarkModel* model = GetBookmarkModel();
+  const BookmarkNode* old_parent = model->GetNodeByID(old_parent_id_);
+  const BookmarkNode* new_parent = model->GetNodeByID(new_parent_id_);
+  DCHECK(old_parent);
+  DCHECK(new_parent);
+
+  const BookmarkNode* node = new_parent->GetChild(new_index_);
+  int destination_index = old_index_;
+
+  // If the bookmark was moved up within the same parent then the destination
+  // index needs to be incremented since the old index did not account for the
+  // moved bookmark.
+  if (old_parent == new_parent && new_index_ < old_index_)
+    ++destination_index;
+
+  model->Move(node, old_parent, destination_index);
+}
+
+void BookmarkMoveOperation::RenumberBookmarkId(int64 old_id, int64 new_id) {
+  if (old_parent_id_ == old_id)
+    old_parent_id_ = new_id;
+  if (new_parent_id_ == old_id)
+    new_parent_id_ = new_id;
+}
+
+// BookmarkReorderOperation ---------------------------------------------------
+
+// Handle the undo of reordering of bookmarks that can happen as a result of
+// sorting a bookmark folder by name or the undo of that operation.  The change
+// of order is not recursive so only the order of the immediate children of the
+// folder need to be restored.
+class BookmarkReorderOperation : public BookmarkUndoOperation {
+ public:
+  BookmarkReorderOperation(Profile* profile,
+                           const BookmarkNode* parent);
+  virtual ~BookmarkReorderOperation();
+
+  // UndoOperation:
+  virtual void Undo() OVERRIDE;
+
+  // BookmarkUndoOperation:
+  virtual void RenumberBookmarkId(int64 old_id, int64 new_id) OVERRIDE;
+
+ private:
+  int64 parent_id_;
+  std::vector<int64> ordered_bookmarks_;
+
+  DISALLOW_COPY_AND_ASSIGN(BookmarkReorderOperation);
+};
+
+BookmarkReorderOperation::BookmarkReorderOperation(Profile* profile,
+                                                   const BookmarkNode* parent)
+    : BookmarkUndoOperation(profile),
+      parent_id_(parent->id()) {
+  ordered_bookmarks_.resize(parent->child_count());
+  for (int i = 0; i < parent->child_count(); ++i)
+    ordered_bookmarks_[i] = parent->GetChild(i)->id();
+}
+
+BookmarkReorderOperation::~BookmarkReorderOperation() {
+}
+
+void BookmarkReorderOperation::Undo() {
+  BookmarkModel* model = GetBookmarkModel();
+  const BookmarkNode* parent = model->GetNodeByID(parent_id_);
+  DCHECK(parent);
+
+  std::vector<BookmarkNode*> ordered_nodes;
+  for (size_t i = 0; i < ordered_bookmarks_.size(); ++i) {
+    const BookmarkNode* node = model->GetNodeByID(ordered_bookmarks_[i]);
+    ordered_nodes.push_back(AsMutable(node));
+  }
+
+  model->ReorderChildren(parent, ordered_nodes);
+}
+
+void BookmarkReorderOperation::RenumberBookmarkId(int64 old_id, int64 new_id) {
+  if (parent_id_ == old_id)
+    parent_id_ = new_id;
+}
+
+}  // namespace
+
+// BookmarkUndoService --------------------------------------------------------
+
+BookmarkUndoService::BookmarkUndoService(Profile* profile) : profile_(profile) {
+  BookmarkModelFactory::GetForProfile(profile_)->AddObserver(this);
+}
+
+BookmarkUndoService::~BookmarkUndoService() {
+  BookmarkModelFactory::GetForProfile(profile_)->RemoveObserver(this);
+}
+
+void BookmarkUndoService::Loaded(BookmarkModel* model, bool ids_reassigned) {
+  undo_manager_.Reset();
+}
+
+void BookmarkUndoService::BookmarkModelBeingDeleted(BookmarkModel* model) {
+  undo_manager_.Reset();
+}
+
+void BookmarkUndoService::BookmarkNodeMoved(BookmarkModel* model,
+                                            const BookmarkNode* old_parent,
+                                            int old_index,
+                                            const BookmarkNode* new_parent,
+                                            int new_index) {
+  scoped_ptr<UndoOperation> op(new BookmarkMoveOperation(profile_,
+                                                         old_parent,
+                                                         old_index,
+                                                         new_parent,
+                                                         new_index));
+  undo_manager()->AddUndoOperation(op.Pass());
+}
+
+void BookmarkUndoService::BookmarkNodeAdded(BookmarkModel* model,
+                                            const BookmarkNode* parent,
+                                            int index) {
+  scoped_ptr<UndoOperation> op(new BookmarkAddOperation(profile_,
+                                                        parent,
+                                                        index));
+  undo_manager()->AddUndoOperation(op.Pass());
+}
+
+void BookmarkUndoService::OnWillRemoveBookmarks(BookmarkModel* model,
+                                                const BookmarkNode* parent,
+                                                int old_index,
+                                                const BookmarkNode* node) {
+  scoped_ptr<UndoOperation> op(new BookmarkRemoveOperation(profile_,
+                                                           parent,
+                                                           old_index,
+                                                           node));
+  undo_manager()->AddUndoOperation(op.Pass());
+}
+
+void BookmarkUndoService::OnWillRemoveAllBookmarks(BookmarkModel* model) {
+  ScopedGroupingAction merge_removes(undo_manager());
+  for (int i = 0; i < model->root_node()->child_count(); ++i) {
+    const BookmarkNode* permanent_node = model->root_node()->GetChild(i);
+    for (int j = permanent_node->child_count() - 1; j >= 0; --j) {
+      scoped_ptr<UndoOperation> op(new BookmarkRemoveOperation(profile_,
+          permanent_node, j, permanent_node->GetChild(j)));
+      undo_manager()->AddUndoOperation(op.Pass());
+    }
+  }
+}
+
+void BookmarkUndoService::OnWillChangeBookmarkNode(BookmarkModel* model,
+                                                   const BookmarkNode* node) {
+  scoped_ptr<UndoOperation> op(new BookmarkEditOperation(profile_, node));
+  undo_manager()->AddUndoOperation(op.Pass());
+}
+
+void BookmarkUndoService::OnWillReorderBookmarkNode(BookmarkModel* model,
+                                                    const BookmarkNode* node) {
+  scoped_ptr<UndoOperation> op(new BookmarkReorderOperation(profile_, node));
+  undo_manager()->AddUndoOperation(op.Pass());
+}