Adds ability to sort the children of a node in the bookmark model. I...

chrome/browser/bookmarks/bookmark_model_unittest.cc

 // Copyright (c) 2006-2008 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 "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 72 matching lines @@
     removed_count++;
     observer_details.Set(parent, NULL, index, -1);
   }
 
   virtual void BookmarkNodeChanged(BookmarkModel* model,
                                    BookmarkNode* node) {
     changed_count++;
     observer_details.Set(node, NULL, -1, -1);
   }
 
+  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
+                                             BookmarkNode* node) {
+    reordered_count_++;
+  }
+
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                          BookmarkNode* node) {
     // We never attempt to load favicons, so that this method never
     // gets invoked.
   }
 
   void ClearCounts() {
-    moved_count = added_count = removed_count = changed_count = 0;
+    reordered_count_ = moved_count = added_count = removed_count =
+        changed_count = 0;
   }
 
   void AssertObserverCount(int added_count,
                            int moved_count,
                            int removed_count,
-                           int changed_count) {
+                           int changed_count,
+                           int reordered_count) {
     ASSERT_EQ(added_count, this->added_count);
     ASSERT_EQ(moved_count, this->moved_count);
     ASSERT_EQ(removed_count, this->removed_count);
     ASSERT_EQ(changed_count, this->changed_count);
+    ASSERT_EQ(reordered_count, reordered_count_);
   }
 
   void AssertNodesEqual(BookmarkNode* expected, BookmarkNode* actual) {
     ASSERT_TRUE(expected);
     ASSERT_TRUE(actual);
     EXPECT_EQ(expected->GetTitle(), actual->GetTitle());
     EXPECT_EQ(expected->GetType(), actual->GetType());
     EXPECT_TRUE(expected->date_added() == actual->date_added());
     if (expected->GetType() == history::StarredEntry::URL) {
       EXPECT_EQ(expected->GetURL(), actual->GetURL());
@@ skipping 17 matching lines @@
   BookmarkModel model;
 
   int moved_count;
 
   int added_count;
 
   int removed_count;
 
   int changed_count;
 
+  int reordered_count_;
+
   ObserverDetails observer_details;
 };
 
 TEST_F(BookmarkModelTest, InitialState) {
   BookmarkNode* bb_node = model.GetBookmarkBarNode();
   ASSERT_TRUE(bb_node != NULL);
   EXPECT_EQ(0, bb_node->GetChildCount());
   EXPECT_EQ(history::StarredEntry::BOOKMARK_BAR, bb_node->GetType());
 
   BookmarkNode* other_node = model.other_node();
   ASSERT_TRUE(other_node != NULL);
   EXPECT_EQ(0, other_node->GetChildCount());
   EXPECT_EQ(history::StarredEntry::OTHER, other_node->GetType());
 
   EXPECT_TRUE(bb_node->id() != other_node->id());
 }
 
 TEST_F(BookmarkModelTest, AddURL) {
   BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
   const GURL url("http://foo.com");
 
   BookmarkNode* new_node = model.AddURL(root, 0, title, url);
-  AssertObserverCount(1, 0, 0, 0);
+  AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->GetChildCount());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->GetURL());
   ASSERT_EQ(history::StarredEntry::URL, new_node->GetType());
   ASSERT_TRUE(new_node == model.GetMostRecentlyAddedNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model.other_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddGroup) {
   BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
 
   BookmarkNode* new_node = model.AddGroup(root, 0, title);
-  AssertObserverCount(1, 0, 0, 0);
+  AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->GetChildCount());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_EQ(history::StarredEntry::USER_GROUP, new_node->GetType());
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model.other_node()->id());
 
   // Add another group, just to make sure group_ids are incremented correctly.
   ClearCounts();
   BookmarkNode* new_node2 = model.AddGroup(root, 0, title);
-  AssertObserverCount(1, 0, 0, 0);
+  AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 }
 
 TEST_F(BookmarkModelTest, RemoveURL) {
   BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
   const GURL url("http://foo.com");
   BookmarkNode* new_node = model.AddURL(root, 0, title, url);
   ClearCounts();
 
   model.Remove(root, 0);
   ASSERT_EQ(0, root->GetChildCount());
-  AssertObserverCount(0, 0, 1, 0);
+  AssertObserverCount(0, 0, 1, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
   // Make sure there is no mapping for the URL.
   ASSERT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
 }
 
 TEST_F(BookmarkModelTest, RemoveGroup) {
   BookmarkNode* root = model.GetBookmarkBarNode();
   BookmarkNode* group = model.AddGroup(root, 0, L"foo");
 
   ClearCounts();
 
   // Add a URL as a child.
   const std::wstring title(L"foo");
   const GURL url("http://foo.com");
   BookmarkNode* new_node = model.AddURL(group, 0, title, url);
 
   ClearCounts();
 
   // Now remove the group.
   model.Remove(root, 0);
   ASSERT_EQ(0, root->GetChildCount());
-  AssertObserverCount(0, 0, 1, 0);
+  AssertObserverCount(0, 0, 1, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
   // Make sure there is no mapping for the URL.
   ASSERT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
 }
 
 TEST_F(BookmarkModelTest, SetTitle) {
   BookmarkNode* root = model.GetBookmarkBarNode();
   std::wstring title(L"foo");
   const GURL url("http://foo.com");
   BookmarkNode* node = model.AddURL(root, 0, title, url);
 
   ClearCounts();
 
   title = L"foo2";
   model.SetTitle(node, title);
-  AssertObserverCount(0, 0, 0, 1);
+  AssertObserverCount(0, 0, 0, 1, 0);
   observer_details.AssertEquals(node, NULL, -1, -1);
   EXPECT_EQ(title, node->GetTitle());
 }
 
 TEST_F(BookmarkModelTest, Move) {
   BookmarkNode* root = model.GetBookmarkBarNode();
   std::wstring title(L"foo");
   const GURL url("http://foo.com");
   BookmarkNode* node = model.AddURL(root, 0, title, url);
   BookmarkNode* group1 = model.AddGroup(root, 0, L"foo");
   ClearCounts();
 
   model.Move(node, group1, 0);
 
-  AssertObserverCount(0, 1, 0, 0);
+  AssertObserverCount(0, 1, 0, 0, 0);
   observer_details.AssertEquals(root, group1, 1, 0);
   EXPECT_TRUE(group1 == node->GetParent());
   EXPECT_EQ(1, root->GetChildCount());
   EXPECT_EQ(group1, root->GetChild(0));
   EXPECT_EQ(1, group1->GetChildCount());
   EXPECT_EQ(node, group1->GetChild(0));
 
   // And remove the group.
   ClearCounts();
   model.Remove(root, 0);
-  AssertObserverCount(0, 0, 1, 0);
+  AssertObserverCount(0, 0, 1, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
   EXPECT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
   EXPECT_EQ(0, root->GetChildCount());
 }
 
 // Tests that adding a URL to a folder updates the last modified time.
 TEST_F(BookmarkModelTest, ParentForNewNodes) {
   ASSERT_EQ(model.GetBookmarkBarNode(), model.GetParentForNewNodes());
 
   const std::wstring title(L"foo");
@@ skipping 528 matching lines @@
   bb_model_->SetURLStarred(url, std::wstring(), true);
 
   profile_->GetHistoryService(Profile::EXPLICIT_ACCESS)->AddPage(
       url, NULL, 1, GURL(), PageTransition::TYPED,
       HistoryService::RedirectList());
 
   // This won't actually delete the URL, rather it'll empty out the visits.
   // This triggers blocking on the BookmarkModel.
   profile_->GetHistoryService(Profile::EXPLICIT_ACCESS)->DeleteURL(url);
 }
+
+TEST_F(BookmarkModelTest, Sort) {
+  // Populate the bookmark bar node with nodes for 'B', 'a', 'd' and 'C'.
+  TestNode bbn;
+  PopulateNodeFromString(L"B a d C", &bbn);
+  BookmarkNode* parent = model.GetBookmarkBarNode();
+  PopulateBookmarkNode(&bbn, &model, parent);
+
+  ClearCounts();
+
+  // Sort the children of the bookmark bar node.
+  model.SortChildren(parent);
+
+  // Make sure we were notified.
+  AssertObserverCount(0, 0, 0, 0, 1);
+
+  // Make sure the order matches.
+  EXPECT_TRUE(parent->GetChild(0)->GetTitle() == L"a");
+  EXPECT_TRUE(parent->GetChild(1)->GetTitle() == L"B");
+  EXPECT_TRUE(parent->GetChild(2)->GetTitle() == L"C");
+  EXPECT_TRUE(parent->GetChild(3)->GetTitle() == L"d");
+}