cancel overlay-scrollbar hover state when moving pointer out of window for ChromeOS

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 191 matching lines @@
       content_is_suitable_for_gpu_rasterization_(true),
       has_gpu_rasterization_trigger_(false),
       use_gpu_rasterization_(false),
       use_msaa_(false),
       gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(Layer::INVALID_ID),
+      scroll_layer_id_when_mouse_near_scrollbar_(Layer::INVALID_ID),
       captured_scrollbar_layer_id_(Layer::INVALID_ID),
       tile_priorities_dirty_(false),
       settings_(settings),
       visible_(false),
       cached_managed_memory_policy_(settings.gpu_memory_policy),
       is_synchronous_single_threaded_(!task_runner_provider->HasImplThread() &&
                                       !settings.single_thread_proxy_scheduler),
       // Must be initialized after is_synchronous_single_threaded_ and
       // task_runner_provider_.
       tile_manager_(this,
@@ skipping 3003 matching lines @@
     return;
 
   ScrollbarAnimationController* animation_controller =
       ScrollbarAnimationControllerForId(captured_scrollbar_layer_id_);
   if (animation_controller)
     animation_controller->DidCaptureScrollbarEnd();
   captured_scrollbar_layer_id_ = Layer::INVALID_ID;
 }
 
 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
+  scroll_layer_id_when_mouse_near_scrollbar_ = Layer::INVALID_ID;
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
   HandleMouseOverScrollbar(layer_impl);
   if (scroll_layer_id_when_mouse_over_scrollbar_ != Layer::INVALID_ID)
     return;
 
   bool scroll_on_main_thread = false;
   uint32_t main_thread_scrolling_reasons;
   LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, InputHandler::TOUCHSCREEN, layer_impl,
       &scroll_on_main_thread, &main_thread_scrolling_reasons);
   if (scroll_layer_impl == InnerViewportScrollLayer())
     scroll_layer_impl = OuterViewportScrollLayer();
   if (scroll_on_main_thread || !scroll_layer_impl)
     return;
 
   ScrollbarAnimationController* animation_controller =
       ScrollbarAnimationControllerForId(scroll_layer_impl->id());
   if (!animation_controller)
     return;
 
+  scroll_layer_id_when_mouse_near_scrollbar_ = scroll_layer_impl->id();
+
   float distance_to_scrollbar = std::numeric_limits<float>::max();
   for (ScrollbarLayerImplBase* scrollbar :
        ScrollbarsFor(scroll_layer_impl->id()))
     distance_to_scrollbar =
         std::min(distance_to_scrollbar,
                  DeviceSpaceDistanceToLayer(device_viewport_point, scrollbar));
 
   animation_controller->DidMouseMoveNear(distance_to_scrollbar /
                                          active_tree_->device_scale_factor());
 }
 
+void LayerTreeHostImpl::MouseLeave() {
+  // scroll_layer_id_when_mouse_near_scrollbar_ and
+  // scroll_layer_id_when_mouse_over_scrollbar_ should not be both true
+  DCHECK(!(scroll_layer_id_when_mouse_near_scrollbar_ != Layer::INVALID_ID &&

[bokan, 2016/10/05 14:00:09]

This is more clearly expressed as:

mouse_near_scrollbar == INVALID_ID || mouse_over_scrollbar == INVALID_ID

+           scroll_layer_id_when_mouse_over_scrollbar_ != Layer::INVALID_ID));
+
+  int scroll_layer_id =
+      scroll_layer_id_when_mouse_near_scrollbar_ != Layer::INVALID_ID
+          ? scroll_layer_id_when_mouse_near_scrollbar_
+          : scroll_layer_id_when_mouse_over_scrollbar_;
+
+  ScrollbarAnimationController* animation_controller =
+      ScrollbarAnimationControllerForId(scroll_layer_id);
+
+  if (animation_controller)
+    animation_controller->DidMouseLeave();
+}
+
 void LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl) {
   int new_id = Layer::INVALID_ID;
   if (layer_impl && layer_impl->ToScrollbarLayer())
     new_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
 
   if (new_id == scroll_layer_id_when_mouse_over_scrollbar_)
     return;
 
   ScrollbarAnimationController* old_animation_controller =
       ScrollbarAnimationControllerForId(
@@ skipping 886 matching lines @@
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc