bookmarks: Cleanup, remove BookmarkModelTestUtils class.

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller_unittest.mm

 // 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.
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/bookmark_model_test_utils.h"
+#include "chrome/browser/bookmarks/bookmark_test_helpers.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_constants.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_window.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_unittest_helper.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_button_cell.h"
 #include "chrome/browser/ui/cocoa/cocoa_profile_test.h"
@@ skipping 1203 matching lines @@
 }
 
 // Verify that the folder menu presentation properly tracks mouse movements
 // over the bar. Until there is a click no folder menus should show. After a
 // click on a folder folder menus should show until another click on a folder
 // button, and a click outside the bar and its folder menus.
 TEST_F(BookmarkBarControllerTest, TestFolderButtons) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b 4f:[ 4f1b 4f2b ] ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model and that we do not have a folder controller.
-  std::string actualModelString =
-      BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModelString = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
   EXPECT_FALSE([bar_ folderController]);
 
   // Add a real bookmark so we can click on it.
   const BookmarkNode* folder = root->GetChild(3);
   model->AddURL(folder, folder->child_count(), ASCIIToUTF16("CLICK ME"),
                 GURL("http://www.google.com/"));
 
   // Click on a folder button.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"4f"];
@@ skipping 190 matching lines @@
 
   // Now that we've closed the bookmark bar (with animation) the folder menu
   // should have been closed thus releasing the folderController.
   EXPECT_FALSE([bar_ folderController]);
 }
 
 TEST_F(BookmarkBarControllerTest, MoveRemoveAddButtons) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::string actualModelString =
-      BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModelString = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Remember how many buttons are showing.
   int oldDisplayedButtons = [bar_ displayedButtonCount];
   NSArray* buttons = [bar_ buttons];
 
   // Move a button around a bit.
   [bar_ moveButtonFromIndex:0 toIndex:2];
   EXPECT_NSEQ(@"2f", [[buttons objectAtIndex:0] title]);
   EXPECT_NSEQ(@"3b", [[buttons objectAtIndex:1] title]);
@@ skipping 49 matching lines @@
   EXPECT_EQ(31.0, NSWidth([view frame]));
   EXPECT_FALSE([view isHidden]);
   [bar_ shrinkOrHideView:view forMaxX:29.0];
   EXPECT_TRUE([view isHidden]);
 }
 
 TEST_F(BookmarkBarControllerTest, LastBookmarkResizeBehavior) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
   [bar_ frameDidChange];
 
   CGFloat viewWidths[] = { 123.0, 124.0, 151.0, 152.0, 153.0, 154.0, 155.0,
                            200.0, 155.0, 154.0, 153.0, 152.0, 151.0, 124.0,
                            123.0 };
   BOOL offTheSideButtonIsHiddenResults[] = { NO, NO, NO, NO, YES, YES, YES, YES,
                                              YES, YES, YES, NO, NO, NO, NO};
   int displayedButtonCountResults[] = { 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 2,
                                         2, 1 };
 
@@ skipping 15 matching lines @@
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableInstantExtendedAPI);
   }
 };
 
 TEST_F(BookmarkBarControllerWithInstantExtendedTest,
     BookmarksWithAppsPageShortcut) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
   [bar_ frameDidChange];
 
   // Apps page shortcut button should be visible.
   ASSERT_FALSE([bar_ appsPageShortcutButtonIsHidden]);
 
   // Bookmarks should be to the right of the Apps page shortcut button.
   CGFloat apps_button_right = NSMaxX([[bar_ appsPageShortcutButton] frame]);
   CGFloat right = apps_button_right;
   NSArray* buttons = [bar_ buttons];
   for (size_t i = 0; i < [buttons count]; ++i) {
@@ skipping 183 matching lines @@
 
 TEST_F(BookmarkBarControllerDragDropTest, DragMoveBarBookmarkToOffTheSide) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1bWithLongName 2fWithLongName:[ "
       "2f1bWithLongName 2f2fWithLongName:[ 2f2f1bWithLongName "
       "2f2f2bWithLongName 2f2f3bWithLongName 2f4b ] 2f3bWithLongName ] "
       "3bWithLongName 4bWithLongName 5bWithLongName 6bWithLongName "
       "7bWithLongName 8bWithLongName 9bWithLongName 10bWithLongName "
       "11bWithLongName 12bWithLongName 13b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::string actualModelString =
-      BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModelString = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Insure that the off-the-side is not showing.
   ASSERT_FALSE([bar_ offTheSideButtonIsHidden]);
 
   // Remember how many buttons are showing and are available.
   int oldDisplayedButtons = [bar_ displayedButtonCount];
   int oldChildCount = root->child_count();
 
   // Pop up the off-the-side menu.
@@ skipping 28 matching lines @@
 
 TEST_F(BookmarkBarControllerDragDropTest, DragOffTheSideToOther) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1bWithLongName 2bWithLongName "
       "3bWithLongName 4bWithLongName 5bWithLongName 6bWithLongName "
       "7bWithLongName 8bWithLongName 9bWithLongName 10bWithLongName "
       "11bWithLongName 12bWithLongName 13bWithLongName 14bWithLongName "
       "15bWithLongName 16bWithLongName 17bWithLongName 18bWithLongName "
       "19bWithLongName 20bWithLongName ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   const BookmarkNode* other = model->other_node();
   const std::string other_string("1other 2other 3other ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, other, other_string);
+  test::AddNodesFromModelString(model, other, other_string);
 
   // Validate initial model.
-  std::string actualModelString =
-      BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModelString = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
-  std::string actualOtherString =
-      BookmarkModelTestUtils::ModelStringFromNode(other);
+  std::string actualOtherString = test::ModelStringFromNode(other);
   EXPECT_EQ(other_string, actualOtherString);
 
   // Insure that the off-the-side is showing.
   ASSERT_FALSE([bar_ offTheSideButtonIsHidden]);
 
   // Remember how many buttons are showing and are available.
   int oldDisplayedButtons = [bar_ displayedButtonCount];
   int oldRootCount = root->child_count();
   int oldOtherCount = other->child_count();
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(oldRootCount - 1, newRootCount);
   EXPECT_EQ(oldOTSCount - 1, newOTSCount);
   EXPECT_EQ(oldOtherCount + 1, newOtherCount);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, DragBookmarkData) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                   "2f3b ] 3b 4b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
   const BookmarkNode* other = model->other_node();
   const std::string other_string("O1b O2b O3f:[ O3f1b O3f2f ] "
                                  "O4f:[ O4f1b O4f2f ] 05b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, other, other_string);
+  test::AddNodesFromModelString(model, other, other_string);
 
   // Validate initial model.
-  std::string actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actual = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
-  actual = BookmarkModelTestUtils::ModelStringFromNode(other);
+  actual = test::ModelStringFromNode(other);
   EXPECT_EQ(other_string, actual);
 
   // Remember the little ones.
   int oldChildCount = root->child_count();
 
   BookmarkButton* targetButton = [bar_ buttonWithTitleEqualTo:@"3b"];
   ASSERT_TRUE(targetButton);
 
   // Gen up some dragging data.
   const BookmarkNode* newNode = other->GetChild(2);
   [bar_ setDragDataNode:newNode];
   base::scoped_nsobject<FakeDragInfo> dragInfo([[FakeDragInfo alloc] init]);
   [dragInfo setDropLocation:[targetButton center]];
   [bar_ dragBookmarkData:(id<NSDraggingInfo>)dragInfo.get()];
 
   // There should one more button in the bar.
   int newChildCount = root->child_count();
   EXPECT_EQ(oldChildCount + 1, newChildCount);
   // Verify the model.
   const std::string expected("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                              "2f3b ] O3f:[ O3f1b O3f2f ] 3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
   oldChildCount = newChildCount;
 
   // Now do it over a folder button.
   targetButton = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(targetButton);
   NSPoint targetPoint = [targetButton center];
   newNode = other->GetChild(2);  // Should be O4f.
   EXPECT_EQ(newNode->GetTitle(), ASCIIToUTF16("O4f"));
   [bar_ setDragDataNode:newNode];
   [dragInfo setDropLocation:targetPoint];
   [bar_ dragBookmarkData:(id<NSDraggingInfo>)dragInfo.get()];
 
   newChildCount = root->child_count();
   EXPECT_EQ(oldChildCount, newChildCount);
   // Verify the model.
   const std::string expected1("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                               "2f3b O4f:[ O4f1b O4f2f ] ] O3f:[ O3f1b O3f2f ] "
                               "3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected1, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, AddURLs) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                  "2f3b ] 3b 4b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::string actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actual = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
 
   // Remember the children.
   int oldChildCount = root->child_count();
 
   BookmarkButton* targetButton = [bar_ buttonWithTitleEqualTo:@"3b"];
   ASSERT_TRUE(targetButton);
 
   NSArray* urls = [NSArray arrayWithObjects: @"http://www.a.com/",
                    @"http://www.b.com/", nil];
   NSArray* titles = [NSArray arrayWithObjects: @"SiteA", @"SiteB", nil];
   [bar_ addURLs:urls withTitles:titles at:[targetButton center]];
 
   // There should two more nodes in the bar.
   int newChildCount = root->child_count();
   EXPECT_EQ(oldChildCount + 2, newChildCount);
   // Verify the model.
   const std::string expected("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                              "2f3b ] SiteA SiteB 3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, ControllerForNode) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::string actualModelString =
-      BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModelString = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Find the main bar controller.
   const void* expectedController = bar_;
   const void* actualController = [bar_ controllerForNode:root];
   EXPECT_EQ(expectedController, actualController);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, DropPositionIndicator) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2b 2f3b ] 3b 4b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::string actualModel = BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModel = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModel);
 
   // Test a series of points starting at the right edge of the bar.
   BookmarkButton* targetButton = [bar_ buttonWithTitleEqualTo:@"1b"];
   ASSERT_TRUE(targetButton);
   NSPoint targetPoint = [targetButton left];
   CGFloat leftMarginIndicatorPosition = bookmarks::kBookmarkLeftMargin - 0.5 *
                                         bookmarks::kBookmarkHorizontalPadding;
   const CGFloat baseOffset = targetPoint.x;
   CGFloat expected = leftMarginIndicatorPosition;
@@ skipping 46 matching lines @@
                       object:nil
                     userInfo:dict];
   EXPECT_FALSE([button isContinuousPulsing]);
 }
 
 TEST_F(BookmarkBarControllerDragDropTest, DragBookmarkDataToTrash) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                                   "2f3b ] 3b 4b ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  test::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::string actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actual = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
 
   int oldChildCount = root->child_count();
 
   // Drag a button to the trash.
   BookmarkButton* buttonToDelete = [bar_ buttonWithTitleEqualTo:@"3b"];
   ASSERT_TRUE(buttonToDelete);
   EXPECT_TRUE([bar_ canDragBookmarkButtonToTrash:buttonToDelete]);
   [bar_ didDragBookmarkToTrash:buttonToDelete];
 
   // There should be one less button in the bar.
   int newChildCount = root->child_count();
   EXPECT_EQ(oldChildCount - 1, newChildCount);
   // Verify the model.
   const std::string expected("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                              "2f3b ] 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Verify that the other bookmark folder can't be deleted.
   BookmarkButton *otherButton = [bar_ otherBookmarksButton];
   EXPECT_FALSE([bar_ canDragBookmarkButtonToTrash:otherButton]);
 }
 
 }  // namespace