bookmarks: Cleanup, remove BookmarkModelTestUtils class.

chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_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.
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_nsobject.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"
 #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_button_cell.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_folder_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_unittest_helper.h"
 #include "chrome/browser/ui/cocoa/cocoa_profile_test.h"
 #import "chrome/browser/ui/cocoa/cocoa_test_helper.h"
 #import "chrome/browser/ui/cocoa/view_resizer_pong.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #import "testing/gtest_mac.h"
@@ skipping 697 matching lines @@
   }
 };
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveBarBookmarkToFolder) {
   WithNoAnimation at_all;
   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 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  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);
 
   // Pop up a folder menu and drag in a button from the bar.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"2f"];
   NSRect oldToFolderFrame = [toFolder frame];
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSWindow* toWindow = [folderController window];
   EXPECT_TRUE(toWindow);
   NSRect oldToWindowFrame = [toWindow frame];
   // Drag a bar button onto a bookmark (i.e. not a folder) in a folder
   // so it should end up below the target bookmark.
   BookmarkButton* draggedButton = [bar_ buttonWithTitleEqualTo:@"1b"];
   ASSERT_TRUE(draggedButton);
   CGFloat horizontalShift =
       NSWidth([draggedButton frame]) + bookmarks::kBookmarkHorizontalPadding;
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"2f1b"];
   ASSERT_TRUE(targetButton);
   [folderController dragButton:draggedButton
                             to:[targetButton center]
                           copy:NO];
   // The button should have landed just after "2f1b".
   const std::string expected_string("2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
       "2f2f2b 2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ "
       "4f2f1b 4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  EXPECT_EQ(expected_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(expected_string, test::ModelStringFromNode(root));
 
   // Verify the window still appears by looking for its controller.
   EXPECT_TRUE([bar_ folderController]);
 
   // Gather the new frames.
   NSRect newToFolderFrame = [toFolder frame];
   NSRect newToWindowFrame = [toWindow frame];
   // The toFolder should have shifted left horizontally but not vertically.
   NSRect expectedToFolderFrame =
       NSOffsetRect(oldToFolderFrame, -horizontalShift, 0);
@@ skipping 10 matching lines @@
   [folderController validateMenuSpacing];
 
   // Move the button back to the bar at the beginning.
   draggedButton = [folderController buttonWithTitleEqualTo:@"1b"];
   ASSERT_TRUE(draggedButton);
   targetButton = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(targetButton);
   [bar_ dragButton:draggedButton
                 to:[targetButton left]
               copy:NO];
-  EXPECT_EQ(model_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(model_string, test::ModelStringFromNode(root));
   // Don't check the folder window since it's not supposed to be showing.
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragCopyBarBookmarkToFolder) {
   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 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  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);
 
   // Pop up a folder menu and copy in a button from the bar.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(toFolder);
   NSRect oldToFolderFrame = [toFolder frame];
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSWindow* toWindow = [folderController window];
   EXPECT_TRUE(toWindow);
   NSRect oldToWindowFrame = [toWindow frame];
   // Drag a bar button onto a bookmark (i.e. not a folder) in a folder
   // so it should end up below the target bookmark.
   BookmarkButton* draggedButton = [bar_ buttonWithTitleEqualTo:@"1b"];
   ASSERT_TRUE(draggedButton);
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"2f1b"];
   ASSERT_TRUE(targetButton);
   [folderController dragButton:draggedButton
                             to:[targetButton center]
                           copy:YES];
   // The button should have landed just after "2f1b".
   const std::string expected_1("1b 2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
     "2f2f2b 2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ "
     "4f2f1b 4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  EXPECT_EQ(expected_1, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(expected_1, test::ModelStringFromNode(root));
 
   // Gather the new frames.
   NSRect newToFolderFrame = [toFolder frame];
   NSRect newToWindowFrame = [toWindow frame];
   // The toFolder should have shifted.
   EXPECT_NSRECT_EQ(oldToFolderFrame, newToFolderFrame);
   // The toWindow should have shifted down vertically and grown vertically.
   NSRect expectedToWindowFrame = oldToWindowFrame;
   expectedToWindowFrame.origin.y -= bookmarks::kBookmarkFolderButtonHeight;
   expectedToWindowFrame.size.height += bookmarks::kBookmarkFolderButtonHeight;
   EXPECT_NSRECT_EQ(expectedToWindowFrame, newToWindowFrame);
 
   // Copy the button back to the bar after "3b".
   draggedButton = [folderController buttonWithTitleEqualTo:@"1b"];
   ASSERT_TRUE(draggedButton);
   targetButton = [bar_ buttonWithTitleEqualTo:@"4f"];
   ASSERT_TRUE(targetButton);
   [bar_ dragButton:draggedButton
                 to:[targetButton left]
               copy:YES];
   const std::string expected_2("1b 2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
       "2f2f2b 2f2f3b ] 2f3b ] 3b 1b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ "
       "4f2f1b 4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  EXPECT_EQ(expected_2, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(expected_2, test::ModelStringFromNode(root));
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveBarBookmarkToSubfolder) {
   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 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  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);
 
   // Pop up a folder menu and a subfolder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"4f"];
   ASSERT_TRUE(toFolder);
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSWindow* toWindow = [folderController window];
@@ skipping 17 matching lines @@
   BookmarkButton* targetButton =
       [subfolderController buttonWithTitleEqualTo:@"4f2f3b"];
   ASSERT_TRUE(targetButton);
   [subfolderController dragButton:draggedButton
                                to:[targetButton center]
                              copy:NO];
   // The button should have landed just after "2f".
   const std::string expected_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b "
       "2f2f2b 2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ "
       "4f2f1b 4f2f2b 4f2f3b 5b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] ");
-  EXPECT_EQ(expected_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(expected_string, test::ModelStringFromNode(root));
 
   // Check button spacing.
   [folderController validateMenuSpacing];
   [subfolderController validateMenuSpacing];
 
   // Check the window layouts. The folder window should not have changed,
   // but the subfolder window should have shifted vertically and grown.
   NSRect newToWindowFrame = [toWindow frame];
   EXPECT_NSRECT_EQ(oldToWindowFrame, newToWindowFrame);
   NSRect newToSubwindowFrame = [toSubwindow frame];
   NSRect expectedToSubwindowFrame = oldToSubwindowFrame;
   expectedToSubwindowFrame.origin.y -= bookmarks::kBookmarkFolderButtonHeight;
   expectedToSubwindowFrame.size.height +=
       bookmarks::kBookmarkFolderButtonHeight;
   EXPECT_NSRECT_EQ(expectedToSubwindowFrame, newToSubwindowFrame);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveWithinFolder) {
   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 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  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);
 
   // Pop up a folder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"4f"];
   ASSERT_TRUE(toFolder);
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSWindow* toWindow = [folderController window];
   EXPECT_TRUE(toWindow);
   NSRect oldToWindowFrame = [toWindow frame];
   // Drag a folder button to the top within the same parent.
   BookmarkButton* draggedButton =
       [folderController buttonWithTitleEqualTo:@"4f2f"];
   ASSERT_TRUE(draggedButton);
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"4f1f"];
   ASSERT_TRUE(targetButton);
   [folderController dragButton:draggedButton
                             to:[targetButton top]
                           copy:NO];
   // The button should have landed above "4f1f".
   const std::string expected_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b "
       "2f2f2b 2f2f3b ] 2f3b ] 3b 4f:[ 4f2f:[ 4f2f1b 4f2f2b 4f2f3b ] "
       "4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  EXPECT_EQ(expected_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(expected_string, test::ModelStringFromNode(root));
 
   // The window should not have gone away.
   EXPECT_TRUE([bar_ folderController]);
 
   // The folder window should not have changed.
   NSRect newToWindowFrame = [toWindow frame];
   EXPECT_NSRECT_EQ(oldToWindowFrame, newToWindowFrame);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragParentOntoChild) {
   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 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  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);
 
   // Pop up a folder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"4f"];
   ASSERT_TRUE(toFolder);
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSWindow* toWindow = [folderController window];
   EXPECT_TRUE(toWindow);
   // Drag a folder button to one of its children.
   BookmarkButton* draggedButton = [bar_ buttonWithTitleEqualTo:@"4f"];
   ASSERT_TRUE(draggedButton);
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"4f3f"];
   ASSERT_TRUE(targetButton);
   [folderController dragButton:draggedButton
                             to:[targetButton top]
                           copy:NO];
   // The model should not have changed.
-  EXPECT_EQ(model_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(model_string, test::ModelStringFromNode(root));
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveChildToParent) {
   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 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f:[ 4f2f1b "
       "4f2f2b 4f2f3b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  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);
 
   // Pop up a folder menu and a subfolder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"4f"];
   ASSERT_TRUE(toFolder);
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   BookmarkButton* toSubfolder =
@@ skipping 12 matching lines @@
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"4f2f"];
   ASSERT_TRUE(targetButton);
   [folderController dragButton:draggedButton
                             to:[targetButton top]
                           copy:NO];
   // The button should have landed above "4f2f".
   const std::string expected_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
       "2f2f3b ] 2f3b ] 3b 4f:[ 4f1f:[ 4f1f1b 4f1f2b 4f1f3b ] 4f2f3b 4f2f:[ "
       "4f2f1b 4f2f2b ] 4f3f:[ 4f3f1b 4f3f2b 4f3f3b ] ] 5b ");
-  EXPECT_EQ(expected_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  EXPECT_EQ(expected_string, test::ModelStringFromNode(root));
 
   // Check button spacing.
   [folderController validateMenuSpacing];
   // The window should not have gone away.
   EXPECT_TRUE([bar_ folderController]);
   // The subfolder should have gone away.
   EXPECT_FALSE([folderController folderController]);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragWindowResizing) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
-  const std::string
-      model_string("a b:[ b1 b2 b3 ] reallyReallyLongBookmarkName c ");
-  BookmarkModelTestUtils::AddNodesFromModelString(model, root, model_string);
+  const std::string model_string(
+      "a b:[ b1 b2 b3 ] reallyReallyLongBookmarkName c ");
+  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);
 
   // Pop up a folder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"b"];
   ASSERT_TRUE(toFolder);
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSWindow* toWindow = [folderController window];
   EXPECT_TRUE(toWindow);
   CGFloat oldWidth = NSWidth([toWindow frame]);
   // Drag the bookmark with a long name to the folder.
   BookmarkButton* draggedButton =
       [bar_ buttonWithTitleEqualTo:@"reallyReallyLongBookmarkName"];
   ASSERT_TRUE(draggedButton);
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"b1"];
   ASSERT_TRUE(targetButton);
   [folderController dragButton:draggedButton
                             to:[targetButton center]
                           copy:NO];
   // Verify the model change.
-  const std::string
-      expected_string("a b:[ b1 reallyReallyLongBookmarkName b2 b3 ] c ");
-  EXPECT_EQ(expected_string, BookmarkModelTestUtils::ModelStringFromNode(root));
+  const std::string expected_string(
+      "a b:[ b1 reallyReallyLongBookmarkName b2 b3 ] c ");
+  EXPECT_EQ(expected_string, test::ModelStringFromNode(root));
   // Verify the window grew. Just test a reasonable width gain.
   CGFloat newWidth = NSWidth([toWindow frame]);
   EXPECT_LT(oldWidth + 30.0, newWidth);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, MoveRemoveAddButtons) {
   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 actualModelString =
-      BookmarkModelTestUtils::ModelStringFromNode(root);
+  std::string actualModelString = test::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Pop up a folder menu.
   BookmarkButton* toFolder = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(toFolder);
   [[toFolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                           withObject:toFolder];
   BookmarkBarFolderController* folder = [bar_ folderController];
   EXPECT_TRUE(folder);
 
@@ skipping 39 matching lines @@
   EXPECT_EQ(oldDisplayedButtons, [buttons count]);
 
   // Check button spacing.
   [folder validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, 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);
 
   // Pop up the folder menu.
   BookmarkButton* targetFolder = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(targetFolder);
@@ skipping 11 matching lines @@
 
   // Find the folder controller from the bar.
   actualController = [folder controllerForNode:targetNode];
   EXPECT_EQ(expectedController, actualController);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, MenuSizingAndScrollArrows) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2b 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);
 
   const BookmarkNode* parent = model->bookmark_bar_node();
   const BookmarkNode* folder = model->AddFolder(parent,
                                                 parent->child_count(),
                                                 ASCIIToUTF16("BIG"));
 
   // Pop open the new folder window and verify it has one (empty) item.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"BIG"];
   [[button target] performSelector:@selector(openBookmarkFolderFromButton:)
@@ skipping 140 matching lines @@
   return dragDataNodes;
 }
 
 @end
 
 TEST_F(BookmarkBarFolderControllerMenuTest, 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);
 
   // Pop open a folder.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"2f"];
   base::scoped_nsobject<BookmarkBarFolderControllerDragData> folderController;
   folderController.reset([[BookmarkBarFolderControllerDragData alloc]
                           initWithParentButton:button
                               parentController:nil
                                  barController:bar_
                                        profile:profile()]);
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"2f1b"];
   ASSERT_TRUE(targetButton);
 
   // Gen up some dragging data.
   const BookmarkNode* newNode = other->GetChild(2);
   [folderController setDragDataNode:newNode];
   base::scoped_nsobject<FakedDragInfo> dragInfo([[FakedDragInfo alloc] init]);
   [dragInfo setDropLocation:[targetButton top]];
   [folderController dragBookmarkData:(id<NSDraggingInfo>)dragInfo.get()];
 
   // Verify the model.
   const std::string expected("1b 2f:[ O3f:[ O3f1b O3f2f ] 2f1b 2f2f:[ 2f2f1b "
                              "2f2f2b 2f2f3b ] 2f3b ] 3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Now drag over a folder button.
   targetButton = [folderController buttonWithTitleEqualTo:@"2f2f"];
   ASSERT_TRUE(targetButton);
   newNode = other->GetChild(2);  // Should be O4f.
   EXPECT_EQ(newNode->GetTitle(), ASCIIToUTF16("O4f"));
   [folderController setDragDataNode:newNode];
   [dragInfo setDropLocation:[targetButton center]];
   [folderController dragBookmarkData:(id<NSDraggingInfo>)dragInfo.get()];
 
   // Verify the model.
   const std::string expectedA("1b 2f:[ O3f:[ O3f1b O3f2f ] 2f1b 2f2f:[ "
                               "2f2f1b 2f2f2b 2f2f3b O4f:[ O4f1b O4f2f ] ] "
                               "2f3b ] 3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expectedA, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, 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);
 
   const BookmarkNode* folderNode = root->GetChild(1);
   int oldFolderChildCount = folderNode->child_count();
 
   // Pop open a folder.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"2f"];
   base::scoped_nsobject<BookmarkBarFolderControllerDragData> folderController;
   folderController.reset([[BookmarkBarFolderControllerDragData alloc]
                           initWithParentButton:button
                               parentController:nil
                                  barController:bar_
                                        profile:profile()]);
 
   // Drag a button to the trash.
   BookmarkButton* buttonToDelete =
       [folderController buttonWithTitleEqualTo:@"2f1b"];
   ASSERT_TRUE(buttonToDelete);
   EXPECT_TRUE([folderController canDragBookmarkButtonToTrash:buttonToDelete]);
   [folderController didDragBookmarkToTrash:buttonToDelete];
 
   // There should be one less button in the folder.
   int newFolderChildCount = folderNode->child_count();
   EXPECT_EQ(oldFolderChildCount - 1, newFolderChildCount);
   // Verify the model.
   const std::string expected("1b 2f:[ 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
                              "2f3b ] 3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, 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);
 
   // Pop open a folder.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"2f"];
   [[button target] performSelector:@selector(openBookmarkFolderFromButton:)
                         withObject:button];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   NSArray* buttons = [folderController buttons];
   EXPECT_TRUE(buttons);
 
   // Remember how many buttons are showing.
   int oldDisplayedButtons = [buttons count];
 
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"2f1b"];
   ASSERT_TRUE(targetButton);
 
   NSArray* urls = [NSArray arrayWithObjects: @"http://www.a.com/",
                    @"http://www.b.com/", nil];
   NSArray* titles = [NSArray arrayWithObjects: @"SiteA", @"SiteB", nil];
   [folderController addURLs:urls withTitles:titles at:[targetButton top]];
 
   // There should two more buttons in the folder.
   int newDisplayedButtons = [buttons count];
   EXPECT_EQ(oldDisplayedButtons + 2, newDisplayedButtons);
   // Verify the model.
   const std::string expected("1b 2f:[ SiteA SiteB 2f1b 2f2f:[ 2f2f1b 2f2f2b "
                              "2f2f3b ] 2f3b ] 3b 4b ");
-  actual = BookmarkModelTestUtils::ModelStringFromNode(root);
+  actual = test::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DropPositionIndicator) {
   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);
 
   // Pop open the folder.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"2f"];
   [[button target] performSelector:@selector(openBookmarkFolderFromButton:)
                         withObject:button];
   BookmarkBarFolderController* folder = [bar_ folderController];
   EXPECT_TRUE(folder);
 
   // Test a series of points starting at the top of the folder.
@@ skipping 35 matching lines @@
                  resizeDelegate:resizeDelegate_.get()]);
     InstallAndToggleBar(bar_.get());
   }
 };
 
 TEST_F(BookmarkBarFolderControllerClosingTest, DeleteClosesFolder) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
   const BookmarkNode* root = model->bookmark_bar_node();
   const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b ] "
                                  "2f3b ] 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);
 
   // Open the folder menu and submenu.
   BookmarkButton* target = [bar_ buttonWithTitleEqualTo:@"2f"];
   ASSERT_TRUE(target);
   [[target target] performSelector:@selector(openBookmarkFolderFromButton:)
                               withObject:target];
   BookmarkBarFolderController* folder = [bar_ folderController];
   EXPECT_TRUE(folder);
   BookmarkButton* subTarget = [folder buttonWithTitleEqualTo:@"2f2f"];
   ASSERT_TRUE(subTarget);
   [[subTarget target] performSelector:@selector(openBookmarkFolderFromButton:)
                            withObject:subTarget];
   BookmarkBarFolderController* subFolder = [folder folderController];
   EXPECT_TRUE(subFolder);
 
   // Delete the folder node and verify the window closed down by looking
   // for its controller again.
   DeleteBookmark([folder parentButton], profile());
   EXPECT_FALSE([folder folderController]);
 }
 
 // TODO(jrg): draggingEntered: and draggingExited: trigger timers so
 // they are hard to test.  Factor out "fire timers" into routines
 // which can be overridden to fire immediately to make behavior
 // confirmable.
 // There is a similar problem with mouseEnteredButton: and
 // mouseExitedButton:.