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"
@@ skipping 314 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 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();
@@ skipping 17 matching lines @@
   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 205 matching lines @@
   GURL url("http://foo.com");
   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();
+
   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());
 }
 
 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 673 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