[Mac] Fix handling of download shelf auto close.

chrome/browser/ui/cocoa/download/download_shelf_controller.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "chrome/browser/ui/cocoa/download/download_shelf_controller.h"
 
 #include "base/mac/bundle_locations.h"
 #include "base/mac/mac_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/browser/download/download_util.h"
@@ skipping 13 matching lines @@
 #include "content/public/browser/download_manager.h"
 #import "third_party/GTM/AppKit/GTMNSAnimation+Duration.h"
 #import "ui/base/cocoa/hover_button.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::DownloadItem;
 
 // Download shelf autoclose behavior:
 //
 // The download shelf autocloses if all of this is true:
-// 1) An item on the shelf has just been opened.
+// 1) An item on the shelf has just been opened or removed.
 // 2) All remaining items on the shelf have been opened in the past.
 // 3) The mouse leaves the shelf and remains off the shelf for 5 seconds.
 //
 // If the mouse re-enters the shelf within the 5 second grace period, the
 // autoclose is canceled.  An autoclose can only be scheduled in response to a
 // shelf item being opened or removed.  If an item is opened and then the
 // resulting autoclose is canceled, subsequent mouse exited events will NOT
 // trigger an autoclose.
 //
 // If the shelf is manually closed while a download is still in progress, that
@@ skipping 19 matching lines @@
 // Amount of time between when the mouse is moved off the shelf and the shelf is
 // autoclosed, in seconds.
 const NSTimeInterval kAutoCloseDelaySeconds = 5;
 
 // The size of the x button by default.
 const NSSize kHoverCloseButtonDefaultSize = { 18, 18 };
 
 }  // namespace
 
 @interface DownloadShelfController(Private)
+- (void)removeDownload:(DownloadItemController*)download
+        isShelfClosing:(BOOL)isShelfClosing;
 - (void)layoutItems:(BOOL)skipFirst;
 - (void)closed;
 - (void)maybeAutoCloseAfterDelay;
+- (void)scheduleAutoClose;
+- (void)cancelAutoClose;
 - (void)autoClose;
 - (void)viewFrameDidChange:(NSNotification*)notification;
 - (void)installTrackingArea;
-- (void)cancelAutoCloseAndRemoveTrackingArea;
+- (void)removeTrackingArea;
 - (void)willEnterFullscreen;
 - (void)willLeaveFullscreen;
 - (void)updateCloseButton;
 @end
 
 
 @implementation DownloadShelfController
 
 - (id)initWithBrowser:(Browser*)browser
        resizeDelegate:(id<ViewResizer>)resizeDelegate {
@@ skipping 38 matching lines @@
   // These notifications are declared in fullscreen_controller, and are posted
   // without objects.
   [defaultCenter addObserver:self
                     selector:@selector(willEnterFullscreen)
                         name:kWillEnterFullscreenNotification
                       object:nil];
   [defaultCenter addObserver:self
                     selector:@selector(willLeaveFullscreen)
                         name:kWillLeaveFullscreenNotification
                       object:nil];
+  [self installTrackingArea];
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
-  [self cancelAutoCloseAndRemoveTrackingArea];
+  [self removeTrackingArea];
 
   // The controllers will unregister themselves as observers when they are
   // deallocated. No need to do that here.
   [super dealloc];
 }
 
 // Called after the frame's rect has changed; usually when the height is
 // animated.
 - (void)viewFrameDidChange:(NSNotification*)notification {
   // Anchor subviews at the top of |view|, so that it looks like the shelf
@@ skipping 16 matching lines @@
 
 - (IBAction)showDownloadsTab:(id)sender {
   chrome::ShowDownloads(bridge_->browser());
 }
 
 - (IBAction)handleClose:(id)sender {
   bridge_->Close(DownloadShelf::USER_ACTION);
 }
 
 - (void)remove:(DownloadItemController*)download {
+  [self removeDownload:download
+        isShelfClosing:NO];
+}
+
+- (void)removeDownload:(DownloadItemController*)download
+        isShelfClosing:(BOOL)isShelfClosing {
   // Look for the download in our controller array and remove it. This will
   // explicity release it so that it removes itself as an Observer of the
   // DownloadItem. We don't want to wait for autorelease since the DownloadItem
   // we are observing will likely be gone by then.
   [[NSNotificationCenter defaultCenter] removeObserver:download];
 
   // TODO(dmaclach): Remove -- http://crbug.com/25845
   [[download view] removeFromSuperview];
 
   [downloadItemControllers_ removeObject:download];
-  [self layoutItems];
 
-  // If there are no more downloads or if all the remaining downloads have been
-  // opened, we can close the shelf.
-  [self maybeAutoCloseAfterDelay];
+  if (!isShelfClosing) {
+    [self layoutItems];
+
+    // If there are no more downloads or if all the remaining downloads have
+    // been opened, we can close the shelf.
+    [self maybeAutoCloseAfterDelay];
+  }
 }
 
 - (void)downloadWasOpened:(DownloadItemController*)item_controller {
   // This should only be called on the main thead.
   DCHECK([NSThread isMainThread]);
   [self maybeAutoCloseAfterDelay];
 }
 
 // We need to explicitly release our download controllers here since they need
 // to remove themselves as observers before the remaining shutdown happens.
 - (void)exiting {
   [[self animatableView] stopAnimation];
-  [self cancelAutoCloseAndRemoveTrackingArea];
+  [self removeTrackingArea];
+  while ([downloadItemControllers_ count] > 0) {
+    [self removeDownload:[downloadItemControllers_ lastObject]
+          isShelfClosing:YES];
+  }
   downloadItemControllers_.reset();
 }
 
 - (void)showDownloadShelf:(BOOL)show
              isUserAction:(BOOL)isUserAction {
+  shouldCloseOnMouseExit_ = NO;
+
   if ([self isVisible] == show)
     return;
 
   if (!show) {
-    [self cancelAutoCloseAndRemoveTrackingArea];
     int numInProgress = 0;
     for (NSUInteger i = 0; i < [downloadItemControllers_ count]; ++i) {
       if ([[downloadItemControllers_ objectAtIndex:i]download]->IsInProgress())
         ++numInProgress;
     }
     download_util::RecordShelfClose(
         [downloadItemControllers_ count], numInProgress, !isUserAction);
   }
 
   // Animate the shelf out, but not in.
@@ skipping 42 matching lines @@
     skipFirst = NO;
   }
 }
 
 - (void)layoutItems {
   [self layoutItems:NO];
 }
 
 - (void)addDownloadItem:(DownloadItem*)downloadItem {
   DCHECK([NSThread isMainThread]);
-  [self cancelAutoCloseAndRemoveTrackingArea];
-
-  // Insert new item at the left.
   scoped_nsobject<DownloadItemController> controller(
       [[DownloadItemController alloc] initWithDownload:downloadItem
                                                  shelf:self
                                              navigator:navigator_]);
+  [self add:controller.get()];
+}
 
+- (void)add:(DownloadItemController*)controller {
+  DCHECK([NSThread isMainThread]);
+  shouldCloseOnMouseExit_ = NO;
+
+  // Insert new item at the left.
   // Adding at index 0 in NSMutableArrays is O(1).
-  [downloadItemControllers_ insertObject:controller.get() atIndex:0];
+  [downloadItemControllers_ insertObject:controller atIndex:0];
 
   [itemContainerView_ addSubview:[controller view]];
 
   // The controller is in charge of removing itself as an observer in its
   // dealloc.
   [[NSNotificationCenter defaultCenter]
     addObserver:controller
        selector:@selector(updateVisibility:)
            name:NSViewFrameDidChangeNotification
          object:[controller view]];
@@ skipping 17 matching lines @@
   [[[controller view] animator] setFrame:frame];
   [NSAnimationContext endGrouping];
 
   // Keep only a limited number of items in the shelf.
   if ([downloadItemControllers_ count] > kMaxDownloadItemCount) {
     DCHECK(kMaxDownloadItemCount > 0);
 
     // Since no user will ever see the item being removed (needs a horizontal
     // screen resolution greater than 3200 at 16 items at 200 pixels each),
     // there's no point in animating the removal.
-    [self remove:[downloadItemControllers_ lastObject]];
+    [self removeDownload:[downloadItemControllers_ lastObject]
+          isShelfClosing:NO];
   }
 
   // Finally, move the remaining items to the right. Skip the first item when
   // laying out the items, so that the longer animation duration we set up above
   // is not overwritten.
   [self layoutItems:YES];
 }
 
 - (void)closed {
   // Don't remove completed downloads if the shelf is just being auto-hidden
   // rather than explicitly closed by the user.
   if (bridge_->is_hidden())
     return;
   NSUInteger i = 0;
   while (i < [downloadItemControllers_ count]) {
     DownloadItemController* itemController =
         [downloadItemControllers_ objectAtIndex:i];
     DownloadItem* download = [itemController download];
     bool isTransferDone = download->IsComplete() ||
                           download->IsCancelled() ||
                           download->IsInterrupted();
     if (isTransferDone && !download->IsDangerous()) {
-      [self remove:itemController];
+      [self removeDownload:itemController
+            isShelfClosing:YES];
     } else {
       // Treat the item as opened when we close. This way if we get shown again
       // the user need not open this item for the shelf to auto-close.
       download->SetOpened(true);
       ++i;
     }
   }
 }
 
 - (void)mouseEntered:(NSEvent*)event {
+  isMouseInsideView_ = YES;
   // If the mouse re-enters the download shelf, cancel the auto-close.  Further
-  // mouse exits should not trigger autoclose, so also remove the tracking area.
-  [self cancelAutoCloseAndRemoveTrackingArea];
+  // mouse exits should not trigger autoclose.
+  if (shouldCloseOnMouseExit_) {
+    [self cancelAutoClose];
+    shouldCloseOnMouseExit_ = NO;
+  }
 }
 
 - (void)mouseExited:(NSEvent*)event {
+  isMouseInsideView_ = NO;
+  if (shouldCloseOnMouseExit_)
+    [self scheduleAutoClose];
+}
+
+- (void)scheduleAutoClose {
   // Cancel any previous hide requests, just to be safe.
-  [NSObject cancelPreviousPerformRequestsWithTarget:self
-                                           selector:@selector(autoClose)
-                                             object:nil];
+  [self cancelAutoClose];
 
   // Schedule an autoclose after a delay.  If the mouse is moved back into the
   // view, or if an item is added to the shelf, the timer will be canceled.
   [self performSelector:@selector(autoClose)
              withObject:nil
              afterDelay:kAutoCloseDelaySeconds];
 }
 
+- (void)cancelAutoClose {
+  [NSObject cancelPreviousPerformRequestsWithTarget:self
+                                           selector:@selector(autoClose)
+                                             object:nil];
+}
+
 - (void)maybeAutoCloseAfterDelay {
   // We can close the shelf automatically if all the downloads on the shelf have
   // been opened.
   for (NSUInteger i = 0; i < [downloadItemControllers_ count]; ++i) {
     DownloadItemController* itemController =
         [downloadItemControllers_ objectAtIndex:i];
     if (![itemController download]->GetOpened())
       return;
   }
 
-  if ([self isVisible] && [downloadItemControllers_ count] > 0) {
-    // If the shelf is visible and has download items remaining on it, close the
-    // shelf after the user moves the mouse out of the download shelf. Note that
-    // the mouse might not be over the shelf. In this case, the shelf will not
-    // auto close.
-    // TODO(asanka): Don't install a tracking area if the mouse isn't over the
-    // shelf. Autoclose instead.
-    [self installTrackingArea];
+  if ([self isVisible] && [downloadItemControllers_ count] > 0 &&
+      isMouseInsideView_) {
+    // If there are download items on the shelf and the user is potentially stil
+    // interacting with them, schedule an auto close after the user moves the
+    // mouse off the shelf.
+    shouldCloseOnMouseExit_ = YES;
   } else {
     // We notify the DownloadShelf of our intention to close even if the shelf
     // is currently hidden. If the shelf was temporarily hidden (e.g. because
     // the browser window entered fullscreen mode), then this prevents the shelf
     // from being shown again when the browser exits fullscreen mode.
     [self autoClose];
   }
 }
 
 - (void)autoClose {
   bridge_->Close(DownloadShelf::AUTOMATIC);
 }
 
 - (void)installTrackingArea {
-  // Install the tracking area to listen for mouseExited messages and trigger
-  // the shelf autoclose.
-  if (trackingArea_.get())
-    return;
+  // Install the tracking area to listen for mouseEntered and mouseExited
+  // messages.
+  DCHECK(!trackingArea_.get());
 
-  trackingArea_.reset([[NSTrackingArea alloc]
+  trackingArea_.reset([[CrTrackingArea alloc]
                         initWithRect:[[self view] bounds]
                              options:NSTrackingMouseEnteredAndExited |
                                      NSTrackingActiveAlways |
                                      NSTrackingInVisibleRect
                                owner:self
                             userInfo:nil]);
-  [[self view] addTrackingArea:trackingArea_];
+  [[self view] addTrackingArea:trackingArea_.get()];
 }
 
-- (void)cancelAutoCloseAndRemoveTrackingArea {
-  [NSObject cancelPreviousPerformRequestsWithTarget:self
-                                           selector:@selector(autoClose)
-                                             object:nil];
-
+- (void)removeTrackingArea {
   if (trackingArea_.get()) {
-    [[self view] removeTrackingArea:trackingArea_];
+    [[self view] removeTrackingArea:trackingArea_.get()];
     trackingArea_.reset(nil);
   }
 }
 
 - (void)willEnterFullscreen {
   isFullscreen_ = YES;
   [self updateCloseButton];
 }
 
 - (void)willLeaveFullscreen {
@@ skipping 21 matching lines @@
   }
 
   // Set the tracking off to create a new tracking area for the control.
   // When changing the bounds/frame on a HoverButton, the tracking isn't updated
   // correctly, it needs to be turned off and back on.
   [hoverCloseButton_ setTrackingEnabled:NO];
   [hoverCloseButton_ setFrame:bounds];
   [hoverCloseButton_ setTrackingEnabled:YES];
 }
 @end