Lands http://codereview.chromium.org/155128 for Thiago....

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 "app/tree_node_iterator.h"
 #include "app/tree_node_model.h"
 #include "base/hash_tables.h"
 #include "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
@@ skipping 136 matching lines @@
 
   int reordered_count_;
 
   ObserverDetails observer_details;
 };
 
 TEST_F(BookmarkModelTest, InitialState) {
   const 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());
+  EXPECT_EQ(BookmarkNode::BOOKMARK_BAR, bb_node->GetType());
 
   const 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_EQ(BookmarkNode::OTHER_NODE, other_node->GetType());
 
   EXPECT_TRUE(bb_node->id() != other_node->id());
 }
 
 TEST_F(BookmarkModelTest, AddURL) {
   const BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model.AddURL(root, 0, title, url);
   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_EQ(BookmarkNode::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) {
   const BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
 
   const BookmarkNode* new_node = model.AddGroup(root, 0, title);
   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());
+  ASSERT_EQ(BookmarkNode::FOLDER, 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();
   model.AddGroup(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 }
@@ skipping 260 matching lines @@
   // Now we should get the notification.
   EXPECT_EQ(1, listener.notification_count_);
   ASSERT_FALSE(listener.details_.starred);
   ASSERT_EQ(1U, listener.details_.changed_urls.size());
   EXPECT_TRUE(url == *(listener.details_.changed_urls.begin()));
 }
 
 namespace {
 
 // See comment in PopulateNodeFromString.
-typedef TreeNodeWithValue<history::StarredEntry::Type> TestNode;
+typedef TreeNodeWithValue<BookmarkNode::Type> TestNode;
 
 // Does the work of PopulateNodeFromString. index gives the index of the current
 // element in description to process.
 static void PopulateNodeImpl(const std::vector<std::wstring>& description,
                              size_t* index,
                              TestNode* parent) {
   while (*index < description.size()) {
     const std::wstring& element = description[*index];
     (*index)++;
     if (element == L"[") {
       // Create a new group and recurse to add all the children.
       // Groups are given a unique named by way of an ever increasing integer
       // value. The groups need not have a name, but one is assigned to help
       // in debugging.
       static int next_group_id = 1;
       TestNode* new_node =
           new TestNode(IntToWString(next_group_id++),
-                       history::StarredEntry::USER_GROUP);
+                       BookmarkNode::FOLDER);
       parent->Add(parent->GetChildCount(), new_node);
       PopulateNodeImpl(description, index, new_node);
     } else if (element == L"]") {
       // End the current group.
       return;
     } else {
       // Add a new URL.
 
       // All tokens must be space separated. If there is a [ or ] in the name it
       // likely means a space was forgotten.
       DCHECK(element.find('[') == std::string::npos);
       DCHECK(element.find(']') == std::string::npos);
       parent->Add(parent->GetChildCount(),
-                  new TestNode(element, history::StarredEntry::URL));
+                  new TestNode(element, BookmarkNode::URL));
     }
   }
 }
 
 // Creates and adds nodes to parent based on description. description consists
 // of the following tokens (all space separated):
 //   [ : creates a new USER_GROUP node. All elements following the [ until the
 //       next balanced ] is encountered are added as children to the node.
 //   ] : closes the last group created by [ so that any further nodes are added
 //       to the current groups parent.
@@ skipping 15 matching lines @@
   SplitStringAlongWhitespace(description, &elements);
   PopulateNodeImpl(elements, &index, parent);
 }
 
 // Populates the BookmarkNode with the children of parent.
 static void PopulateBookmarkNode(TestNode* parent,
                                  BookmarkModel* model,
                                  const BookmarkNode* bb_node) {
   for (int i = 0; i < parent->GetChildCount(); ++i) {
     TestNode* child = parent->GetChild(i);
-    if (child->value == history::StarredEntry::USER_GROUP) {
+    if (child->value == BookmarkNode::FOLDER) {
       const BookmarkNode* new_bb_node =
           model->AddGroup(bb_node, i, child->GetTitle());
       PopulateBookmarkNode(child, model, new_bb_node);
     } else {
       model->AddURL(bb_node, i, child->GetTitle(),
                     GURL("http://" + WideToASCII(child->GetTitle())));
     }
   }
 }
 
@@ skipping 15 matching lines @@
 
  protected:
   // Verifies the contents of the bookmark bar node match the contents of the
   // TestNode.
   void VerifyModelMatchesNode(TestNode* expected, const BookmarkNode* actual) {
     ASSERT_EQ(expected->GetChildCount(), actual->GetChildCount());
     for (int i = 0; i < expected->GetChildCount(); ++i) {
       TestNode* expected_child = expected->GetChild(i);
       const BookmarkNode* actual_child = actual->GetChild(i);
       ASSERT_EQ(expected_child->GetTitle(), actual_child->GetTitle());
-      if (expected_child->value == history::StarredEntry::USER_GROUP) {
-        ASSERT_TRUE(actual_child->GetType() ==
-                    history::StarredEntry::USER_GROUP);
+      if (expected_child->value == BookmarkNode::FOLDER) {
+        ASSERT_TRUE(actual_child->GetType() == BookmarkNode::FOLDER);
         // Recurse throught children.
         VerifyModelMatchesNode(expected_child, actual_child);
         if (HasFatalFailure())
           return;
       } else {
         // No need to check the URL, just the title is enough.
-        ASSERT_TRUE(actual_child->GetType() ==
-                    history::StarredEntry::URL);
+        ASSERT_TRUE(actual_child->GetType() == BookmarkNode::URL);
       }
     }
   }
 
   void VerifyNoDuplicateIDs(BookmarkModel* model) {
     TreeNodeIterator<const BookmarkNode> it(model->root_node());
     base::hash_set<int> ids;
     while (it.has_next())
       ASSERT_TRUE(ids.insert(it.Next()->id()).second);
   }
@@ skipping 113 matching lines @@
     //     http://www.google.com/intl/en/ads/ - Google Advertising
     //     F11
     //       http://www.google.com/services/ - Google Business Solutions
     // other
     //   OF1
     //   http://www.google.com/intl/en/about.html - About Google
     const BookmarkNode* bbn = bb_model_->GetBookmarkBarNode();
     ASSERT_EQ(2, bbn->GetChildCount());
 
     const BookmarkNode* child = bbn->GetChild(0);
-    ASSERT_EQ(history::StarredEntry::URL, child->GetType());
+    ASSERT_EQ(BookmarkNode::URL, child->GetType());
     ASSERT_EQ(L"Google", child->GetTitle());
     ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com"));
 
     child = bbn->GetChild(1);
     ASSERT_TRUE(child->is_folder());
     ASSERT_EQ(L"F1", child->GetTitle());
     ASSERT_EQ(2, child->GetChildCount());
 
     const BookmarkNode* parent = child;
     child = parent->GetChild(0);
-    ASSERT_EQ(history::StarredEntry::URL, child->GetType());
+    ASSERT_EQ(BookmarkNode::URL, child->GetType());
     ASSERT_EQ(L"Google Advertising", child->GetTitle());
     ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com/intl/en/ads/"));
 
     child = parent->GetChild(1);
     ASSERT_TRUE(child->is_folder());
     ASSERT_EQ(L"F11", child->GetTitle());
     ASSERT_EQ(1, child->GetChildCount());
 
     parent = child;
     child = parent->GetChild(0);
-    ASSERT_EQ(history::StarredEntry::URL, child->GetType());
+    ASSERT_EQ(BookmarkNode::URL, child->GetType());
     ASSERT_EQ(L"Google Business Solutions", child->GetTitle());
     ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com/services/"));
 
     parent = bb_model_->other_node();
     ASSERT_EQ(2, parent->GetChildCount());
 
     child = parent->GetChild(0);
     ASSERT_TRUE(child->is_folder());
     ASSERT_EQ(L"OF1", child->GetTitle());
     ASSERT_EQ(0, child->GetChildCount());
 
     child = parent->GetChild(1);
-    ASSERT_EQ(history::StarredEntry::URL, child->GetType());
+    ASSERT_EQ(BookmarkNode::URL, child->GetType());
     ASSERT_EQ(L"About Google", child->GetTitle());
     ASSERT_TRUE(child->GetURL() ==
                 GURL("http://www.google.com/intl/en/about.html"));
 
     ASSERT_TRUE(bb_model_->IsBookmarked(GURL("http://www.google.com")));
   }
 };
 
 // Tests migrating bookmarks from db into file. This copies an old history db
 // file containing bookmarks and make sure they are loaded correctly and
@@ skipping 82 matching lines @@
   // Make sure we were notified.
   AssertObserverCount(0, 0, 0, 0, 1);
 
   // Make sure the order matches (remember, 'a' and 'C' are folders and
   // come first).
   EXPECT_TRUE(parent->GetChild(0)->GetTitle() == L"a");
   EXPECT_TRUE(parent->GetChild(1)->GetTitle() == L"C");
   EXPECT_TRUE(parent->GetChild(2)->GetTitle() == L"B");
   EXPECT_TRUE(parent->GetChild(3)->GetTitle() == L"d");
 }