ash: Add functionality to specify how long a tooltip is shown for a window.

ui/views/corewm/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 "ui/views/corewm/tooltip_controller.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/location.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;
+const int kDefaultTooltipShownTimeoutMs = 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 161 matching lines @@
   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::SetTooltipShownTimeout(aura::Window* target,
+                                               int timeout_in_ms) {
+  tooltip_shown_timeout_map_[target] = timeout_in_ms;
+}
+
 void TooltipController::SetTooltipsEnabled(bool enable) {
   if (tooltips_enabled_ == enable)
     return;
   tooltips_enabled_ = enable;
   UpdateTooltip(tooltip_window_);
 }
 
 void TooltipController::OnKeyEvent(ui::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
@@ skipping 59 matching lines @@
   tooltip_window_ = NULL;
 }
 
 void TooltipController::OnCancelMode(ui::CancelModeEvent* event) {
   if (tooltip_.get() && tooltip_->IsVisible())
     tooltip_->Hide();
 }
 
 void TooltipController::OnWindowDestroyed(aura::Window* window) {
   if (tooltip_window_ == window) {
+    tooltip_shown_timeout_map_.erase(tooltip_window_);
     tooltip_window_->RemoveObserver(this);
     tooltip_window_ = NULL;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TooltipController private:
 
 int TooltipController::GetMaxWidth(const gfx::Point& location) const {
   // TODO(varunjain): implementation duplicated in tooltip_manager_aura. Figure
@@ skipping 148 matching lines @@
     } else {
       gfx::Point widget_loc = curr_mouse_loc_ +
           tooltip_window_->GetBoundsInScreen().OffsetFromOrigin();
       gfx::Rect bounds(GetBoundsForTooltip(widget_loc));
       if (bounds.IsEmpty()) {
         tooltip_text_.clear();
         GetTooltip()->Hide();
       } else {
         GetTooltip()->SetText(tooltip_window_, tooltip_text_, widget_loc);
         GetTooltip()->Show();
-        tooltip_shown_timer_.Start(FROM_HERE,
-              base::TimeDelta::FromMilliseconds(kTooltipShownTimeoutMs),
-              this, &TooltipController::TooltipShownTimerFired);
+        int timeout = GetTooltipShownTimeout();
+        if (timeout > 0) {
+          tooltip_shown_timer_.Start(FROM_HERE,
+                base::TimeDelta::FromMilliseconds(timeout),
+                this, &TooltipController::TooltipShownTimerFired);
+        }
       }
     }
   }
 }
 
 bool TooltipController::IsTooltipVisible() {
   return GetTooltip()->IsVisible();
 }
 
 bool TooltipController::IsDragDropInProgress() {
@@ skipping 15 matching lines @@
     return false;
   aura::RootWindow* root = tooltip_window_->GetRootWindow();
   if (!root)
     return false;
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root);
   // |cursor_client| may be NULL in tests, treat NULL as always visible.
   return !cursor_client || cursor_client->IsCursorVisible();
 }
 
+int TooltipController::GetTooltipShownTimeout() {
+  std::map<aura::Window*, int>::const_iterator it =
+      tooltip_shown_timeout_map_.find(tooltip_window_);
+  if (it == tooltip_shown_timeout_map_.end())
+    return kDefaultTooltipShownTimeoutMs;
+  return it->second;
+}
+
 }  // namespace corewm
 }  // namespace views