Rework somewhat how the folder menu window and main view sizes and positions ...

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"
 #import "chrome/browser/cocoa/bookmark_bar_constants.h"  // namespace bookmarks
 #import "chrome/browser/cocoa/bookmark_bar_controller.h"
@@ skipping 103 matching lines @@
 - (void)childFolderWillClose:(id<BookmarkButtonControllerProtocol>)child {
   [childFolderDelegate_ childFolderWillClose:child];
 }
 
 @end
 
 
 class BookmarkBarFolderControllerTest : public CocoaTest {
  public:
   BrowserTestHelper helper_;
-  scoped_nsobject<BookmarkBarController> parentBarController_;
+  scoped_nsobject<BookmarkBarController> bar_;
   const BookmarkNode* folderA_;  // owned by model
   const BookmarkNode* longTitleNode_;  // owned by model
 
   BookmarkBarFolderControllerTest() {
     BookmarkModel* model = helper_.profile()->GetBookmarkModel();
     const BookmarkNode* parent = model->GetBookmarkBarNode();
     const BookmarkNode* folderA = model->AddGroup(parent,
                                                   parent->GetChildCount(),
                                                   L"group");
     folderA_ = folderA;
     model->AddGroup(parent, parent->GetChildCount(),
                     L"sibbling group");
     const BookmarkNode* folderB = model->AddGroup(folderA,
                                                   folderA->GetChildCount(),
                                                   L"subgroup 1");
     model->AddGroup(folderA,
                     folderA->GetChildCount(),
                     L"subgroup 2");
     model->AddURL(folderA, folderA->GetChildCount(), L"title a",
                   GURL("http://www.google.com/a"));
     longTitleNode_ = model->AddURL(
       folderA, folderA->GetChildCount(),
       L"title super duper long long whoa momma title you betcha",
       GURL("http://www.google.com/b"));
     model->AddURL(folderB, folderB->GetChildCount(), L"t",
                   GURL("http://www.google.com/c"));
 
-    parentBarController_.reset(
+    bar_.reset(
       [[BookmarkBarControllerChildFolderRedirect alloc]
           initWithBrowser:helper_.browser()
              initialWidth:300
                  delegate:nil
            resizeDelegate:nil]);
-    [parentBarController_ loaded:model];
+    [bar_ loaded:model];
     // Make parent frame for bookmark bar then open it.
     NSRect frame = [[test_window() contentView] frame];
     frame = NSInsetRect(frame, 100, 200);
     NSView* fakeToolbarView = [[[NSView alloc] initWithFrame:frame]
                                 autorelease];
     [[test_window() contentView] addSubview:fakeToolbarView];
-    [fakeToolbarView addSubview:[parentBarController_ view]];
-    [parentBarController_ setBookmarkBarEnabled:YES];
+    [fakeToolbarView addSubview:[bar_ view]];
+    [bar_ setBookmarkBarEnabled:YES];
   }
 
   // Remove the bookmark with the long title.
   void RemoveLongTitleNode() {
     BookmarkModel* model = helper_.profile()->GetBookmarkModel();
     model->Remove(longTitleNode_->GetParent(),
                   longTitleNode_->GetParent()->IndexOfChild(longTitleNode_));
   }
 
   // Add LOTS of nodes to our model if needed (e.g. scrolling).
   // Returns the number of nodes added.
   int AddLotsOfNodes() {
     BookmarkModel* model = helper_.profile()->GetBookmarkModel();
     for (int i = 0; i < kLotsOfNodesCount; i++) {
       model->AddURL(folderA_, folderA_->GetChildCount(), L"repeated title",
                     GURL("http://www.google.com/repeated/url"));
     }
     return kLotsOfNodesCount;
   }
 
 
   // Return a simple BookmarkBarFolderController.
   BookmarkBarFolderControllerPong* SimpleBookmarkBarFolderController() {
-    BookmarkButton* parentButton = [[parentBarController_ buttons]
-                                     objectAtIndex:0];
+    BookmarkButton* parentButton = [[bar_ buttons] objectAtIndex:0];
     BookmarkBarFolderControllerPong* c =
       [[BookmarkBarFolderControllerPong alloc]
                initWithParentButton:parentButton
                    parentController:nil
-                      barController:parentBarController_];
+                      barController:bar_];
     [c window];  // Force nib load.
     return c;
   }
 };
 
 TEST_F(BookmarkBarFolderControllerTest, InitCreateAndDelete) {
   scoped_nsobject<BookmarkBarFolderController> bbfc;
   bbfc.reset(SimpleBookmarkBarFolderController());
 
   // Make sure none of the buttons overlap, that all are inside
@@ skipping 27 matching lines @@
 TEST_F(BookmarkBarFolderControllerTest, ReleaseOnClose) {
   scoped_nsobject<BookmarkBarFolderController> bbfc;
   bbfc.reset(SimpleBookmarkBarFolderController());
   EXPECT_TRUE(bbfc.get());
 
   [bbfc retain];  // stop the scoped_nsobject from doing anything
   [[bbfc window] close];  // trigger an autorelease of bbfc.get()
 }
 
 TEST_F(BookmarkBarFolderControllerTest, BasicPosition) {
- BookmarkButton* parentButton = [[parentBarController_ buttons]
-                                   objectAtIndex:0];
+ BookmarkButton* parentButton = [[bar_ buttons] objectAtIndex:0];
   EXPECT_TRUE(parentButton);
 
   // If parent is a BookmarkBarController, grow down.
   scoped_nsobject<BookmarkBarFolderControllerLow> bbfc;
   bbfc.reset([[BookmarkBarFolderControllerLow alloc]
                initWithParentButton:parentButton
                    parentController:nil
-                      barController:parentBarController_]);
+                      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), 2);
   EXPECT_LE(abs(pt.y - buttonOriginInScreen.y), 2);
 
   // 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]
                 initWithParentButton:[[bbfc buttons] objectAtIndex:0]
                     parentController:bbfc.get()
-                       barController:parentBarController_]);
+                       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();
   const BookmarkNode* parent = model->GetBookmarkBarNode();
   const BookmarkNode* folder = parent;
 
   const int count = 100;
   int i;
   // Make some super duper deeply nested folders.
   for (i=0; i<count; i++) {
     folder = model->AddGroup(folder, 0, L"nested folder");
   }
 
   // Setup initial state for opening all folders.
   folder = parent;
-  BookmarkButton* parentButton = [[parentBarController_ buttons]
-                                   objectAtIndex:0];
+  BookmarkButton* parentButton = [[bar_ buttons] objectAtIndex:0];
   BookmarkBarFolderController* parentController = nil;
   EXPECT_TRUE(parentButton);
 
   // Open them all.
   scoped_nsobject<NSMutableArray> folder_controller_array;
   folder_controller_array.reset([[NSMutableArray array] retain]);
   for (i=0; i<count; i++) {
     BookmarkBarFolderControllerNoLevel* bbfcl =
         [[BookmarkBarFolderControllerNoLevel alloc]
           initWithParentButton:parentButton
               parentController:parentController
-                 barController:parentBarController_];
+                 barController:bar_];
     [folder_controller_array addObject:bbfcl];
     [bbfcl autorelease];
     [bbfcl window];
     parentController = bbfcl;
     parentButton = [[bbfcl buttons] objectAtIndex:0];
   }
 
   // Make vector of all x positions.
   std::vector<CGFloat> leftPositions;
   for (i=0; i<count; i++) {
@@ skipping 81 matching lines @@
 
   // Close it --> all gone!
   [bbfc closeBookmarkFolder:nil];
   EXPECT_FALSE([bbfc folderController]);
 }
 
 TEST_F(BookmarkBarFolderControllerTest, ChildFolderCallbacks) {
   scoped_nsobject<BookmarkBarFolderControllerPong> bbfc;
   bbfc.reset(SimpleBookmarkBarFolderController());
   EXPECT_TRUE(bbfc.get());
-  [parentBarController_ setChildFolderDelegate:bbfc.get()];
+  [bar_ setChildFolderDelegate:bbfc.get()];
 
   EXPECT_FALSE([bbfc childFolderWillShow]);
   [bbfc openBookmarkFolderFromButton:[[bbfc buttons] objectAtIndex:0]];
   EXPECT_TRUE([bbfc childFolderWillShow]);
 
   EXPECT_FALSE([bbfc childFolderWillClose]);
   [bbfc closeBookmarkFolder:nil];
   EXPECT_TRUE([bbfc childFolderWillClose]);
 
-  [parentBarController_ setChildFolderDelegate:nil];
+  [bar_ setChildFolderDelegate:nil];
 }
 
 // Make sure bookmark folders have variable widths.
 TEST_F(BookmarkBarFolderControllerTest, ChildFolderWidth) {
   scoped_nsobject<BookmarkBarFolderController> bbfc;
 
   bbfc.reset(SimpleBookmarkBarFolderController());
   EXPECT_TRUE(bbfc.get());
   [bbfc showWindow:bbfc.get()];
   CGFloat wideWidth = NSWidth([[bbfc window] frame]);
@@ skipping 62 matching lines @@
   // way.
   for (int i=0; i<nodecount+50; i++) {
     CGFloat height = NSHeight([[bbfc window] frame]);
     [bbfc performOneScroll:-60];
     EXPECT_EQ(height, NSHeight([[bbfc window] frame]));
     EXPECT_TRUE(NSContainsRect(screenFrame,
                                [[bbfc window] frame]));
   }
 }
 
+// Folder menu sizing and placementwhile 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
+  // not moved. Pick a button which is near the top and visible.
+  CGFloat oldTop = [menuWindow frame].origin.y + NSHeight([menuWindow frame]);
+  BookmarkButton* button = [buttons objectAtIndex:3];
+  [folder deleteBookmark:button];
+  CGFloat newTop = [menuWindow frame].origin.y + NSHeight([menuWindow frame]);
+  EXPECT_CGFLOAT_EQ(oldTop, newTop);
+
+  // Scroll so that both the top and bottom scroll arrows show, make sure
+  // the top of the window has moved up, then delete a visible button and
+  // make sure the top has not moved.
+  oldTop = newTop;
+  const CGFloat scrollOneBookmark = bookmarks::kBookmarkButtonHeight +
+      bookmarks::kBookmarkVerticalPadding;
+  NSUInteger buttonCounter = 0;
+  NSUInteger extraButtonLimit = 3;
+  while (![bbfc canScrollDown] || extraButtonLimit > 0) {
+    [bbfc performOneScroll:scrollOneBookmark];
+    ++buttonCounter;
+    if ([bbfc canScrollDown])
+      --extraButtonLimit;
+  }
+  newTop = [menuWindow frame].origin.y + NSHeight([menuWindow frame]);
+  EXPECT_NE(oldTop, newTop);
+  oldTop = newTop;
+  button = [buttons objectAtIndex:buttonCounter + 3];
+  [folder deleteBookmark:button];
+  newTop = [menuWindow frame].origin.y + NSHeight([menuWindow frame]);
+  EXPECT_CGFLOAT_EQ(oldTop, newTop);
+
+  // 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);
+}
+
 @interface FakedDragInfo : NSObject {
 @public
   NSPoint dropLocation_;
   NSDragOperation sourceMask_;
 }
 @property (nonatomic, assign) NSPoint dropLocation;
 - (void)setDraggingSourceOperationMask:(NSDragOperation)mask;
 @end
 
 @implementation FakedDragInfo
@@ skipping 555 matching lines @@
                                               L"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);
-  CGFloat expectedHeight = (CGFloat)bookmarks::kBookmarkButtonHeight;
+  CGFloat expectedHeight = (CGFloat)bookmarks::kBookmarkButtonHeight +
+      bookmarks::kBookmarkVerticalPadding;
   NSRect menuFrame = [folderMenu frame];
   CGFloat menuHeight = NSHeight(menuFrame);
   EXPECT_CGFLOAT_EQ(expectedHeight, menuHeight);
   EXPECT_FALSE([folderController scrollable]);
 
   // Now add a real bookmark and reopen.
   model.AddURL(folder, folder->GetChildCount(), L"a", GURL("http://a.com/"));
   folderController = [bar_ folderController];
   EXPECT_TRUE(folderController);
   folderMenu = [folderController window];
@@ skipping 269 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:.