Supporting undoing bookmark deletion without creating new ID.

components/bookmarks/browser/bookmark_model_unittest.cc

 // 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.
 
 #include "components/bookmarks/browser/bookmark_model.h"
 
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
+#include "components/bookmarks/browser/bookmark_undo_delegate.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
 #include "components/favicon_base/favicon_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "ui/base/models/tree_node_model.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
@@ skipping 173 matching lines @@
 }
 
 void VerifyNoDuplicateIDs(BookmarkModel* model) {
   ui::TreeNodeIterator<const BookmarkNode> it(model->root_node());
   base::hash_set<int64_t> ids;
   while (it.has_next())
     ASSERT_TRUE(ids.insert(it.Next()->id()).second);
 }
 
 class BookmarkModelTest : public testing::Test,
-                          public BookmarkModelObserver {
+                          public BookmarkModelObserver,
+                          public BookmarkUndoDelegate {
  public:
   struct ObserverDetails {
     ObserverDetails() {
       Set(NULL, NULL, -1, -1);
     }
 
     void Set(const BookmarkNode* node1,
              const BookmarkNode* node2,
              int index1,
              int index2) {
@@ skipping 13 matching lines @@
       EXPECT_EQ(index2_, index2);
     }
 
    private:
     const BookmarkNode* node1_;
     const BookmarkNode* node2_;
     int index1_;
     int index2_;
   };
 
+  struct NodeRemovalDetail {
+    NodeRemovalDetail(const BookmarkNode* parent,
+                      int index,
+                      const BookmarkNode* node)
+        : parent_node_id(parent->id()), index(index), node_id(node->id()) {}
+
+    bool operator==(const NodeRemovalDetail& other) const {
+      return parent_node_id == other.parent_node_id &&
+             index == other.index &&
+             node_id == other.node_id;
+    }
+
+    int64_t parent_node_id;
+    int index;
+    int64_t node_id;
+  };
+
   BookmarkModelTest() : model_(client_.CreateModel()) {
     model_->AddObserver(this);
     ClearCounts();
   }
 
   void BookmarkModelLoaded(BookmarkModel* model, bool ids_reassigned) override {
     // We never load from the db, so that this should never get invoked.
     NOTREACHED();
   }
 
@@ skipping 13 matching lines @@
     observer_details_.Set(parent, NULL, index, -1);
   }
 
   void OnWillRemoveBookmarks(BookmarkModel* model,
                              const BookmarkNode* parent,
                              int old_index,
                              const BookmarkNode* node) override {
     ++before_remove_count_;
   }
 
+  void SetUndoProvider(BookmarkUndoProvider* provider) override {}
+
   void BookmarkNodeRemoved(BookmarkModel* model,
                            const BookmarkNode* parent,
                            int old_index,
                            const BookmarkNode* node,
                            const std::set<GURL>& removed_urls) override {
     ++removed_count_;
     observer_details_.Set(parent, NULL, old_index, -1);
   }
 
   void BookmarkNodeChanged(BookmarkModel* model,
@@ skipping 34 matching lines @@
   void BookmarkAllUserNodesRemoved(
       BookmarkModel* model,
       const std::set<GURL>& removed_urls) override {
     ++all_bookmarks_removed_;
   }
 
   void OnWillRemoveAllUserBookmarks(BookmarkModel* model) override {
     ++before_remove_all_count_;
   }
 
+  void GroupedBookmarkChangesBeginning(BookmarkModel* model) override {
+    ++grouped_changes_beginning_count_;
+  }
+
+  void GroupedBookmarkChangesEnded(BookmarkModel* model) override {
+    ++grouped_changes_ended_count_;
+  }
+
+  void OnBookmarkNodeRemoved(BookmarkModel* model,
+                             const BookmarkNode* parent,
+                             int index,
+                             scoped_ptr<BookmarkNode> node) override {
+    node_removal_details_.push_back(
+        NodeRemovalDetail(parent, index, node.get()));
+  }
+
   void ClearCounts() {
     added_count_ = moved_count_ = removed_count_ = changed_count_ =
         reordered_count_ = extensive_changes_beginning_count_ =
         extensive_changes_ended_count_ = all_bookmarks_removed_ =
         before_remove_count_ = before_change_count_ = before_reorder_count_ =
-        before_remove_all_count_ = 0;
+        before_remove_all_count_ = grouped_changes_beginning_count_ =
+        grouped_changes_ended_count_ = 0;
   }
 
   void AssertObserverCount(int added_count,
                            int moved_count,
                            int removed_count,
                            int changed_count,
                            int reordered_count,
                            int before_remove_count,
                            int before_change_count,
                            int before_reorder_count,
@@ skipping 10 matching lines @@
   }
 
   void AssertExtensiveChangesObserverCount(
       int extensive_changes_beginning_count,
       int extensive_changes_ended_count) {
     EXPECT_EQ(extensive_changes_beginning_count,
               extensive_changes_beginning_count_);
     EXPECT_EQ(extensive_changes_ended_count, extensive_changes_ended_count_);
   }
 
+  void AssertGroupedChangesObserverCount(
+      int grouped_changes_beginning_count,
+      int grouped_changes_ended_count) {
+    EXPECT_EQ(grouped_changes_beginning_count,
+              grouped_changes_beginning_count_);
+    EXPECT_EQ(grouped_changes_ended_count, grouped_changes_ended_count_);
+  }
+
   int AllNodesRemovedObserverCount() const { return all_bookmarks_removed_; }
 
   BookmarkPermanentNode* ReloadModelWithExtraNode() {
     BookmarkPermanentNode* extra_node = new BookmarkPermanentNode(100);
     BookmarkPermanentNodeList extra_nodes;
     extra_nodes.push_back(extra_node);
     client_.SetExtraNodesToLoad(extra_nodes.Pass());
 
     model_->RemoveObserver(this);
     model_ = client_.CreateModel();
     model_->AddObserver(this);
     ClearCounts();
 
     if (model_->root_node()->GetIndexOf(extra_node) == -1)
       ADD_FAILURE();
 
     return extra_node;
   }
 
  protected:
   TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
   ObserverDetails observer_details_;
+  std::vector<NodeRemovalDetail> node_removal_details_;
 
  private:
   int added_count_;
   int moved_count_;
   int removed_count_;
   int changed_count_;
   int reordered_count_;
   int extensive_changes_beginning_count_;
   int extensive_changes_ended_count_;
   int all_bookmarks_removed_;
   int before_remove_count_;
   int before_change_count_;
   int before_reorder_count_;
   int before_remove_all_count_;
+  int grouped_changes_beginning_count_;
+  int grouped_changes_ended_count_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModelTest);
 };
 
 TEST_F(BookmarkModelTest, InitialState) {
   const BookmarkNode* bb_node = model_->bookmark_bar_node();
   ASSERT_TRUE(bb_node != NULL);
   EXPECT_EQ(0, bb_node->child_count());
   EXPECT_EQ(BookmarkNode::BOOKMARK_BAR, bb_node->type());
 
@@ skipping 196 matching lines @@
 }
 
 TEST_F(BookmarkModelTest, RemoveAllUserBookmarks) {
   const BookmarkNode* bookmark_bar_node = model_->bookmark_bar_node();
 
   ClearCounts();
 
   // Add a url to bookmark bar.
   base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
-  model_->AddURL(bookmark_bar_node, 0, title, url);
+  const BookmarkNode* url_node =
+      model_->AddURL(bookmark_bar_node, 0, title, url);
 
   // Add a folder with child URL.
   const BookmarkNode* folder = model_->AddFolder(bookmark_bar_node, 0, title);
   model_->AddURL(folder, 0, title, url);
 
   AssertObserverCount(3, 0, 0, 0, 0, 0, 0, 0, 0);
   ClearCounts();
 
+  int permanent_node_count = model_->root_node()->child_count();
+
+  NodeRemovalDetail expected_node_removal_details[] = {
+    NodeRemovalDetail(bookmark_bar_node, 1, url_node),
+    NodeRemovalDetail(bookmark_bar_node, 0, folder),
+  };
+
+  model_->SetUndoDelegate(this);
   model_->RemoveAllUserBookmarks();
 
   EXPECT_EQ(0, bookmark_bar_node->child_count());
+  // No permanent node should be removed.
+  EXPECT_EQ(permanent_node_count, model_->root_node()->child_count());
   // No individual BookmarkNodeRemoved events are fired, so removed count
   // should be 0.
   AssertObserverCount(0, 0, 0, 0, 0, 0, 0, 0, 1);
   AssertExtensiveChangesObserverCount(1, 1);
+  AssertGroupedChangesObserverCount(1, 1);
   EXPECT_EQ(1, AllNodesRemovedObserverCount());
+  EXPECT_EQ(1, AllNodesRemovedObserverCount());
+  ASSERT_EQ(2u, node_removal_details_.size());
+  EXPECT_EQ(expected_node_removal_details[0], node_removal_details_[0]);
+  EXPECT_EQ(expected_node_removal_details[1], node_removal_details_[1]);
 }
 
 TEST_F(BookmarkModelTest, SetTitle) {
   const BookmarkNode* root = model_->bookmark_bar_node();
   base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   const BookmarkNode* node = model_->AddURL(root, 0, title, url);
 
   ClearCounts();
 
@@ skipping 672 matching lines @@
     std::set<GURL> changed_page_urls;
     changed_page_urls.insert(kPageURL1);
     model_->OnFaviconsChanged(changed_page_urls, kFaviconURL12);
     ASSERT_EQ(2u, updated_nodes_.size());
     EXPECT_TRUE(WasNodeUpdated(node1));
     EXPECT_TRUE(WasNodeUpdated(node2));
   }
 }
 
 }  // namespace bookmarks