Makes the download shelf auto-close after the user opens all downloads

chrome/browser/views/download_shelf_view.cc

 // 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.
 
 #include "chrome/browser/views/download_shelf_view.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 38 matching lines @@
 
 // Border color.
 static const SkColor kBorderColor = SkColorSetRGB(214, 214, 214);
 
 // New download item animation speed in milliseconds.
 static const int kNewItemAnimationDurationMs = 800;
 
 // Shelf show/hide speed.
 static const int kShelfAnimationDurationMs = 120;
 
+// Amount of time to delay if the mouse leaves the shelf by way of entering
+// another window. This is much larger than the normal delay as openning a
+// download is most likely going to trigger a new window to appear over the
+// button. Delay the time so that the user has a chance to quickly close the
+// other app and return to chrome with the download shelf still open.
+static const int kNotifyOnExitTimeMS = 5000;
+
 namespace {
 
 // Sets size->width() to view's preferred width + size->width().s
 // Sets size->height() to the max of the view's preferred height and
 // size->height();
 void AdjustSize(views::View* view, gfx::Size* size) {
   gfx::Size view_preferred = view->GetPreferredSize();
   size->Enlarge(view_preferred.width(), 0);
   size->set_height(std::max(view_preferred.height(), size->height()));
 }
 
 int CenterPosition(int size, int target_size) {
   return std::max((target_size - size) / 2, kTopBottomPadding);
 }
 
 }  // namespace
 
 DownloadShelfView::DownloadShelfView(Browser* browser, BrowserView* parent)
     : browser_(browser),
-      parent_(parent) {
+      parent_(parent),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          mouse_watcher_(this, this, gfx::Insets())) {
+  mouse_watcher_.set_notify_on_exit_time_ms(kNotifyOnExitTimeMS);
   SetID(VIEW_ID_DOWNLOAD_SHELF);
   parent->AddChildView(this);
   Init();
 }
 
 DownloadShelfView::~DownloadShelfView() {
   parent_->RemoveChildView(this);
 }
 
 void DownloadShelfView::Init() {
@@ skipping 19 matching lines @@
 
   new_item_animation_.reset(new SlideAnimation(this));
   new_item_animation_->SetSlideDuration(kNewItemAnimationDurationMs);
 
   shelf_animation_.reset(new SlideAnimation(this));
   shelf_animation_->SetSlideDuration(kShelfAnimationDurationMs);
   Show();
 }
 
 void DownloadShelfView::AddDownloadView(DownloadItemView* view) {
+  mouse_watcher_.Stop();
+
   Show();
 
   DCHECK(view);
   download_views_.push_back(view);
   AddChildView(view);
   if (download_views_.size() > kMaxDownloadViews)
     RemoveDownloadView(*download_views_.begin());
 
   new_item_animation_->Reset();
   new_item_animation_->Show();
 }
 
 void DownloadShelfView::AddDownload(BaseDownloadItemModel* download_model) {
   DownloadItemView* view = new DownloadItemView(
       download_model->download(), this, download_model);
   AddDownloadView(view);
 }
 
+void DownloadShelfView::MouseMovedOutOfView() {
+  Close();
+}
+
 void DownloadShelfView::RemoveDownloadView(View* view) {
   DCHECK(view);
   std::vector<DownloadItemView*>::iterator i =
-    find(download_views_.begin(), download_views_.end(), view);
+      find(download_views_.begin(), download_views_.end(), view);
   DCHECK(i != download_views_.end());
   download_views_.erase(i);
   RemoveChildView(view);
   delete view;
   if (download_views_.empty())
     Close();
+  else if (CanAutoClose())
+    mouse_watcher_.Start();
   Layout();
   SchedulePaint();
 }
 
 void DownloadShelfView::Paint(gfx::Canvas* canvas) {
   PaintBackground(canvas);
   PaintBorder(canvas);
 }
 
 void DownloadShelfView::PaintBorder(gfx::Canvas* canvas) {
   canvas->FillRectInt(kBorderColor, 0, 0, width(), 1);
 }
 
+void DownloadShelfView::OpenedDownload(DownloadItemView* view) {
+  if (CanAutoClose())
+    mouse_watcher_.Start();
+}
+
 gfx::Size DownloadShelfView::GetPreferredSize() {
   gfx::Size prefsize(kRightPadding + kLeftPadding + kCloseAndLinkPadding, 0);
   AdjustSize(close_button_, &prefsize);
   AdjustSize(show_all_view_, &prefsize);
   // Add one download view to the preferred size.
   if (download_views_.size() > 0) {
     AdjustSize(*download_views_.begin(), &prefsize);
     prefsize.Enlarge(kDownloadPadding, 0);
   }
   prefsize.Enlarge(0, kTopBottomPadding + kTopBottomPadding);
@@ skipping 160 matching lines @@
 
 void DownloadShelfView::Close() {
   parent_->SetDownloadShelfVisible(false);
   shelf_animation_->Hide();
 }
 
 void DownloadShelfView::Closed() {
   // When the close animation is complete, remove all completed downloads.
   size_t i = 0;
   while (i < download_views_.size()) {
-    DownloadItem* download = download_views_[i]->get_download();
+    DownloadItem* download = download_views_[i]->download();
     bool is_transfer_done = download->state() == DownloadItem::COMPLETE ||
                             download->state() == DownloadItem::CANCELLED;
     if (is_transfer_done &&
         download->safety_state() != DownloadItem::DANGEROUS) {
       RemoveDownloadView(download_views_[i]);
     } 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->set_opened(true);
       ++i;
     }
   }
 }
+
+bool DownloadShelfView::CanAutoClose() {
+  for (size_t i = 0; i < download_views_.size(); ++i) {
+    if (!download_views_[i]->download()->opened())
+      return false;
+  }
+  return true;
+}