Remove wstrings from bookmarks, part 13.

chrome/browser/cocoa/bookmark_bar_folder_controller_unittest.mm

 // Copyright (c) 2010 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/scoped_nsobject.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
@@ skipping 630 matching lines @@
     // Make sure it's open so certain things aren't no-ops.
     [bar updateAndShowNormalBar:YES
                 showDetachedBar:NO
                   withAnimation:NO];
   }
 };
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveBarBookmarkToFolder) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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 ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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::wstring expected_string(L"2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
+  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, model_test_utils::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];
@@ skipping 19 matching lines @@
   [bar_ dragButton:draggedButton
                 to:[targetButton left]
               copy:NO];
   EXPECT_EQ(model_string, model_test_utils::ModelStringFromNode(root));
   // Don't check the folder window since it's not supposed to be showing.
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragCopyBarBookmarkToFolder) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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 ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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::wstring expected_1(L"1b 2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
+  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, model_test_utils::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::kBookmarkBarHeight + bookmarks::kVisualHeightOffset;
   expectedToWindowFrame.size.height +=
       bookmarks::kBookmarkBarHeight + bookmarks::kVisualHeightOffset;
   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::wstring expected_2(L"1b 2f:[ 2f1b 1b 2f2f:[ 2f2f1b "
+  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, model_test_utils::ModelStringFromNode(root));
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveBarBookmarkToSubfolder) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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 ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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 14 matching lines @@
   // so it should end up below the target bookmark.
   BookmarkButton* draggedButton = [bar_ buttonWithTitleEqualTo:@"5b"];
   ASSERT_TRUE(draggedButton);
   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::wstring expected_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b "
+  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, model_test_utils::ModelStringFromNode(root));
 
   // 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::kBookmarkBarHeight + bookmarks::kVisualHeightOffset;
   expectedToSubwindowFrame.size.height +=
       bookmarks::kBookmarkBarHeight + bookmarks::kVisualHeightOffset;
   EXPECT_NSRECT_EQ(expectedToSubwindowFrame, newToSubwindowFrame);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveWithinFolder) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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 ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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::wstring expected_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b "
+  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, model_test_utils::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);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragParentOntoChild) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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 ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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, model_test_utils::ModelStringFromNode(root));
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveChildToParent) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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 ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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 =
       [folderController buttonWithTitleEqualTo:@"4f2f"];
   ASSERT_TRUE(toSubfolder);
   [[toSubfolder target] performSelector:@selector(openBookmarkFolderFromButton:)
                              withObject:toSubfolder];
   BookmarkBarFolderController* subfolderController =
       [folderController folderController];
   EXPECT_TRUE(subfolderController);
 
   // Drag a subfolder bookmark to the parent folder.
   BookmarkButton* draggedButton =
       [subfolderController buttonWithTitleEqualTo:@"4f2f3b"];
   ASSERT_TRUE(draggedButton);
   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::wstring expected_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+  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, model_test_utils::ModelStringFromNode(root));
 
   // 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(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring
-      model_string(L"a b:[ b1 b2 b3 ] reallyReallyLongBookmarkName c ");
+  const std::string
+      model_string("a b:[ b1 b2 b3 ] reallyReallyLongBookmarkName c ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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::wstring
-      expected_string(L"a b:[ b1 reallyReallyLongBookmarkName b2 b3 ] c ");
+  const std::string
+      expected_string("a b:[ b1 reallyReallyLongBookmarkName b2 b3 ] c ");
   EXPECT_EQ(expected_string, model_test_utils::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(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2b 2f3b ] 3b 4b ");
+  const std::string model_string("1b 2f:[ 2f1b 2f2b 2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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 35 matching lines @@
   [folder removeButton:1 animate:NO];
   EXPECT_NSEQ(@"3b", [[buttons objectAtIndex:0] title]);
   EXPECT_NSEQ(@"2f2b", [[buttons objectAtIndex:1] title]);
   EXPECT_NSEQ(@"2f3b", [[buttons objectAtIndex:2] title]);
   EXPECT_EQ(oldDisplayedButtons, [buttons count]);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, ControllerForNode) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2b ] 3b ");
+  const std::string model_string("1b 2f:[ 2f1b 2f2b ] 3b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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 10 matching lines @@
   EXPECT_EQ(expectedController, actualController);
 
   // Find the folder controller from the bar.
   actualController = [folder controllerForNode:targetNode];
   EXPECT_EQ(expectedController, actualController);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, MenuSizingAndScrollArrows) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2b 3b ");
+  const std::string model_string("1b 2b 3b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   const BookmarkNode* parent = model.GetBookmarkBarNode();
   const BookmarkNode* folder = model.AddGroup(parent,
                                               parent->GetChildCount(),
                                               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 130 matching lines @@
     dragDataNodes.push_back(dragDataNode_);
   }
   return dragDataNodes;
 }
 
 @end
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragBookmarkData) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
-                                  "2f3b ] 3b 4b ");
+  const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
+                                 "2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
   const BookmarkNode* other = model.other_node();
-  const std::wstring other_string(L"O1b O2b O3f:[ O3f1b O3f2f ] "
-                                  "O4f:[ O4f1b O4f2f ] 05b ");
+  const std::string other_string("O1b O2b O3f:[ O3f1b O3f2f ] "
+                                 "O4f:[ O4f1b O4f2f ] 05b ");
   model_test_utils::AddNodesFromModelString(model, other, other_string);
 
   // Validate initial model.
-  std::wstring actual = model_test_utils::ModelStringFromNode(root);
+  std::string actual = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actual);
   actual = model_test_utils::ModelStringFromNode(other);
   EXPECT_EQ(other_string, actual);
 
   // Pop open a folder.
   BookmarkButton* button = [bar_ buttonWithTitleEqualTo:@"2f"];
   scoped_nsobject<BookmarkBarFolderControllerDragData> folderController;
   folderController.reset([[BookmarkBarFolderControllerDragData alloc]
                           initWithParentButton:button
                               parentController:nil
                                  barController:bar_]);
   [folderController window];
   BookmarkButton* targetButton =
       [folderController buttonWithTitleEqualTo:@"2f1b"];
   ASSERT_TRUE(targetButton);
 
   // Gen up some dragging data.
   const BookmarkNode* newNode = other->GetChild(2);
   [folderController setDragDataNode:newNode];
   scoped_nsobject<FakedDragInfo> dragInfo([[FakedDragInfo alloc] init]);
   [dragInfo setDropLocation:[targetButton top]];
   [folderController dragBookmarkData:(id<NSDraggingInfo>)dragInfo.get()];
 
   // Verify the model.
-  const std::wstring expected(L"1b 2f:[ O3f:[ O3f1b O3f2f ] 2f1b 2f2f:[ 2f2f1b "
-                              "2f2f2b 2f2f3b ] 2f3b ] 3b 4b ");
+  const std::string expected("1b 2f:[ O3f:[ O3f1b O3f2f ] 2f1b 2f2f:[ 2f2f1b "
+                             "2f2f2b 2f2f3b ] 2f3b ] 3b 4b ");
   actual = model_test_utils::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->GetTitleAsString16(), ASCIIToUTF16("O4f"));
   [folderController setDragDataNode:newNode];
   [dragInfo setDropLocation:[targetButton center]];
   [folderController dragBookmarkData:(id<NSDraggingInfo>)dragInfo.get()];
 
   // Verify the model.
-  const std::wstring expectedA(L"1b 2f:[ O3f:[ O3f1b O3f2f ] 2f1b 2f2f:[ "
-                               "2f2f1b 2f2f2b 2f2f3b O4f:[ O4f1b O4f2f ] ] "
+  const std::string expectedA("1b 2f:[ O3f:[ O3f1b O3f2f ] 2f1b 2f2f:[ "
+                              "2f2f1b 2f2f2b 2f2f3b O4f:[ O4f1b O4f2f ] ] "
                                "2f3b ] 3b 4b ");
   actual = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(expectedA, actual);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, AddURLs) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
-                                  "2f3b ] 3b 4b ");
+  const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
+                                 "2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actual = model_test_utils::ModelStringFromNode(root);
+  std::string actual = model_test_utils::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::wstring expected(L"1b 2f:[ SiteA SiteB 2f1b 2f2f:[ 2f2f1b 2f2f2b "
-                              "2f2f3b ] 2f3b ] 3b 4b ");
+  const std::string expected("1b 2f:[ SiteA SiteB 2f1b 2f2f:[ 2f2f1b 2f2f2b "
+                             "2f2f3b ] 2f3b ] 3b 4b ");
   actual = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DropPositionIndicator) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
-                                  "2f3b ] 3b 4b ");
+  const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b 2f2f3b ] "
+                                 "2f3b ] 3b 4b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actual = model_test_utils::ModelStringFromNode(root);
+  std::string actual = model_test_utils::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 30 matching lines @@
                    initialWidth:NSWidth([parent_view_ frame])
                        delegate:nil
                  resizeDelegate:resizeDelegate_.get()]);
     InstallAndToggleBar(bar_.get());
   }
 };
 
 TEST_F(BookmarkBarFolderControllerClosingTest, DeleteClosesFolder) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  const std::wstring model_string(L"1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b ] "
-                                   "2f3b ] 3b ");
+  const std::string model_string("1b 2f:[ 2f1b 2f2f:[ 2f2f1b 2f2f2b ] "
+                                 "2f3b ] 3b ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::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.
   [folder deleteBookmark:folder];
   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:.