Skip overlay painting during scroll

This CL adds page-level scroll events to be sent to the inspector
overlay agent so that the agent can disable persistent overlays
during scrolling. Since the scrolling happens in the compositor and
the overlay is painted on the main thread, there is a visible lag
in the overlay rendering during scroll. This CL is a workaround for
this issue.

Video: https://i.imgur.com/krVFVPG.mp4

Bug: 1147362
Change-Id: Ifd9f735c0fe15a745f49f1fb440889e78e4a599e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2562846
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: David Bokan <bokan@chromium.org>
Reviewed-by: Mathias Bynens <mathias@chromium.org>
Commit-Queue: Alex Rudenko <alexrudenko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#834159}

cc/input/threaded_input_handler.cc

@@ -951,11 +951,14 @@ void ThreadedInputHandler::ProcessCommitDeltas(
     commit_data->manipulation_info |= kManipulationInfoPrecisionTouchPad;
   if (has_pinch_zoomed_)
     commit_data->manipulation_info |= kManipulationInfoPinchZoom;
+  if (has_scrolled_by_scrollbar_)
+    commit_data->manipulation_info |= kManipulationInfoScrollbar;
 
   has_scrolled_by_wheel_ = false;
   has_scrolled_by_touch_ = false;
   has_scrolled_by_precisiontouchpad_ = false;
   has_pinch_zoomed_ = false;
+  has_scrolled_by_scrollbar_ = false;
 
   commit_data->scroll_gesture_did_end = scroll_gesture_did_end_;
   scroll_gesture_did_end_ = false;
@@ -2093,6 +2096,8 @@ void ThreadedInputHandler::UpdateScrollSourceInfo(
     has_scrolled_by_wheel_ = true;
   } else if (type == ui::ScrollInputType::kTouchscreen) {
     has_scrolled_by_touch_ = true;
+  } else if (type == ui::ScrollInputType::kScrollbar) {
+    has_scrolled_by_scrollbar_ = true;
   }
 }
 

cc/input/threaded_input_handler.h

@@ -434,6 +434,7 @@ class CC_EXPORT ThreadedInputHandler : public InputHandler,
   bool has_scrolled_by_wheel_ = false;
   bool has_scrolled_by_touch_ = false;
   bool has_scrolled_by_precisiontouchpad_ = false;
+  bool has_scrolled_by_scrollbar_ = false;
 
   // Must be the last member to ensure this is destroyed first in the
   // destruction order and invalidates all weak pointers.

cc/test/layer_tree_test.cc

@@ -435,14 +435,8 @@ class LayerTreeHostClientForTesting : public LayerTreeHostClient,
       base::TimeDelta first_scroll_delay,
       base::TimeTicks first_scroll_timestamp) override {}
 
-  void RecordManipulationTypeCounts(ManipulationInfo info) override {}
-
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      ElementId scroll_latched_element_id) override {}
-
-  void SendScrollEndEventFromImplSide(
-      ElementId scroll_latched_element_id) override {}
+  void UpdateCompositorScrollState(
+      const CompositorCommitData& commit_data) override {}
 
   void RequestNewLayerTreeFrameSink() override {
     test_hooks_->RequestNewLayerTreeFrameSink();

cc/test/stub_layer_tree_host_client.h

@@ -34,12 +34,8 @@ class StubLayerTreeHostClient : public LayerTreeHostClient {
   void BeginMainFrameNotExpectedUntil(base::TimeTicks time) override {}
   void UpdateLayerTreeHost() override {}
   void ApplyViewportChanges(const ApplyViewportChangesArgs&) override {}
-  void RecordManipulationTypeCounts(ManipulationInfo info) override {}
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      ElementId scroll_latched_element_id) override {}
-  void SendScrollEndEventFromImplSide(
-      ElementId scroll_latched_element_id) override {}
+  void UpdateCompositorScrollState(
+      const CompositorCommitData& commit_data) override {}
   void RequestNewLayerTreeFrameSink() override {}
   void DidInitializeLayerTreeFrameSink() override {}
   void DidFailToInitializeLayerTreeFrameSink() override {}

cc/trees/layer_tree_host.cc

@@ -918,29 +918,6 @@ void LayerTreeHost::ApplyViewportChanges(
   SetNeedsUpdateLayers();
 }
 
-void LayerTreeHost::RecordManipulationTypeCounts(
-    const CompositorCommitData& commit_data) {
-  client_->RecordManipulationTypeCounts(commit_data.manipulation_info);
-}
-
-void LayerTreeHost::SendOverscrollAndScrollEndEventsFromImplSide(
-    const CompositorCommitData& commit_data) {
-  if (commit_data.scroll_latched_element_id == ElementId())
-    return;
-
-  if (!commit_data.overscroll_delta.IsZero()) {
-    client_->SendOverscrollEventFromImplSide(
-        commit_data.overscroll_delta, commit_data.scroll_latched_element_id);
-  }
-  // TODO(bokan): If a scroll ended and a new one began in the same Blink frame
-  // (e.g. during a long running main thread task), this will erroneously
-  // dispatch the scroll end to the latter (still-scrolling) element.
-  // https://crbug.com/1116780.
-  if (commit_data.scroll_gesture_did_end)
-    client_->SendScrollEndEventFromImplSide(
-        commit_data.scroll_latched_element_id);
-}
-
 void LayerTreeHost::UpdateScrollOffsetFromImpl(
     const ElementId& id,
     const gfx::ScrollOffset& delta,
@@ -1016,14 +993,12 @@ void LayerTreeHost::ApplyCompositorChanges(CompositorCommitData* commit_data) {
     }
   }
 
-  SendOverscrollAndScrollEndEventsFromImplSide(*commit_data);
+  client_->UpdateCompositorScrollState(*commit_data);
 
   // This needs to happen after scroll deltas have been sent to prevent top
   // controls from clamping the layout viewport both on the compositor and
   // on the main thread.
   ApplyViewportChanges(*commit_data);
-
-  RecordManipulationTypeCounts(*commit_data);
 }
 
 void LayerTreeHost::ApplyMutatorEvents(std::unique_ptr<MutatorEvents> events) {

cc/trees/layer_tree_host.h

@@ -778,9 +778,6 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient {
   enum { kNumFramesToConsiderBeforeRemovingSlowPathFlag = 60 };
 
   void ApplyViewportChanges(const CompositorCommitData& commit_data);
-  void RecordManipulationTypeCounts(const CompositorCommitData& commit_data);
-  void SendOverscrollAndScrollEndEventsFromImplSide(
-      const CompositorCommitData& commit_data);
   void ApplyPageScaleDeltaFromImplSide(float page_scale_delta);
   void InitializeProxy(std::unique_ptr<Proxy> proxy);
 

cc/trees/layer_tree_host_client.h

@@ -11,6 +11,7 @@
 #include "base/time/time.h"
 #include "cc/input/browser_controls_state.h"
 #include "cc/metrics/frame_sequence_tracker_collection.h"
+#include "cc/trees/property_tree.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
@@ -24,7 +25,6 @@ struct BeginFrameArgs;
 
 namespace cc {
 struct BeginMainFrameMetrics;
-struct ElementId;
 struct WebVitalMetrics;
 
 struct ApplyViewportChangesArgs {
@@ -66,6 +66,7 @@ constexpr ManipulationInfo kManipulationInfoWheel = 1 << 0;
 constexpr ManipulationInfo kManipulationInfoTouch = 1 << 1;
 constexpr ManipulationInfo kManipulationInfoPrecisionTouchPad = 1 << 2;
 constexpr ManipulationInfo kManipulationInfoPinchZoom = 1 << 3;
+constexpr ManipulationInfo kManipulationInfoScrollbar = 1 << 4;
 
 struct PaintBenchmarkResult {
   double record_time_ms = 0;
@@ -137,17 +138,10 @@ class LayerTreeHostClient {
   // related to pinch-zoom, browser controls (aka URL bar), overscroll, etc.
   virtual void ApplyViewportChanges(const ApplyViewportChangesArgs& args) = 0;
 
-  // Record use counts of different methods of scrolling (e.g. wheel, touch,
-  // precision touchpad, etc.).
-  virtual void RecordManipulationTypeCounts(ManipulationInfo info) = 0;
-
-  // Notifies the client when an overscroll has happened.
-  virtual void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      ElementId scroll_latched_element_id) = 0;
-  // Notifies the client when a gesture scroll has ended.
-  virtual void SendScrollEndEventFromImplSide(
-      ElementId scroll_latched_element_id) = 0;
+  // Notifies the client about scroll and input related changes that occurred in
+  // the LayerTreeHost since the last commit.
+  virtual void UpdateCompositorScrollState(
+      const CompositorCommitData& commit_data) = 0;
 
   // Request a LayerTreeFrameSink from the client. When the client has one it
   // should call LayerTreeHost::SetLayerTreeFrameSink. This will result in

content/browser/renderer_host/compositor_impl_android.h

@@ -121,12 +121,8 @@ class CONTENT_EXPORT CompositorImpl
   void UpdateLayerTreeHost() override;
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override {
   }
-  void RecordManipulationTypeCounts(cc::ManipulationInfo args) override {}
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) override {}
-  void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) override {}
+  void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) override {}
   void RequestNewLayerTreeFrameSink() override;
   void DidInitializeLayerTreeFrameSink() override;
   void DidFailToInitializeLayerTreeFrameSink() override;

third_party/blink/renderer/core/exported/web_dev_tools_agent_impl.cc

@@ -480,6 +480,16 @@ void WebDevToolsAgentImpl::DispatchBufferedTouchEvents() {
     it.value->DispatchBufferedTouchEvents();
 }
 
+void WebDevToolsAgentImpl::PageScrollStarted() {
+  for (auto& it : overlay_agents_)
+    it.value->PageScrollStarted();
+}
+
+void WebDevToolsAgentImpl::PageScrollEnded() {
+  for (auto& it : overlay_agents_)
+    it.value->PageScrollEnded();
+}
+
 WebInputEventResult WebDevToolsAgentImpl::HandleInputEvent(
     const WebInputEvent& event) {
   for (auto& it : overlay_agents_) {

third_party/blink/renderer/core/exported/web_dev_tools_agent_impl.h

@@ -81,6 +81,8 @@ class CORE_EXPORT WebDevToolsAgentImpl final
 
   WebInputEventResult HandleInputEvent(const WebInputEvent&);
   void DispatchBufferedTouchEvents();
+  void PageScrollStarted();
+  void PageScrollEnded();
   void BindReceiver(
       mojo::PendingAssociatedRemote<mojom::blink::DevToolsAgentHost>,
       mojo::PendingAssociatedReceiver<mojom::blink::DevToolsAgent>);

third_party/blink/renderer/core/frame/DEPS

@@ -35,6 +35,7 @@ specific_include_rules = {
   ],
   "web_frame_widget_impl\.cc": [
     "+cc/trees/swap_promise.h",
+    "+cc/trees/compositor_commit_data.h",
   ],
   "web_frame_widget_impl\.h": [
     "+services/viz/public/mojom/hit_test/input_target_client.mojom-blink.h",

third_party/blink/renderer/core/frame/web_frame_widget_impl.cc

@@ -39,6 +39,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "cc/trees/compositor_commit_data.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/swap_promise.h"
 #include "cc/trees/ukm_manager.h"
@@ -1210,6 +1211,9 @@ void WebFrameWidgetImpl::SendOverscrollEventFromImplSide(
 
 void WebFrameWidgetImpl::SendScrollEndEventFromImplSide(
     cc::ElementId scroll_latched_element_id) {
+  if (WebDevToolsAgentImpl* devtools = LocalRootImpl()->DevToolsAgentImpl())
+    devtools->PageScrollEnded();
+
   if (!RuntimeEnabledFeatures::OverscrollCustomizationEnabled())
     return;
 
@@ -1219,6 +1223,31 @@ void WebFrameWidgetImpl::SendScrollEndEventFromImplSide(
     target_node->GetDocument().EnqueueScrollEndEventForNode(target_node);
 }
 
+void WebFrameWidgetImpl::UpdateCompositorScrollState(
+    const cc::CompositorCommitData& commit_data) {
+  if (commit_data.manipulation_info != cc::kManipulationInfoNone) {
+    if (WebDevToolsAgentImpl* devtools = LocalRootImpl()->DevToolsAgentImpl())
+      devtools->PageScrollStarted();
+  }
+
+  RecordManipulationTypeCounts(commit_data.manipulation_info);
+
+  if (commit_data.scroll_latched_element_id == cc::ElementId())
+    return;
+
+  if (!commit_data.overscroll_delta.IsZero()) {
+    SendOverscrollEventFromImplSide(commit_data.overscroll_delta,
+                                    commit_data.scroll_latched_element_id);
+  }
+
+  // TODO(bokan): If a scroll ended and a new one began in the same Blink frame
+  // (e.g. during a long running main thread task), this will erroneously
+  // dispatch the scroll end to the latter (still-scrolling) element.
+  // https://crbug.com/1116780.
+  if (commit_data.scroll_gesture_did_end)
+    SendScrollEndEventFromImplSide(commit_data.scroll_latched_element_id);
+}
+
 WebInputMethodController*
 WebFrameWidgetImpl::GetActiveWebInputMethodController() const {
   WebLocalFrameImpl* local_frame =
@@ -2117,6 +2146,7 @@ void WebFrameWidgetImpl::RecordManipulationTypeCounts(
   // Manipulation counts are only recorded for the main frame.
   if (!ForMainFrame())
     return;
+
   if ((info & cc::kManipulationInfoWheel) == cc::kManipulationInfoWheel) {
     UseCounter::Count(LocalRootImpl()->GetDocument(),
                       WebFeature::kScrollByWheel);

third_party/blink/renderer/core/frame/web_frame_widget_impl.h

@@ -278,11 +278,8 @@ class CORE_EXPORT WebFrameWidgetImpl
 
   // WebFrameWidget overrides.
   WebLocalFrame* LocalRoot() const override;
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) override;
-  void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) override;
+  void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) override;
   WebInputMethodController* GetActiveWebInputMethodController() const override;
   WebLocalFrameImpl* FocusedWebLocalFrameInWidget() const override;
   bool ScrollFocusedEditableElementIntoView() override;
@@ -584,7 +581,6 @@ class CORE_EXPORT WebFrameWidgetImpl
   void BeginCommitCompositorFrame() override;
   void EndCommitCompositorFrame(base::TimeTicks commit_start_time) override;
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override;
-  void RecordManipulationTypeCounts(cc::ManipulationInfo info) override;
   void RecordDispatchRafAlignedInputTime(
       base::TimeTicks raf_aligned_input_start_time) override;
   void SetSuppressFrameRequestsWorkaroundFor704763Only(bool) override;
@@ -746,6 +742,12 @@ class CORE_EXPORT WebFrameWidgetImpl
 
   void SetWindowRectSynchronously(const gfx::Rect& new_window_rect);
 
+  void SendOverscrollEventFromImplSide(const gfx::Vector2dF& overscroll_delta,
+                                       cc::ElementId scroll_latched_element_id);
+  void SendScrollEndEventFromImplSide(cc::ElementId scroll_latched_element_id);
+
+  void RecordManipulationTypeCounts(cc::ManipulationInfo info);
+
   // Finds the parameters required for scrolling the focused editable |element|
   // into view. |out_rect_to_scroll| is used for recursive scrolling of the
   // element into view and contains all or part of element's bounding box and

third_party/blink/renderer/core/inspector/inspector_overlay_agent.cc

@@ -919,6 +919,16 @@ void InspectorOverlayAgent::DispatchBufferedTouchEvents() {
   OverlayMainFrame()->GetEventHandler().DispatchBufferedTouchEvents();
 }
 
+void InspectorOverlayAgent::PageScrollStarted() {
+  // The new scroll can start without the previous ending.
+  is_page_scrolling_ = true;
+}
+
+void InspectorOverlayAgent::PageScrollEnded() {
+  DCHECK(is_page_scrolling_);
+  is_page_scrolling_ = false;
+}
+
 WebInputEventResult InspectorOverlayAgent::HandleInputEvent(
     const WebInputEvent& input_event) {
   if (!enabled_.Get())
@@ -1046,9 +1056,13 @@ void InspectorOverlayAgent::PaintOverlayPage() {
   float scale = WindowToViewportScale();
 
   if (inspect_tool_) {
-    inspect_tool_->Draw(scale);
-    if (persistent_tool_ && inspect_tool_->SupportsPersistentOverlays())
+    // Skip drawing persistent_tool_ on page scroll.
+    if (!(inspect_tool_ == persistent_tool_ && is_page_scrolling_))
+      inspect_tool_->Draw(scale);
+    if (persistent_tool_ && inspect_tool_->SupportsPersistentOverlays() &&
+        !is_page_scrolling_) {
       persistent_tool_->Draw(scale);
+    }
   }
 
   if (hinge_)

third_party/blink/renderer/core/inspector/inspector_overlay_agent.h

@@ -233,6 +233,8 @@ class CORE_EXPORT InspectorOverlayAgent final
   void Inspect(Node*);
   void EnsureAXContext(Node*);
   void DispatchBufferedTouchEvents();
+  void PageScrollStarted();
+  void PageScrollEnded();
   WebInputEventResult HandleInputEvent(const WebInputEvent&);
   WebInputEventResult HandleInputEventInOverlay(const WebInputEvent&);
   void PageLayoutInvalidated(bool resized);
@@ -303,6 +305,7 @@ class CORE_EXPORT InspectorOverlayAgent final
   HeapHashMap<WeakMember<Document>, std::unique_ptr<AXContext>>
       document_to_ax_context_;
   bool swallow_next_mouse_up_;
+  bool is_page_scrolling_ = false;
   DOMNodeId backend_node_id_to_inspect_;
   InspectorAgentState::Boolean enabled_;
   InspectorAgentState::Boolean show_ad_highlights_;

third_party/blink/renderer/platform/widget/compositing/layer_tree_view.cc

@@ -206,26 +206,11 @@ void LayerTreeView::ApplyViewportChanges(
   delegate_->ApplyViewportChanges(args);
 }
 
-void LayerTreeView::RecordManipulationTypeCounts(cc::ManipulationInfo info) {
+void LayerTreeView::UpdateCompositorScrollState(
+    const cc::CompositorCommitData& commit_data) {
   if (!delegate_)
     return;
-  delegate_->RecordManipulationTypeCounts(info);
-}
-
-void LayerTreeView::SendOverscrollEventFromImplSide(
-    const gfx::Vector2dF& overscroll_delta,
-    cc::ElementId scroll_latched_element_id) {
-  if (!delegate_)
-    return;
-  delegate_->SendOverscrollEventFromImplSide(overscroll_delta,
-                                             scroll_latched_element_id);
-}
-
-void LayerTreeView::SendScrollEndEventFromImplSide(
-    cc::ElementId scroll_latched_element_id) {
-  if (!delegate_)
-    return;
-  delegate_->SendScrollEndEventFromImplSide(scroll_latched_element_id);
+  delegate_->UpdateCompositorScrollState(commit_data);
 }
 
 void LayerTreeView::RequestNewLayerTreeFrameSink() {

third_party/blink/renderer/platform/widget/compositing/layer_tree_view.h

@@ -79,12 +79,8 @@ class PLATFORM_EXPORT LayerTreeView
   void BeginMainFrameNotExpectedUntil(base::TimeTicks time) override;
   void UpdateLayerTreeHost() override;
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override;
-  void RecordManipulationTypeCounts(cc::ManipulationInfo info) override;
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) override;
-  void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) override;
+  void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) override;
   void RequestNewLayerTreeFrameSink() override;
   void DidInitializeLayerTreeFrameSink() override;
   void DidFailToInitializeLayerTreeFrameSink() override;

third_party/blink/renderer/platform/widget/compositing/layer_tree_view_delegate.h

@@ -14,7 +14,6 @@
 namespace cc {
 class LayerTreeFrameSink;
 struct BeginMainFrameMetrics;
-struct ElementId;
 struct WebVitalMetrics;
 class RenderFrameMetadataObserver;
 }  // namespace cc
@@ -34,20 +33,8 @@ class LayerTreeViewDelegate {
   virtual void ApplyViewportChanges(
       const cc::ApplyViewportChangesArgs& args) = 0;
 
-  // Record use counts of different methods of scrolling (e.g. wheel, touch,
-  // precision touchpad, etc.).
-  virtual void RecordManipulationTypeCounts(cc::ManipulationInfo info) = 0;
-
-  // Send overscroll DOM event when overscrolling has happened on the compositor
-  // thread.
-  virtual void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) = 0;
-
-  // Send scrollend DOM event when gesture scrolling on the compositor thread
-  // has finished.
-  virtual void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) = 0;
+  virtual void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) = 0;
 
   // Notifies that the compositor has issued a BeginMainFrame.
   virtual void BeginMainFrame(base::TimeTicks frame_time) = 0;

third_party/blink/renderer/platform/widget/compositing/test/stub_layer_tree_view_delegate.h

@@ -23,12 +23,8 @@ class StubLayerTreeViewDelegate : public LayerTreeViewDelegate {
       LayerTreeFrameSinkCallback callback) override {}
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override {
   }
-  void RecordManipulationTypeCounts(cc::ManipulationInfo info) override {}
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) override {}
-  void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) override {}
+  void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) override {}
   void BeginMainFrame(base::TimeTicks frame_time) override {}
   void OnDeferMainFrameUpdatesChanged(bool) override {}
   void OnDeferCommitsChanged(bool) override {}

third_party/blink/renderer/platform/widget/widget_base.cc

@@ -460,20 +460,9 @@ void WidgetBase::ApplyViewportChanges(
   client_->ApplyViewportChanges(args);
 }
 
-void WidgetBase::RecordManipulationTypeCounts(cc::ManipulationInfo info) {
-  client_->RecordManipulationTypeCounts(info);
-}
-
-void WidgetBase::SendOverscrollEventFromImplSide(
-    const gfx::Vector2dF& overscroll_delta,
-    cc::ElementId scroll_latched_element_id) {
-  client_->SendOverscrollEventFromImplSide(overscroll_delta,
-                                           scroll_latched_element_id);
-}
-
-void WidgetBase::SendScrollEndEventFromImplSide(
-    cc::ElementId scroll_latched_element_id) {
-  client_->SendScrollEndEventFromImplSide(scroll_latched_element_id);
+void WidgetBase::UpdateCompositorScrollState(
+    const cc::CompositorCommitData& commit_data) {
+  client_->UpdateCompositorScrollState(commit_data);
 }
 
 void WidgetBase::OnDeferMainFrameUpdatesChanged(bool defer) {

third_party/blink/renderer/platform/widget/widget_base.h

@@ -124,12 +124,8 @@ class PLATFORM_EXPORT WidgetBase : public mojom::blink::Widget,
   // Applies viewport related properties during a commit from the compositor
   // thread.
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override;
-  void RecordManipulationTypeCounts(cc::ManipulationInfo info) override;
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) override;
-  void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) override;
+  void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) override;
   void BeginMainFrame(base::TimeTicks frame_time) override;
   void OnDeferMainFrameUpdatesChanged(bool) override;
   void OnDeferCommitsChanged(bool) override;

third_party/blink/renderer/platform/widget/widget_base_client.h

@@ -95,13 +95,8 @@ class WidgetBaseClient {
   // thread.
   virtual void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) {}
 
-  virtual void RecordManipulationTypeCounts(cc::ManipulationInfo info) {}
-
-  virtual void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) {}
-  virtual void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) {}
+  virtual void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) {}
 
   virtual void DidBeginMainFrame() {}
   virtual void DidCommitAndDrawCompositorFrame() {}

third_party/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py

@@ -328,6 +328,8 @@ _CONFIG = [
             'cc::kManipulationInfoPrecisionTouchPad',
             'cc::kManipulationInfoTouch',
             'cc::kManipulationInfoWheel',
+            'cc::kManipulationInfoScrollbar',
+            'cc::kManipulationInfoNone',
             'cc::kPixelsPerLineStep',
             'cc::kMinFractionToStepWhenPaging',
             'cc::kPercentDeltaForDirectionalScroll',
@@ -657,11 +659,19 @@ _CONFIG = [
         'paths':
         ['third_party/blink/renderer/core/frame/web_frame_widget_impl.cc'],
         'allowed': [
+            'cc::CompositorCommitData',
             'cc::InputHandlerScrollResult',
             'cc::SwapPromise',
             'viz::CompositorFrameMetadata',
         ],
     },
+    {
+        'paths':
+        ['third_party/blink/renderer/core/frame/web_frame_widget_impl.h'],
+        'allowed': [
+            'cc::CompositorCommitData',
+        ],
+    },
     {
         'paths':
         ['third_party/blink/renderer/core/frame/web_local_frame_impl.cc'],

ui/compositor/compositor.h

@@ -322,12 +322,8 @@ class COMPOSITOR_EXPORT Compositor : public cc::LayerTreeHostClient,
   void UpdateLayerTreeHost() override;
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override {
   }
-  void RecordManipulationTypeCounts(cc::ManipulationInfo info) override {}
-  void SendOverscrollEventFromImplSide(
-      const gfx::Vector2dF& overscroll_delta,
-      cc::ElementId scroll_latched_element_id) override {}
-  void SendScrollEndEventFromImplSide(
-      cc::ElementId scroll_latched_element_id) override {}
+  void UpdateCompositorScrollState(
+      const cc::CompositorCommitData& commit_data) override {}
   void RequestNewLayerTreeFrameSink() override;
   void DidInitializeLayerTreeFrameSink() override {}
   void DidFailToInitializeLayerTreeFrameSink() override;