The password bubble should fade out on click on the web page.

chrome/browser/ui/views/passwords/manage_passwords_bubble_view.cc

 // Copyright 2013 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/ui/views/passwords/manage_passwords_bubble_view.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/passwords/manage_passwords_bubble_model.h"
 #include "chrome/browser/ui/passwords/manage_passwords_ui_controller.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/browser/ui/views/passwords/manage_password_item_view.h"
 #include "chrome/browser/ui/views/passwords/manage_passwords_icon_view.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/password_manager/core/common/password_manager_ui.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/compositor/layer_animation_observer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/views/controls/button/blue_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/combobox/combobox.h"
 #include "ui/views/controls/styled_label.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/layout/layout_constants.h"
 
 
 // Helpers --------------------------------------------------------------------
 
 namespace {
 
-// The number of seconds the inactive bubble should stay alive.
-const int kBubbleCloseDelay = 15;
+// The number of seconds the bubble needs to fade out.
+const int kBubbleFadeDelay = 2;
 
 const int kDesiredBubbleWidth = 370;
 
 enum ColumnSetType {
   // | | (FILL, FILL) | |
   // Used for the bubble's header, the credentials list, and for simple
   // messages like "No passwords".
   SINGLE_VIEW_COLUMN_SET = 0,
 
   // | | (TRAILING, CENTER) | | (TRAILING, CENTER) | |
@@ skipping 476 matching lines @@
   }
 
   virtual ~WebContentMouseHandler() {
     aura::Window* window = GetWebContentsWindow();
     if (window)
       window->RemovePreTargetHandler(this);
   }
 
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (event->type() == ui::ET_MOUSE_PRESSED)
-      bubble_->OnWebContentClicked();
+      bubble_->StartFadingOut();
   }
 
  private:
   aura::Window* GetWebContentsWindow() {
     content::WebContents* web_contents = bubble_->model()->web_contents();
     return web_contents ? web_contents->GetNativeView() : NULL;
   }
 
   ManagePasswordsBubbleView* bubble_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentMouseHandler);
 };
 
+// ManagePasswordsBubbleView::FadeOutObserver ---------------------------------
+
+// The class notifies the bubble when it faded out completely.
+class ManagePasswordsBubbleView::FadeOutObserver
+    : public ui::ImplicitAnimationObserver {
+ public:
+  explicit FadeOutObserver(ManagePasswordsBubbleView* bubble)
+      : bubble_(bubble) {
+  }
+
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
+    bubble_->OnBubbleDisappeared();
+  }
+
+ private:
+  ManagePasswordsBubbleView* bubble_;
+
+  DISALLOW_COPY_AND_ASSIGN(FadeOutObserver);
+};
+
 // ManagePasswordsBubbleView --------------------------------------------------
 
 // static
 ManagePasswordsBubbleView* ManagePasswordsBubbleView::manage_passwords_bubble_ =
     NULL;
 
 // static
 void ManagePasswordsBubbleView::ShowBubble(content::WebContents* web_contents,
                                            DisplayReason reason) {
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
@@ skipping 22 matching lines @@
 
   // Adjust for fullscreen after creation as it relies on the content size.
   if (is_fullscreen) {
     manage_passwords_bubble_->AdjustForFullscreen(
         browser_view->GetBoundsInScreen());
   }
   if (reason == AUTOMATIC)
     manage_passwords_bubble_->GetWidget()->ShowInactive();
   else
     manage_passwords_bubble_->GetWidget()->Show();
-  manage_passwords_bubble_->StartTimerIfNecessary();
 }
 
 // static
 void ManagePasswordsBubbleView::CloseBubble() {
   if (manage_passwords_bubble_)
     manage_passwords_bubble_->Close();
 }
 
 // static
 void ManagePasswordsBubbleView::ActivateBubble() {
@@ skipping 41 matching lines @@
   // The bubble's padding from the screen edge, used in fullscreen.
   const int kFullscreenPaddingEnd = 20;
   const size_t bubble_half_width = width() / 2;
   const int x_pos = base::i18n::IsRTL() ?
       screen_bounds.x() + bubble_half_width + kFullscreenPaddingEnd :
       screen_bounds.right() - bubble_half_width - kFullscreenPaddingEnd;
   SetAnchorRect(gfx::Rect(x_pos, screen_bounds.y(), 0, 0));
 }
 
 void ManagePasswordsBubbleView::Close() {
+  fadeout_observer_.reset();
+  mouse_handler_.reset();
   GetWidget()->Close();
 }
 
 void ManagePasswordsBubbleView::Init() {
   views::FillLayout* layout = new views::FillLayout();
   SetLayoutManager(layout);
 
   Refresh();
 }
 
 void ManagePasswordsBubbleView::WindowClosing() {
   // Close() closes the window asynchronously, so by the time we reach here,
   // |manage_passwords_bubble_| may have already been reset.
   if (manage_passwords_bubble_ == this)
     manage_passwords_bubble_ = NULL;
 }
 
 void ManagePasswordsBubbleView::OnWidgetActivationChanged(views::Widget* widget,
                                                           bool active) {
   if (active && widget == GetWidget())
-    timer_.Stop();
+    CancelFadingOut();
   BubbleDelegateView::OnWidgetActivationChanged(widget, active);
 }
 
 views::View* ManagePasswordsBubbleView::GetInitiallyFocusedView() {
   return initially_focused_view_;
 }
 
 void ManagePasswordsBubbleView::OnMouseEntered(const ui::MouseEvent& event) {
-  timer_.Stop();
-}
-
-void ManagePasswordsBubbleView::OnMouseExited(const ui::MouseEvent& event) {
-  StartTimerIfNecessary();
+  CancelFadingOut();
 }
 
 void ManagePasswordsBubbleView::Refresh() {
   RemoveAllChildViews(true);
   initially_focused_view_ = NULL;
   if (password_manager::ui::IsPendingState(model()->state())) {
     if (never_save_passwords_)
       AddChildView(new ConfirmNeverView(this));
     else
       AddChildView(new PendingView(this));
   } else if (model()->state() == password_manager::ui::BLACKLIST_STATE) {
     AddChildView(new BlacklistedView(this));
   } else if (model()->state() == password_manager::ui::CONFIRMATION_STATE) {
     AddChildView(new SaveConfirmationView(this));
   } else {
     AddChildView(new ManageView(this));
   }
   GetLayoutManager()->Layout(this);
-  // If we refresh the existing bubble we may want to restart the timer.
-  if (GetWidget())
-    StartTimerIfNecessary();
+  CancelFadingOut();
 }
 
 void ManagePasswordsBubbleView::NotifyNeverForThisSiteClicked() {
   if (model()->best_matches().empty()) {
     // Skip confirmation if there are no existing passwords for this site.
     NotifyConfirmedNeverForThisSite();
   } else {
     never_save_passwords_ = true;
     Refresh();
   }
 }
 
 void ManagePasswordsBubbleView::NotifyConfirmedNeverForThisSite() {
   model()->OnNeverForThisSiteClicked();
   Close();
 }
 
 void ManagePasswordsBubbleView::NotifyUndoNeverForThisSite() {
   never_save_passwords_ = false;
   Refresh();
 }
 
-void ManagePasswordsBubbleView::StartTimerIfNecessary() {
-  // Active bubble will stay visible until it loses focus.
-  if (GetWidget()->IsActive())
+void ManagePasswordsBubbleView::StartFadingOut() {
+  if (fadeout_observer_)
     return;
-  timer_.Start(FROM_HERE,
-               base::TimeDelta::FromSeconds(kBubbleCloseDelay),
-               this,
-               &ManagePasswordsBubbleView::Close);
+  aura::Window* window = GetWidget()->GetNativeView();
+  ui::ScopedLayerAnimationSettings animator(window->layer()->GetAnimator());
+  fadeout_observer_.reset(new FadeOutObserver(this));
+  animator.AddObserver(fadeout_observer_.get());
+  animator.SetTransitionDuration(
+      base::TimeDelta::FromSeconds(kBubbleFadeDelay));
+  window->layer()->SetOpacity(0);
 }
 
-void ManagePasswordsBubbleView::OnWebContentClicked() {
+void ManagePasswordsBubbleView::CancelFadingOut() {
+  if (!fadeout_observer_)
+    return;
+  fadeout_observer_.reset();
+  aura::Window* window = GetWidget()->GetNativeView();
+  window->layer()->SetOpacity(1);
+}
+
+void ManagePasswordsBubbleView::OnBubbleDisappeared() {
   Close();
 }