Eliminate Bookmarks dependence to bookmark_undo_utils.h.

chrome/browser/bookmarks/bookmark_utils_unittest.cc

 // Copyright (c) 2012 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/bookmarks/bookmark_utils.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 
 using base::ASCIIToUTF16;
 using std::string;
 
 namespace bookmark_utils {
 namespace {
 
-class BookmarkUtilsTest : public ::testing::Test {
- public:
+class BookmarkUtilsTest : public ::testing::Test,
+                          public BaseBookmarkModelObserver {
+public:

[tfarina, 2014/02/21 18:46:47]

please, sync your checkout.

also, please, run clang-format on it.

[Tom Cassiotis, 2014/02/22 04:29:35]

Done.

+  BookmarkUtilsTest() {
+    ClearCounts();
+  }
+
   virtual void TearDown() OVERRIDE {
     ui::Clipboard::DestroyClipboardForCurrentThread();
   }
 
+  void ClearCounts() {
+    grouped_changes_beginning_count_ = grouped_changes_ended_count_ = 0;
+  }
+
+  void AssertGroupedChangesObserverCount(int expected_beginning_count,

[sky, 2014/02/06 17:48:27]

ExpectedGroupChanges...

[Tom Cassiotis, 2014/02/21 17:51:45]

Added 'Assert' so it come out as AssertExpectedGroupChanges.  It is consistent
with the naming in bookmark_model_unittest.cc (AssertObserverCount).  Is that
okay?

Done.

[tfarina, 2014/02/21 18:46:47]

I'd say Scott suggested Expected* because this method is using EXPECT macros
rather than ASSERT ones.

[Tom Cassiotis, 2014/02/22 04:29:35]

Sorry for the misunderstanding. 

Done.

+                                         int expected_ended_count) {
+    EXPECT_EQ(grouped_changes_beginning_count_, expected_beginning_count);
+    EXPECT_EQ(grouped_changes_ended_count_, expected_ended_count);
+  }
+
+  // BookmarkModelObserver:
+  virtual void BookmarkModelChanged() OVERRIDE {}
+
+  virtual void GroupedBookmarkChangesBeginning(BookmarkModel* model) OVERRIDE {
+    ++grouped_changes_beginning_count_;
+  }
+
+  virtual void GroupedBookmarkChangesEnded(BookmarkModel* model) OVERRIDE {
+    ++grouped_changes_ended_count_;
+  }
+
  private:
+  int grouped_changes_beginning_count_;
+  int grouped_changes_ended_count_;
+
   // Clipboard requires a message loop.
   base::MessageLoopForUI loop;
 };
 
 TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesWordPhraseQuery) {
   BookmarkModel model(NULL);
   const BookmarkNode* node1 = model.AddURL(model.other_node(),
                                            0,
                                            ASCIIToUTF16("foo bar"),
                                            GURL("http://www.google.com"));
@@ skipping 195 matching lines @@
     ui::ScopedClipboardWriter clipboard_writer(
         ui::Clipboard::GetForCurrentThread(),
         ui::CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(ASCIIToUTF16("foo"));
   }
 
   // Now we shouldn't be able to paste from the clipboard.
   EXPECT_FALSE(CanPasteFromClipboard(model.bookmark_bar_node()));
 }
 
+TEST_F(BookmarkUtilsTest, CutToClipboard) {
+  BookmarkModel model(NULL);
+  model.AddObserver(this);
+  base::string16 title(ASCIIToUTF16("foo"));
+  GURL url("http://foo.com");
+  const BookmarkNode* n1 = model.AddURL(model.other_node(), 0, title, url);
+  const BookmarkNode* n2 = model.AddURL(model.other_node(), 1, title, url);
+  ClearCounts();

[tfarina, 2014/02/21 18:46:47]

I doubt you need this here. Because the test fixture will clean this up in the
initialization.

[Tom Cassiotis, 2014/02/22 04:29:35]

You are right.

Done.

+
+  // Cut the nodes to the clipboard.
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(n1);
+  nodes.push_back(n2);
+  CopyToClipboard(&model, nodes, true);
+
+  // Make sure the nodes were removed.
+  EXPECT_EQ(0, model.other_node()->child_count());
+
+  // Make sure observers were notified the set of changes should be grouped.
+  AssertGroupedChangesObserverCount(1, 1);
+
+  // And make sure we can paste from the clipboard.
+  EXPECT_TRUE(CanPasteFromClipboard(model.bookmark_bar_node()));

[tfarina, 2014/02/21 18:46:47]

this could be other_node() as well, no?

[Tom Cassiotis, 2014/02/22 04:29:35]

This function simply checks whether we can paste into the provided node. I
thought it would be better for the paste destination to be a different node than
where it was copied from.

Saying that it doesn't much matter since CanPasteFromClipboard only checks that
the passed in node is non-null.

Done.

+

[tfarina, 2014/02/21 18:46:47]

remove this empty line;

[Tom Cassiotis, 2014/02/22 04:29:35]

Done.

+}
+
 TEST_F(BookmarkUtilsTest, GetParentForNewNodes) {
   BookmarkModel model(NULL);
   // This tests the case where selection contains one item and that item is a
   // folder.
   std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model.bookmark_bar_node());
   int index = -1;
   const BookmarkNode* real_parent = GetParentForNewNodes(
       model.bookmark_bar_node(), nodes, &index);
   EXPECT_EQ(real_parent, model.bookmark_bar_node());
@@ skipping 53 matching lines @@
   EXPECT_EQ(2u, clone->GetMetaInfoMap()->size());
   std::string value;
   EXPECT_TRUE(clone->GetMetaInfo("somekey", &value));
   EXPECT_EQ("somevalue", value);
   EXPECT_TRUE(clone->GetMetaInfo("someotherkey", &value));
   EXPECT_EQ("someothervalue", value);
 }
 
 }  // namespace
 }  // namespace bookmark_utils