Remove infinite spin, make tooltip delay consistent

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 <stddef.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/views/corewm/tooltip.h"
 #include "ui/views/widget/tooltip_manager.h"
+#include "ui/wm/public/tooltip_client.h"
 
 namespace views {
 namespace corewm {
 namespace {
 
-const int kTooltipTimeoutMs = 500;
+const int kDelayForTooltipUpdateInMs = 500;
 const int kDefaultTooltipShownTimeoutMs = 10000;
 #if defined(OS_WIN)
 // Drawing a long word in tooltip is very slow on Windows. crbug.com/513693
 const size_t kMaxTooltipLength = 1024;
 #else
 const size_t kMaxTooltipLength = 2048;
 #endif
 
 // Returns true if |target| is a valid window to get the tooltip from.
 // |event_target| is the original target from the event and |target| the window
@@ skipping 78 matching lines @@
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TooltipController public:
 
 TooltipController::TooltipController(std::unique_ptr<Tooltip> tooltip)
     : tooltip_window_(NULL),
       tooltip_id_(NULL),
       tooltip_window_at_mouse_press_(NULL),
       tooltip_(std::move(tooltip)),
-      tooltips_enabled_(true) {
-  tooltip_timer_.Start(FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kTooltipTimeoutMs),
-      this, &TooltipController::TooltipTimerFired);
-}
+      tooltips_enabled_(true),
+      tooltip_show_delayed_(true) {}
 
 TooltipController::~TooltipController() {
   if (tooltip_window_)
     tooltip_window_->RemoveObserver(this);
 }
 
 int TooltipController::GetMaxWidth(const gfx::Point& location) const {
   return tooltip_->GetMaxWidth(location);
 }
 
 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();
 
   // Reset |tooltip_window_at_mouse_press_| if the moving within the same window
-  // but over a region that has different tooltip text. By resetting
-  // |tooltip_window_at_mouse_press_| we ensure the next time the timer fires
-  // we'll requery for the tooltip text.
+  // but over a region that has different tooltip text.
   // This handles the case of clicking on a view, moving within the same window
   // but over a different view, than back to the original.
   if (tooltip_window_at_mouse_press_ &&
       target == tooltip_window_at_mouse_press_ &&
       aura::client::GetTooltipText(target) != tooltip_text_at_mouse_press_) {
     tooltip_window_at_mouse_press_ = NULL;
   }
-
-  // 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::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;
@@ skipping 20 matching lines @@
       curr_mouse_loc_ = event->location();
       aura::Window* target = NULL;
       // Avoid a call to display::Screen::GetWindowAtScreenPoint() since it can
       // be very expensive on X11 in cases when the tooltip is hidden anyway.
       if (tooltips_enabled_ &&
           !aura::Env::GetInstance()->IsMouseButtonDown() &&
           !IsDragDropInProgress()) {
         target = GetTooltipTarget(*event, &curr_mouse_loc_);
       }
       SetTooltipWindow(target);
-      if (tooltip_timer_.IsRunning())
-        tooltip_timer_.Reset();
 
-      if (tooltip_->IsVisible())
+      if (tooltip_->IsVisible() ||
+          (tooltip_window_ &&
+           tooltip_text_ != aura::client::GetTooltipText(tooltip_window_)))
         UpdateIfRequired();
       break;
     }
     case ui::ET_MOUSE_PRESSED:
       if ((event->flags() & ui::EF_IS_NON_CLIENT) == 0) {
         aura::Window* target = static_cast<aura::Window*>(event->target());
         // We don't get a release for non-client areas.
         tooltip_window_at_mouse_press_ = target;
         if (target)
           tooltip_text_at_mouse_press_ = aura::client::GetTooltipText(target);
       }
       tooltip_->Hide();
       break;
     case ui::ET_MOUSEWHEEL:
       // Hide the tooltip for click, release, drag, wheel events.
       if (tooltip_->IsVisible())
         tooltip_->Hide();
-
-      // Don't reshow the tooltip during scroll.
-      if (tooltip_timer_.IsRunning())
-        tooltip_timer_.Reset();
       break;
     default:
       break;
   }
 }
 
 void TooltipController::OnTouchEvent(ui::TouchEvent* event) {
   // TODO(varunjain): need to properly implement tooltips for
   // touch events.
   // Hide the tooltip for touch events.
   tooltip_->Hide();
   SetTooltipWindow(NULL);
 }
 
 void TooltipController::OnCancelMode(ui::CancelModeEvent* event) {
   tooltip_->Hide();
   SetTooltipWindow(NULL);
 }
 
+void TooltipController::OnCursorVisibilityChanged(bool is_visible) {
+  UpdateIfRequired();
+}
+
 void TooltipController::OnWindowDestroyed(aura::Window* window) {
   if (tooltip_window_ == window) {
     tooltip_->Hide();
     tooltip_shown_timeout_map_.erase(tooltip_window_);
     tooltip_window_ = NULL;
   }
 }
 
+void TooltipController::OnWindowPropertyChanged(aura::Window* window,
+                                                const void* key,
+                                                intptr_t old) {
+  if ((key == aura::client::kTooltipIdKey ||
+       key == aura::client::kTooltipTextKey) &&
+      aura::client::GetTooltipText(window) != base::string16() &&
+      (tooltip_text_ != aura::client::GetTooltipText(window) ||
+       tooltip_id_ != aura::client::GetTooltipId(window)))
+    UpdateIfRequired();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TooltipController private:
 
-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_ ||
-      aura::Env::GetInstance()->IsMouseButtonDown() ||
+  if (!tooltips_enabled_ || aura::Env::GetInstance()->IsMouseButtonDown() ||
       IsDragDropInProgress() || !IsCursorVisible()) {
     tooltip_->Hide();
     return;
   }
 
   base::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;
   }
 
   // If the uniqueness indicator is different from the previously encountered
   // one, we should force tooltip update
   const void* tooltip_id = aura::client::GetTooltipId(tooltip_window_);
   bool ids_differ = false;
   ids_differ = tooltip_id_ != tooltip_id;
   tooltip_id_ = tooltip_id;
 
-  // 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() || ids_differ) {
     tooltip_shown_timer_.Stop();
     tooltip_text_ = tooltip_text;
     base::string16 trimmed_text =
         gfx::TruncateString(tooltip_text_, kMaxTooltipLength, gfx::WORD_BREAK);
     // If the string consists entirely of whitespace, then don't both showing it
     // (an empty tooltip is useless).
-    base::string16 whitespace_removed_text;
     base::TrimWhitespace(trimmed_text, base::TRIM_ALL,
-                         &whitespace_removed_text);
-    if (whitespace_removed_text.empty()) {
+                         &tooltip_text_whitespace_trimmed_);
+    if (tooltip_text_whitespace_trimmed_.empty()) {
       tooltip_->Hide();
+    } else if (tooltip_show_delayed_) {
+      // Initialize the one-shot timer to show the tooltip in a while.
+      // If there is already a request queued then cancel it and post the new
+      // request. This ensures that tooltip won't show up too early.
+      // The delayed appearance of a tooltip is by default.
+      if (tooltip_defer_timer_.IsRunning()) {
+        tooltip_defer_timer_.Reset();
+      } else {
+        tooltip_defer_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
+                                                  kDelayForTooltipUpdateInMs),
+                                   this, &TooltipController::ShowTooltip);
+      }
     } else {
-      gfx::Point widget_loc = curr_mouse_loc_ +
-          tooltip_window_->GetBoundsInScreen().OffsetFromOrigin();
-      tooltip_->SetText(tooltip_window_, whitespace_removed_text, widget_loc);
-      tooltip_->Show();
-      int timeout = GetTooltipShownTimeout();
-      if (timeout > 0) {
-        tooltip_shown_timer_.Start(FROM_HERE,
-            base::TimeDelta::FromMilliseconds(timeout),
-            this, &TooltipController::TooltipShownTimerFired);
-      }
+      ShowTooltip();  // Allow tooltip to show up without delay for unit tests.
     }
   }
 }
 
+void TooltipController::ShowTooltip() {
+  if (!tooltip_window_)
+    return;
+  gfx::Point widget_loc =
+      curr_mouse_loc_ + tooltip_window_->GetBoundsInScreen().OffsetFromOrigin();
+  tooltip_->SetText(tooltip_window_, tooltip_text_whitespace_trimmed_,
+                    widget_loc);
+  tooltip_->Show();
+  int timeout = GetTooltipShownTimeout();
+  if (timeout > 0) {
+    tooltip_shown_timer_.Start(FROM_HERE,
+                               base::TimeDelta::FromMilliseconds(timeout), this,
+                               &TooltipController::TooltipShownTimerFired);
+  }
+}
+
 bool TooltipController::IsTooltipVisible() {
   return tooltip_->IsVisible();
 }
 
 bool TooltipController::IsDragDropInProgress() {
   if (!tooltip_window_)
     return false;
   aura::client::DragDropClient* client =
       aura::client::GetDragDropClient(tooltip_window_->GetRootWindow());
   return client && client->IsDragDropInProgress();
@@ skipping 24 matching lines @@
     return;
   if (tooltip_window_)
     tooltip_window_->RemoveObserver(this);
   tooltip_window_ = target;
   if (tooltip_window_)
     tooltip_window_->AddObserver(this);
 }
 
 }  // namespace corewm
 }  // namespace views