Fix for faded Mac scrollbar hit test.

This CL fixes an issue where clicking on a faded out scrollbar on Mac
caused a gesture scroll. This is fixed by querying the opacity of the
PaintedScrollbarLayerImpl and returning a zero delta if the scrollbar
opacity is 0.

Bug: 1054155
Change-Id: I9ae3b8284b1843b99f15e70a66f7336d956aa810
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2068204
Commit-Queue: Rahul Arakeri <arakeri@microsoft.com>
Reviewed-by: David Bokan <bokan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#744864}

cc/input/scrollbar_controller.cc

@@ -78,7 +78,12 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown(
   if (!(layer_impl && layer_impl->ToScrollbarLayer()))
     return InputHandlerPointerResult();
 
+  // If the scrollbar layer has faded out (eg: Overlay scrollbars), don't
+  // initiate a scroll.
   const ScrollbarLayerImplBase* scrollbar = layer_impl->ToScrollbarLayer();
+  if (scrollbar->OverlayScrollbarOpacity() == 0.f)
+    return InputHandlerPointerResult();
+
   captured_scrollbar_metadata_ = CapturedScrollbarMetadata();
   captured_scrollbar_metadata_->scroll_element_id =
       scrollbar->scroll_element_id();

cc/layers/painted_scrollbar_layer_impl.cc

@@ -78,6 +78,13 @@ void PaintedScrollbarLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   scrollbar_layer->set_thumb_opacity(thumb_opacity_);
 }
 
+float PaintedScrollbarLayerImpl::OverlayScrollbarOpacity() const {
+  // This is relevant in case of Mac overlay scrollbars because they fade out by
+  // animating the opacity via Blink paint. This member will be renamed as a
+  // part of crbug.com/1055246.
+  return thumb_opacity_;
+}
+
 bool PaintedScrollbarLayerImpl::WillDraw(
     DrawMode draw_mode,
     viz::ClientResourceProvider* resource_provider) {

cc/layers/painted_scrollbar_layer_impl.h

@@ -52,7 +52,10 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase {
     thumb_ui_resource_id_ = uid;
   }
 
+  // TODO(arakeri): Rename set_thumb_opacity to set_scrollbar_painted_opacity as
+  // a part of crbug.com/1055246.
   void set_thumb_opacity(float opacity) { thumb_opacity_ = opacity; }
+  float OverlayScrollbarOpacity() const override;
 
   void set_internal_contents_scale_and_bounds(float content_scale,
                                               const gfx::Size& content_bounds) {

cc/layers/scrollbar_layer_impl_base.cc

@@ -284,6 +284,10 @@ bool ScrollbarLayerImplBase::HasFindInPageTickmarks() const {
   return false;
 }
 
+float ScrollbarLayerImplBase::OverlayScrollbarOpacity() const {
+  return Opacity();
+}
+
 bool ScrollbarLayerImplBase::SupportsDragSnapBack() const {
   return false;
 }

cc/layers/scrollbar_layer_impl_base.h

@@ -79,6 +79,12 @@ class CC_EXPORT ScrollbarLayerImplBase : public LayerImpl {
   // tickmarks's state.
   virtual bool HasFindInPageTickmarks() const;
 
+  // Mac overlay scrollbars are faded during paint but the compositor layer is
+  // always fully opaque where as Aura scrollbars fade by animating the layer
+  // opacity. This method will return the user visible opacity of an overlay
+  // scrollbar regardless of the underlying mechanism or platform.
+  virtual float OverlayScrollbarOpacity() const;
+
  protected:
   ScrollbarLayerImplBase(LayerTreeImpl* tree_impl,
                          int id,

cc/trees/layer_tree_host_impl_unittest.cc

@@ -34,6 +34,7 @@
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/painted_overlay_scrollbar_layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/solid_color_layer_impl.h"
@@ -12122,6 +12123,119 @@ TEST_F(LayerTreeHostImplTest, ScrollAnimatedWhileZoomed) {
   }
 }
 
+// This tests that faded-out Aura scrollbars can't be interacted with.
+TEST_F(LayerTreeHostImplTest, FadedOutPaintedOverlayScrollbarHitTest) {
+  LayerTreeSettings settings = DefaultSettings();
+  settings.compositor_threaded_scrollbar_scrolling = true;
+  CreateHostImpl(settings, CreateLayerTreeFrameSink());
+
+  // Setup the viewport.
+  const gfx::Size viewport_size = gfx::Size(360, 600);
+  const gfx::Size content_size = gfx::Size(345, 3800);
+  SetupViewportLayersOuterScrolls(viewport_size, content_size);
+  LayerImpl* scroll_layer = OuterViewportScrollLayer();
+
+  // Set up the scrollbar and its dimensions.
+  LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
+  auto* scrollbar = AddLayer<PaintedOverlayScrollbarLayerImpl>(layer_tree_impl,
+                                                               VERTICAL, false);
+  SetupScrollbarLayerCommon(scroll_layer, scrollbar);
+  scrollbar->SetHitTestable(true);
+
+  const gfx::Size scrollbar_size = gfx::Size(15, 600);
+  scrollbar->SetBounds(scrollbar_size);
+
+  // Set up the thumb dimensions.
+  scrollbar->SetThumbThickness(15);
+  scrollbar->SetThumbLength(50);
+  scrollbar->SetTrackStart(0);
+  scrollbar->SetTrackLength(575);
+  scrollbar->SetOffsetToTransformParent(gfx::Vector2dF(345, 0));
+
+  // Set up the scroll node and other state required for scrolling.
+  host_impl_->ScrollBegin(
+      BeginState(gfx::Point(350, 18), gfx::Vector2dF(), InputHandler::SCROLLBAR)
+          .get(),
+      InputHandler::SCROLLBAR);
+
+  TestInputHandlerClient input_handler_client;
+  host_impl_->BindToClient(&input_handler_client);
+
+  // PaintedOverlayScrollbarLayerImpl(s) don't have a track, so we test thumb
+  // drags instead. Start with 0.8 opacity. Scrolling is expected to occur in
+  // this case.
+  auto& scrollbar_effect_node = CreateEffectNode(scrollbar);
+  scrollbar_effect_node.opacity = 0.8;
+
+  host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false);
+  InputHandlerPointerResult result =
+      host_impl_->MouseMoveAt(gfx::Point(350, 28));
+  EXPECT_GT(result.scroll_offset.y(), 0u);
+  host_impl_->MouseUp(gfx::PointF(350, 28));
+
+  // Scrolling shouldn't occur at opacity = 0.
+  scrollbar_effect_node.opacity = 0;
+
+  host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false);
+  result = host_impl_->MouseMoveAt(gfx::Point(350, 28));
+  EXPECT_EQ(result.scroll_offset.y(), 0u);
+  host_impl_->MouseUp(gfx::PointF(350, 28));
+
+  // Tear down the LayerTreeHostImpl before the InputHandlerClient.
+  host_impl_->ReleaseLayerTreeFrameSink();
+  host_impl_ = nullptr;
+}
+
+// This tests that faded-out Mac scrollbars can't be interacted with.
+TEST_F(LayerTreeHostImplTest, FadedOutPaintedScrollbarHitTest) {
+  LayerTreeSettings settings = DefaultSettings();
+  settings.compositor_threaded_scrollbar_scrolling = true;
+  CreateHostImpl(settings, CreateLayerTreeFrameSink());
+
+  // Setup the viewport.
+  const gfx::Size viewport_size = gfx::Size(360, 600);
+  const gfx::Size content_size = gfx::Size(345, 3800);
+  SetupViewportLayersOuterScrolls(viewport_size, content_size);
+  LayerImpl* scroll_layer = OuterViewportScrollLayer();
+
+  // Set up the scrollbar and its dimensions.
+  LayerTreeImpl* layer_tree_impl = host_impl_->active_tree();
+  auto* scrollbar = AddLayer<PaintedScrollbarLayerImpl>(layer_tree_impl,
+                                                        VERTICAL, false, true);
+  SetupScrollbarLayerCommon(scroll_layer, scrollbar);
+  scrollbar->SetHitTestable(true);
+
+  const gfx::Size scrollbar_size = gfx::Size(15, 600);
+  scrollbar->SetBounds(scrollbar_size);
+
+  // Set up the thumb dimensions.
+  scrollbar->SetThumbThickness(15);
+  scrollbar->SetThumbLength(50);
+  scrollbar->SetTrackRect(gfx::Rect(0, 15, 15, 575));
+  scrollbar->SetOffsetToTransformParent(gfx::Vector2dF(345, 0));
+
+  TestInputHandlerClient input_handler_client;
+  host_impl_->BindToClient(&input_handler_client);
+
+  // MouseDown on the track of a scrollbar with opacity 0 should not produce a
+  // scroll.
+  scrollbar->set_thumb_opacity(0);
+  InputHandlerPointerResult result =
+      host_impl_->MouseDown(gfx::PointF(350, 100), /*shift_modifier*/ false);
+  EXPECT_EQ(result.scroll_offset.y(), 0u);
+
+  // MouseDown on the track of a scrollbar with opacity > 0 should produce a
+  // scroll.
+  scrollbar->set_thumb_opacity(1);
+  result =
+      host_impl_->MouseDown(gfx::PointF(350, 100), /*shift_modifier*/ false);
+  EXPECT_GT(result.scroll_offset.y(), 0u);
+
+  // Tear down the LayerTreeHostImpl before the InputHandlerClient.
+  host_impl_->ReleaseLayerTreeFrameSink();
+  host_impl_ = nullptr;
+}
+
 TEST_F(LayerTreeHostImplTest, SingleGSUForScrollbarThumbDragPerFrame) {
   LayerTreeSettings settings = DefaultSettings();
   settings.compositor_threaded_scrollbar_scrolling = true;