Rework how bookmark bar folder menus and submenus are layed out when scrollin...

chrome/browser/ui/cocoa/bookmarks/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 46 matching lines @@
 // For testing.
 @interface BookmarkBarFolderControllerNoLevel : BookmarkBarFolderController
 @end
 
 @implementation BookmarkBarFolderControllerNoLevel
 - (void)configureWindowLevel {
   // Intentionally empty.
 }
 @end
 
-// No window level and the ability to fake the "top left" point of the window.
-// For testing.
-@interface BookmarkBarFolderControllerLow : BookmarkBarFolderControllerNoLevel {
-  BOOL realTopLeft_;  // Use the real windowTopLeft call?
-}
-@property (nonatomic) BOOL realTopLeft;
-@end
-
-
-@implementation BookmarkBarFolderControllerLow
-
-@synthesize realTopLeft = realTopLeft_;
-
-- (NSPoint)windowTopLeftForWidth:(int)width {
-  return realTopLeft_ ? [super windowTopLeftForWidth:width] :
-      NSMakePoint(200,200);
-}
-
-@end
-
-
-@interface BookmarkBarFolderControllerPong : BookmarkBarFolderControllerLow {
+@interface BookmarkBarFolderControllerPong : BookmarkBarFolderController {
   BOOL childFolderWillShow_;
   BOOL childFolderWillClose_;
 }
 @property (nonatomic, readonly) BOOL childFolderWillShow;
 @property (nonatomic, readonly) BOOL childFolderWillClose;
 @end
 
 @implementation BookmarkBarFolderControllerPong
 @synthesize childFolderWillShow = childFolderWillShow_;
 @synthesize childFolderWillClose = childFolderWillClose_;
@@ skipping 75 matching lines @@
 
     bar_.reset(
       [[BookmarkBarControllerChildFolderRedirect alloc]
           initWithBrowser:helper_.browser()
              initialWidth:300
                  delegate:nil
            resizeDelegate:nil]);
     [bar_ loaded:model];
     // Make parent frame for bookmark bar then open it.
     NSRect frame = [[test_window() contentView] frame];
-    frame = NSInsetRect(frame, 100, 200);
+    frame = NSMakeRect(frame.origin.x,
+                       frame.size.height - bookmarks::kNTPBookmarkBarHeight,
+                       frame.size.width, bookmarks::kNTPBookmarkBarHeight);
     NSView* fakeToolbarView = [[[NSView alloc] initWithFrame:frame]
                                 autorelease];
     [[test_window() contentView] addSubview:fakeToolbarView];
     [fakeToolbarView addSubview:[bar_ view]];
     [bar_ setBookmarkBarEnabled:YES];
   }
 
   // Remove the bookmark with the long title.
   void RemoveLongTitleNode() {
     BookmarkModel* model = helper_.profile()->GetBookmarkModel();
@@ skipping 33 matching lines @@
   // Make sure none of the buttons overlap, that all are inside
   // the content frame, and their cells are of the proper class.
   NSArray* buttons = [bbfc buttons];
   EXPECT_TRUE([buttons count]);
   for (unsigned int i = 0; i < ([buttons count]-1); i++) {
     EXPECT_FALSE(NSContainsRect([[buttons objectAtIndex:i] frame],
                               [[buttons objectAtIndex:i+1] frame]));
   }
   Class cellClass = [BookmarkBarFolderButtonCell class];
   for (BookmarkButton* button in buttons) {
-    NSRect r = [[bbfc mainView] convertRect:[button frame] fromView:button];
+    NSRect r = [[bbfc folderView] convertRect:[button frame] fromView:button];
     // TODO(jrg): remove this adjustment.
-    NSRect bigger = NSInsetRect([[bbfc mainView] frame], -2, 0);
+    NSRect bigger = NSInsetRect([[bbfc folderView] frame], -2, 0);
     EXPECT_TRUE(NSContainsRect(bigger, r));
     EXPECT_TRUE([[button cell] isKindOfClass:cellClass]);
   }
 
   // Confirm folder buttons have no tooltip.  The important thing
   // really is that we insure folders and non-folders are treated
   // differently; not sure of any other generic way to do this.
   for (BookmarkButton* button in buttons) {
     if ([button isFolder])
       EXPECT_FALSE([button toolTip]);
@@ skipping 11 matching lines @@
 
   [bbfc retain];  // stop the scoped_nsobject from doing anything
   [[bbfc window] close];  // trigger an autorelease of bbfc.get()
 }
 
 TEST_F(BookmarkBarFolderControllerTest, BasicPosition) {
  BookmarkButton* parentButton = [[bar_ buttons] objectAtIndex:0];
   EXPECT_TRUE(parentButton);
 
   // If parent is a BookmarkBarController, grow down.
-  scoped_nsobject<BookmarkBarFolderControllerLow> bbfc;
-  bbfc.reset([[BookmarkBarFolderControllerLow alloc]
+  scoped_nsobject<BookmarkBarFolderController> bbfc;
+  bbfc.reset([[BookmarkBarFolderController alloc]
                initWithParentButton:parentButton
                    parentController:nil
                       barController:bar_]);
   [bbfc window];
-  [bbfc setRealTopLeft:YES];
   NSPoint pt = [bbfc windowTopLeftForWidth:0];  // screen coords
   NSPoint buttonOriginInScreen =
       [[parentButton window]
         convertBaseToScreen:[parentButton
                               convertRectToBase:[parentButton frame]].origin];
   // Within margin
   EXPECT_LE(abs(pt.x - buttonOriginInScreen.x),
             bookmarks::kBookmarkMenuOverlap+1);
   EXPECT_LE(abs(pt.y - buttonOriginInScreen.y),
             bookmarks::kBookmarkMenuOverlap+1);
 
   // Make sure we see the window shift left if it spills off the screen
   pt = [bbfc windowTopLeftForWidth:0];
   NSPoint shifted = [bbfc windowTopLeftForWidth:9999999];
   EXPECT_LT(shifted.x, pt.x);
 
   // If parent is a BookmarkBarFolderController, grow right.
-  scoped_nsobject<BookmarkBarFolderControllerLow> bbfc2;
-  bbfc2.reset([[BookmarkBarFolderControllerLow alloc]
+  scoped_nsobject<BookmarkBarFolderController> bbfc2;
+  bbfc2.reset([[BookmarkBarFolderController alloc]
                 initWithParentButton:[[bbfc buttons] objectAtIndex:0]
                     parentController:bbfc.get()
                        barController:bar_]);
   [bbfc2 window];
-  [bbfc2 setRealTopLeft:YES];
   pt = [bbfc2 windowTopLeftForWidth:0];
   // We're now overlapping the window a bit.
   EXPECT_EQ(pt.x, NSMaxX([[bbfc.get() window] frame]) -
             bookmarks::kBookmarkMenuOverlap);
 }
 
 // Confirm we grow right until end of screen, then start growing left
 // until end of screen again, then right.
 TEST_F(BookmarkBarFolderControllerTest, PositionRightLeftRight) {
   BookmarkModel* model = helper_.profile()->GetBookmarkModel();
@@ skipping 56 matching lines @@
   // (No need to EXPECT a final "grow right"; if we didn't find one
   // we'd get a C++ array bounds exception).
 }
 
 TEST_F(BookmarkBarFolderControllerTest, DropDestination) {
   scoped_nsobject<BookmarkBarFolderController> bbfc;
   bbfc.reset(SimpleBookmarkBarFolderController());
   EXPECT_TRUE(bbfc.get());
 
   // Confirm "off the top" and "off the bottom" match no buttons.
-  NSPoint p = NSMakePoint(NSMidX([[bbfc mainView] frame]), 10000);
+  NSPoint p = NSMakePoint(NSMidX([[bbfc folderView] frame]), 10000);
   EXPECT_FALSE([bbfc buttonForDroppingOnAtPoint:p]);
   EXPECT_TRUE([bbfc shouldShowIndicatorShownForPoint:p]);
-  p = NSMakePoint(NSMidX([[bbfc mainView] frame]), -1);
+  p = NSMakePoint(NSMidX([[bbfc folderView] frame]), -1);
   EXPECT_FALSE([bbfc buttonForDroppingOnAtPoint:p]);
   EXPECT_TRUE([bbfc shouldShowIndicatorShownForPoint:p]);
 
   // Confirm "right in the center" (give or take a pixel) is a match,
   // and confirm "just barely in the button" is not.  Anything more
   // specific seems likely to be tweaked.  We don't loop over all
   // buttons because the scroll view makes them not visible.
   for (BookmarkButton* button in [bbfc buttons]) {
     CGFloat x = NSMidX([button frame]);
     CGFloat y = NSMidY([button frame]);
@@ skipping 70 matching lines @@
   EXPECT_TRUE(bbfc.get());
   CGFloat thinWidth = NSWidth([[bbfc window] frame]);
 
   // Make sure window size changed as expected.
   EXPECT_GT(wideWidth, thinWidth);
 }
 
 // Simple scrolling tests.
 TEST_F(BookmarkBarFolderControllerTest, SimpleScroll) {
   scoped_nsobject<BookmarkBarFolderController> bbfc;
-
+  NSRect screenFrame = [[NSScreen mainScreen] frame];
+  CGFloat screenHeight = NSHeight(screenFrame);
   int nodecount = AddLotsOfNodes();
   bbfc.reset(SimpleBookmarkBarFolderController());
   EXPECT_TRUE(bbfc.get());
   [bbfc showWindow:bbfc.get()];
+  NSWindow* window = [bbfc window];
 
-  // Make sure the window fits on the screen.
-  EXPECT_LT(NSHeight([[bbfc window] frame]),
-            NSHeight([[NSScreen mainScreen] frame]));
+  // The window should be shorter than the screen but reach exactly to the
+  // bottom of the screen since it's scrollable.
+  EXPECT_LT(NSHeight([window frame]), screenHeight);
+  EXPECT_CGFLOAT_EQ(0.0, [window frame].origin.y);
 
-  // Verify the logic used by the scroll arrow code.
+  // Initially, should show scroll-up but not scroll-down.
   EXPECT_TRUE([bbfc canScrollUp]);
   EXPECT_FALSE([bbfc canScrollDown]);
 
-  // Scroll it up.  Make sure the window has gotten bigger each time.
+  // Scroll up a bit.  Make sure the window has gotten bigger each time.
   // Also, for each scroll, make sure our hit test finds a new button
   // (to confirm the content area changed).
   NSView* savedHit = nil;
-  for (int i=0; i<3; i++) {
-    CGFloat height = NSHeight([[bbfc window] frame]);
+  NSView* scrollView = [bbfc scrollView];
+
+  // Find the next-to-last button showing at the bottom of the window and
+  // us its center for hit testing.
+  BookmarkButton* targetButton = nil;
+  NSPoint scrollPoint = [[bbfc scrollView] documentVisibleRect].origin;
+  for (BookmarkButton* button in [bbfc buttons]) {
+    NSRect buttonFrame = [button frame];
+    buttonFrame.origin.y -= scrollPoint.y;
+    if (buttonFrame.origin.y < 0.0)
+      break;
+    targetButton = button;
+  }
+  NSPoint hitPoint = [targetButton frame].origin;
+  hitPoint.x += 50.0;
+  hitPoint.y += (bookmarks::kBookmarkButtonHeight / 2.0) - scrollPoint.y;
+
+  for (int i = 0; i < 3; i++) {
+    CGFloat height = NSHeight([window frame]);
     [bbfc performOneScroll:60];
-    EXPECT_GT(NSHeight([[bbfc window] frame]), height);
-    NSView* hit = [[[bbfc window] contentView] hitTest:NSMakePoint(22, 22)];
+    EXPECT_GT(NSHeight([window frame]), height);
+    NSView* hit = [scrollView hitTest:hitPoint];
+    // We should hit a bookmark button.
+    EXPECT_TRUE([[hit className] isEqualToString:@"BookmarkButton"]);
     EXPECT_NE(hit, savedHit);
     savedHit = hit;
   }
 
   // Keep scrolling up; make sure we never get bigger than the screen.
   // Also confirm we never scroll the window off the screen.
   bool bothAtOnce = false;
-  NSRect screenFrame = [[NSScreen mainScreen] frame];
-  for (int i = 0; i < nodecount; i++) {
+  while ([bbfc canScrollUp]) {
     [bbfc performOneScroll:60];
-    EXPECT_TRUE(NSContainsRect(screenFrame,
-                               [[bbfc window] frame]));
+    EXPECT_TRUE(NSContainsRect(screenFrame, [window frame]));
     // Make sure, sometime during our scroll, we have the ability to
     // scroll in either direction.
     if ([bbfc canScrollUp] &&
         [bbfc canScrollDown])
       bothAtOnce = true;
   }
   EXPECT_TRUE(bothAtOnce);
 
   // Once we've scrolled to the end, our only option should be to scroll back.
   EXPECT_FALSE([bbfc canScrollUp]);
   EXPECT_TRUE([bbfc canScrollDown]);
 
   // Now scroll down and make sure the window size does not change.
   // Also confirm we never scroll the window off the screen the other
   // way.
-  for (int i=0; i<nodecount+50; i++) {
-    CGFloat height = NSHeight([[bbfc window] frame]);
+  for (int i = 0; i < nodecount+50; ++i) {
     [bbfc performOneScroll:-60];
-    EXPECT_EQ(height, NSHeight([[bbfc window] frame]));
-    EXPECT_TRUE(NSContainsRect(screenFrame,
-                               [[bbfc window] frame]));
+    // Once we can no longer scroll down the window height changes.
+    if (![bbfc canScrollDown])
+      break;
+    EXPECT_EQ(screenHeight, NSHeight([window frame]));
+    EXPECT_TRUE(NSContainsRect(screenFrame, [window frame]));
   }
+  // The final height should be offset from the top of the screen and still
+  // within the screen.
+  CGFloat height = screenHeight - bookmarks::kScrollWindowVerticalMargin;
+  EXPECT_CGFLOAT_EQ(height, NSHeight([window frame]));
+  EXPECT_TRUE(NSContainsRect(screenFrame, [window frame]));
 }
 
-// Folder menu sizing and placementwhile deleting bookmarks and scrolling tests.
+// Folder menu sizing and placement while deleting bookmarks
+// and scrolling tests.
 TEST_F(BookmarkBarFolderControllerTest, MenuPlacementWhileScrollingDeleting) {
   scoped_nsobject<BookmarkBarFolderController> bbfc;
   AddLotsOfNodes();
   bbfc.reset(SimpleBookmarkBarFolderController());
   [bbfc showWindow:bbfc.get()];
   NSWindow* menuWindow = [bbfc window];
   BookmarkBarFolderController* folder = [bar_ folderController];
   NSArray* buttons = [folder buttons];
 
   // Before scrolling any, delete a bookmark and make sure the window top has
@@ skipping 29 matching lines @@
   // Scroll so that the top scroll arrow is no longer showing, make sure
   // the top of the window has not moved, then delete a visible button and
   // make sure the top has not moved.
   while ([bbfc canScrollDown]) {
     [bbfc performOneScroll:-scrollOneBookmark];
     --buttonCounter;
   }
   button = [buttons objectAtIndex:buttonCounter + 3];
   [folder deleteBookmark:button];
   newTop = [menuWindow frame].origin.y + NSHeight([menuWindow frame]);
-  EXPECT_CGFLOAT_EQ(oldTop, newTop);
+  EXPECT_CGFLOAT_EQ(oldTop - bookmarks::kScrollWindowVerticalMargin, newTop);
 }
 
 @interface FakedDragInfo : NSObject {
 @public
   NSPoint dropLocation_;
   NSDragOperation sourceMask_;
 }
 @property (nonatomic, assign) NSPoint dropLocation;
 - (void)setDraggingSourceOperationMask:(NSDragOperation)mask;
 @end
@@ skipping 56 matching lines @@
                  resizeDelegate:resizeDelegate_.get()]);
     InstallAndToggleBar(bar_.get());
   }
 
   void InstallAndToggleBar(BookmarkBarController* bar) {
     // Force loading of the nib.
     [bar view];
     // Awkwardness to look like we've been installed.
     [parent_view_ addSubview:[bar view]];
     NSRect frame = [[[bar view] superview] frame];
-    frame.origin.y = 100;
+    frame.origin.y = 400;
     [[[bar view] superview] setFrame:frame];
 
     // Make sure it's on in a window so viewDidMoveToWindow is called
     [[test_window() contentView] addSubview:parent_view_];
 
     // Make sure it's open so certain things aren't no-ops.
     [bar updateAndShowNormalBar:YES
                 showDetachedBar:NO
                   withAnimation:NO];
   }
@@ skipping 193 matching lines @@
   [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::kBookmarkBarHeight + bookmarks::kVisualHeightOffset;
+      (bookmarks::kBookmarkButtonHeight + bookmarks::kVisualHeightOffset);
   expectedToSubwindowFrame.size.height +=
-      bookmarks::kBookmarkBarHeight + bookmarks::kVisualHeightOffset;
+      (bookmarks::kBookmarkButtonHeight + bookmarks::kVisualHeightOffset);
   EXPECT_NSRECT_EQ(expectedToSubwindowFrame, newToSubwindowFrame);
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragMoveWithinFolder) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
   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);
@@ skipping 280 matching lines @@
   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:)
                         withObject:button];
   BookmarkBarFolderController* folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
-  NSWindow* folderMenu = [folderController window];
-  EXPECT_TRUE(folderMenu);
+  NSWindow* folderWindow = [folderController window];
+  EXPECT_TRUE(folderWindow);
   CGFloat expectedHeight = (CGFloat)bookmarks::kBookmarkButtonHeight +
       (2*bookmarks::kBookmarkVerticalPadding);
-  NSRect menuFrame = [folderMenu frame];
-  CGFloat menuHeight = NSHeight(menuFrame);
-  EXPECT_CGFLOAT_EQ(expectedHeight, menuHeight);
-  EXPECT_FALSE([folderController scrollable]);
+  NSRect windowFrame = [folderWindow frame];
+  CGFloat windowHeight = NSHeight(windowFrame);
+  EXPECT_CGFLOAT_EQ(expectedHeight, windowHeight);
+  EXPECT_FALSE([folderController canScrollUp]);
+  EXPECT_FALSE([folderController canScrollDown]);
 
   // Now add a real bookmark and reopen.
   model.AddURL(folder, folder->GetChildCount(), ASCIIToUTF16("a"),
                GURL("http://a.com/"));
   folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
-  folderMenu = [folderController window];
-  EXPECT_TRUE(folderMenu);
-  menuFrame = [folderMenu frame];
-  menuHeight = NSHeight(menuFrame);
+  NSView* folderView = [folderController folderView];
+  EXPECT_TRUE(folderView);
+  NSRect menuFrame = [folderView frame];
+  NSView* visibleView = [folderController visibleView];
+  NSRect visibleFrame = [visibleView frame];
+  NSView* scrollView = [folderController scrollView];
+  NSRect scrollFrame = [scrollView frame];
+
+  // Determine the margins between the scroll frame and the visible frame.
+  CGFloat widthDelta = NSWidth(visibleFrame) - NSWidth(scrollFrame);
+
+  CGFloat menuHeight = NSHeight(menuFrame);
   EXPECT_CGFLOAT_EQ(expectedHeight, menuHeight);
-  CGFloat menuWidth = NSWidth(menuFrame);
+  CGFloat scrollerWidth = NSWidth(scrollFrame);
   button = [folderController buttonWithTitleEqualTo:@"a"];
   CGFloat buttonWidth = NSWidth([button frame]);
-  CGFloat expectedWidth =
-      buttonWidth + (2 * bookmarks::kBookmarkSubMenuHorizontalPadding);
-  EXPECT_CGFLOAT_EQ(expectedWidth, menuWidth);
+  EXPECT_CGFLOAT_EQ(scrollerWidth, buttonWidth);
+  CGFloat visibleWidth = NSWidth(visibleFrame);
+  EXPECT_CGFLOAT_EQ(visibleWidth - widthDelta, buttonWidth);
+  EXPECT_LT(scrollerWidth, NSWidth([folderView frame]));
 
   // Add a wider bookmark and make sure the button widths match.
-  model.AddURL(folder, folder->GetChildCount(),
-               ASCIIToUTF16("A really, really long name"),
+  int reallyWideButtonNumber = folder->GetChildCount();
+  model.AddURL(folder, reallyWideButtonNumber,
+               ASCIIToUTF16("A really, really, really, really, really, "
+                            "really long name"),
                GURL("http://www.google.com/a"));
-  EXPECT_LT(menuWidth, NSWidth([folderMenu frame]));
-  EXPECT_LT(buttonWidth, NSWidth([button frame]));
-  buttonWidth = NSWidth([button frame]);
-  BookmarkButton* buttonB =
-      [folderController buttonWithTitleEqualTo:@"A really, really long name"];
-  EXPECT_TRUE(buttonB);
-  CGFloat buttonWidthB = NSWidth([buttonB frame]);
-  EXPECT_CGFLOAT_EQ(buttonWidth, buttonWidthB);
-  // Add a bunch of bookmarks until the window grows no more, then check for
-  // a scroll down arrow.
-  CGFloat oldMenuHeight = 0.0;  // It just has to be different for first run.
-  menuHeight = NSHeight([folderMenu frame]);
+  BookmarkButton* bigButton =
+      [folderController buttonWithTitleEqualTo:
+       @"A really, really, really, really, really, really long name"];
+  EXPECT_TRUE(bigButton);
+  CGFloat buttonWidthB = NSWidth([bigButton frame]);
+  EXPECT_LT(buttonWidth, buttonWidthB);
+  // Add a bunch of bookmarks until the window becomes scrollable, then check
+  // for a scroll up arrow.
   NSUInteger tripWire = 0;  // Prevent a runaway.
-  while (![folderController scrollable] && ++tripWire < 100) {
+  while (![folderController canScrollUp] && ++tripWire < 1000) {
     model.AddURL(folder, folder->GetChildCount(), ASCIIToUTF16("B"),
                  GURL("http://b.com/"));
-    oldMenuHeight = menuHeight;
-    menuHeight = NSHeight([folderMenu frame]);
   }
-  EXPECT_TRUE([folderController scrollable]);
   EXPECT_TRUE([folderController canScrollUp]);
 
   // Remove one bookmark and make sure the scroll down arrow has been removed.
   // We'll remove the really long node so we can see if the buttons get resized.
-  menuWidth = NSWidth([folderMenu frame]);
+  scrollerWidth = NSWidth([folderView frame]);
   buttonWidth = NSWidth([button frame]);
-  model.Remove(folder, 1);
-  EXPECT_FALSE([folderController scrollable]);
+  model.Remove(folder, reallyWideButtonNumber);
   EXPECT_FALSE([folderController canScrollUp]);
   EXPECT_FALSE([folderController canScrollDown]);
 
   // Check the size. It should have reduced.
-  EXPECT_GT(menuWidth, NSWidth([folderMenu frame]));
+  EXPECT_GT(scrollerWidth, NSWidth([folderView frame]));
   EXPECT_GT(buttonWidth, NSWidth([button frame]));
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 // See http://crbug.com/46101
 TEST_F(BookmarkBarFolderControllerMenuTest, HoverThenDeleteBookmark) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
@@ skipping 106 matching lines @@
   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 ");
+                              "2f3b ] 3b 4b ");
   actual = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(expectedA, actual);
 
   // Check button spacing.
   [folderController validateMenuSpacing];
 }
 
 TEST_F(BookmarkBarFolderControllerMenuTest, DragBookmarkDataToTrash) {
   BookmarkModel& model(*helper_.profile()->GetBookmarkModel());
   const BookmarkNode* root = model.GetBookmarkBarNode();
@@ skipping 167 matching lines @@
   [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:.