aura: couple of tooltip UX changes:

ash/tooltips/tooltip_controller.cc

 // 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.
 
 #include "ash/tooltips/tooltip_controller.h"
 
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
@@ skipping 30 matching lines @@
 const int kTooltipMaxWidthPixels = 400;
 
 // Maximum number of lines we allow in the tooltip.
 const size_t kMaxLines = 10;
 
 // TODO(derat): This padding is needed on Chrome OS devices but seems excessive
 // when running the same binary on a Linux workstation; presumably there's a
 // difference in font metrics.  Rationalize this.
 const int kTooltipVerticalPadding = 2;
 const int kTooltipTimeoutMs = 500;
+const int kTooltipShownTimeoutMs = 10000;
 
 // FIXME: get cursor offset from actual cursor size.
 const int kCursorOffsetX = 10;
 const int kCursorOffsetY = 15;
 
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
 gfx::Font GetDefaultFont() {
   // TODO(varunjain): implementation duplicated in tooltip_manager_aura. Figure
@@ skipping 133 matching lines @@
 
 TooltipController::~TooltipController() {
   if (tooltip_window_)
     tooltip_window_->RemoveObserver(this);
 }
 
 void TooltipController::UpdateTooltip(aura::Window* target) {
   // If tooltip is visible, we may want to hide it. If it is not, we are ok.
   if (tooltip_window_ == target && tooltip_->IsVisible())
     UpdateIfRequired();
+
+  // If we had stopped the tooltip timer for some reason, we must restart it if
+  // there is a change in the tooltip.
+  if (!tooltip_timer_.IsRunning()) {
+    if (tooltip_window_ != target || (tooltip_window_ &&
+        tooltip_text_ != aura::client::GetTooltipText(tooltip_window_))) {
+      tooltip_timer_.Start(FROM_HERE,
+          base::TimeDelta::FromMilliseconds(kTooltipTimeoutMs),
+          this, &TooltipController::TooltipTimerFired);
+    }
+  }
 }
 
 void TooltipController::SetTooltipsEnabled(bool enable) {
   if (tooltips_enabled_ == enable)
     return;
   tooltips_enabled_ = enable;
   UpdateTooltip(tooltip_window_);
 }
 
 bool TooltipController::PreHandleKeyEvent(aura::Window* target,
                                           aura::KeyEvent* event) {
+  // On key press, we want to hide the tooltip and not show it until change.
+  // This is the same behavior as hiding tooltips on timeout. Hence, we can
+  // simply simulate a timeout.
+  if (tooltip_shown_timer_.IsRunning()) {
+    tooltip_shown_timer_.Stop();
+    TooltipShownTimerFired();
+  }
   return false;
 }
 
 bool TooltipController::PreHandleMouseEvent(aura::Window* target,
                                             aura::MouseEvent* event) {
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED:
       if (tooltip_window_ != target) {
         if (tooltip_window_)
@@ skipping 142 matching lines @@
       result.append(*l);
     }
   }
   *text = result;
 }
 
 void TooltipController::TooltipTimerFired() {
   UpdateIfRequired();
 }
 
+void TooltipController::TooltipShownTimerFired() {
+  tooltip_->Hide();
+
+  // Since the user presumably no longer needs the tooltip, we also stop the
+  // tooltip timer so that tooltip does not pop back up. We will restart this
+  // timer if the tooltip changes (see UpdateTooltip()).
+  tooltip_timer_.Stop();
+}
+
 void TooltipController::UpdateIfRequired() {
   if (!tooltips_enabled_ || mouse_pressed_ || IsDragDropInProgress() ||
       !aura::Env::GetInstance()->cursor_manager()->cursor_visible()) {
     tooltip_->Hide();
     return;
   }
 
   string16 tooltip_text;
   if (tooltip_window_)
     tooltip_text = aura::client::GetTooltipText(tooltip_window_);
 
   // If the user pressed a mouse button. We will hide the tooltip and not show
   // it until there is a change in the tooltip.
   if (tooltip_window_at_mouse_press_) {
     if (tooltip_window_ == tooltip_window_at_mouse_press_ &&
         tooltip_text == tooltip_text_at_mouse_press_) {
       tooltip_->Hide();
       return;
     }
     tooltip_window_at_mouse_press_ = NULL;
   }
 
   // We add the !tooltip_->IsVisible() below because when we come here from
   // TooltipTimerFired(), the tooltip_text may not have changed but we still
   // want to update the tooltip because the timer has fired.
   // If we come here from UpdateTooltip(), we have already checked for tooltip
   // visibility and this check below will have no effect.
   if (tooltip_text_ != tooltip_text || !tooltip_->IsVisible()) {
+    tooltip_shown_timer_.Stop();
     tooltip_text_ = tooltip_text;
     if (tooltip_text_.empty()) {
       tooltip_->Hide();
     } else {
       string16 tooltip_text(tooltip_text_);
       gfx::Point widget_loc = curr_mouse_loc_;
       widget_loc = widget_loc.Add(
           tooltip_window_->GetScreenBounds().origin());
       tooltip_->SetText(tooltip_text, widget_loc);
       tooltip_->Show();
+      tooltip_shown_timer_.Start(FROM_HERE,
+          base::TimeDelta::FromMilliseconds(kTooltipShownTimeoutMs),
+          this, &TooltipController::TooltipShownTimerFired);
     }
   }
 }
 
 bool TooltipController::IsTooltipVisible() {
   return tooltip_->IsVisible();
 }
 
 bool TooltipController::IsDragDropInProgress() {
   return drag_drop_client_->IsDragDropInProgress();
 }
 
 }  // namespace internal
 }  // namespace ash