WebView setFrameContentVelocity integration

To be conservative, compute the change in scroll offset before and after
a begin frame, which can be done on the UI thread since begin frame is
synchronous. This covers touch scroll, fling, and and any css scroll
animations.

Limitations is this only covers root scroll, and does not cover things
like js scroll or java scroll. These cases it's not possible to
distinguish between scroll vs a jump.

Use delta between frame time since it's the only reliable source of
current frame rate and is the time stamp used for animations.

Bug: 346732738
Change-Id: I60c30b77235802a7b194b6edbaa9d3f509e8086a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5741874
Commit-Queue: Bo Liu <boliu@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1333006}

android_webview/browser/aw_contents.cc

@@ -1098,6 +1098,10 @@ bool AwContents::OnDraw(JNIEnv* env,
   return browser_view_renderer_.OnDrawSoftware(canvas_holder->GetCanvas());
 }
 
+jfloat AwContents::GetVelocityInPixelsPerSecond(JNIEnv* env) {
+  return browser_view_renderer_.GetVelocityInPixelsPerSecond();
+}
+
 bool AwContents::NeedToDrawBackgroundColor(JNIEnv* env) {
   return browser_view_renderer_.NeedToDrawBackgroundColor();
 }

android_webview/browser/aw_contents.h

@@ -151,6 +151,7 @@ class AwContents : public FindHelper::Listener,
               jint visible_right,
               jint visible_bottom,
               jboolean force_auxiliary_bitmap_rendering);
+  jfloat GetVelocityInPixelsPerSecond(JNIEnv* env);
   bool NeedToDrawBackgroundColor(JNIEnv* env);
   jlong CapturePicture(JNIEnv* env, int width, int height);
   void EnableOnNewPicture(JNIEnv* env, jboolean enabled);

android_webview/browser/aw_feature_map.cc

@@ -27,6 +27,7 @@ const base::Feature* const kFeaturesExposedToJava[] = {
     &features::kWebViewDisplayCutout,
     &features::kWebViewDragDropFiles,
     &features::kWebViewExitReasonMetric,
+    &features::kWebViewFrameRateHints,
     &features::kWebViewInvokeZoomPickerOnGSU,
     &features::kWebViewMixedContentAutoupgrades,
     &features::kWebViewTestFeature,

android_webview/browser/gfx/browser_view_renderer.cc

@@ -436,6 +436,13 @@ bool BrowserViewRenderer::OnDrawSoftware(SkCanvas* canvas) {
   return CanOnDraw() && CompositeSW(canvas, /*software_canvas=*/true);
 }
 
+float BrowserViewRenderer::GetVelocityInPixelsPerSecond() {
+  if (!compositor_) {
+    return 0.f;
+  }
+  return compositor_->GetVelocityInPixelsPerSecond();
+}
+
 bool BrowserViewRenderer::NeedToDrawBackgroundColor() {
   return !has_rendered_frame_;
 }

android_webview/browser/gfx/browser_view_renderer.h

@@ -88,6 +88,8 @@ class BrowserViewRenderer : public content::SynchronousCompositorClient,
   bool OnDrawHardware();
   bool OnDrawSoftware(SkCanvas* canvas);
 
+  float GetVelocityInPixelsPerSecond();
+
   bool NeedToDrawBackgroundColor();
 
   // CapturePicture API methods.

android_webview/common/aw_features.cc

@@ -59,6 +59,11 @@ BASE_FEATURE(kWebViewForceDarkModeMatchTheme,
              "WebViewForceDarkModeMatchTheme",
              base::FEATURE_DISABLED_BY_DEFAULT);
 
+// Enable WebView providing frame rate hints to View system.
+BASE_FEATURE(kWebViewFrameRateHints,
+             "WebViewFrameRateHints",
+             base::FEATURE_DISABLED_BY_DEFAULT);
+
 BASE_FEATURE(kWebViewHitTestInBlinkOnTouchStart,
              "WebViewHitTestInBlinkOnTouchStart",
              base::FEATURE_ENABLED_BY_DEFAULT);

android_webview/common/aw_features.h

@@ -26,6 +26,7 @@ BASE_DECLARE_FEATURE(kWebViewEnumerateDevicesCache);
 BASE_DECLARE_FEATURE(kWebViewExitReasonMetric);
 BASE_DECLARE_FEATURE(kWebViewExtraHeadersSameOriginOnly);
 BASE_DECLARE_FEATURE(kWebViewForceDarkModeMatchTheme);
+BASE_DECLARE_FEATURE(kWebViewFrameRateHints);
 BASE_DECLARE_FEATURE(kWebViewHitTestInBlinkOnTouchStart);
 BASE_DECLARE_FEATURE(kWebViewImageDrag);
 BASE_DECLARE_FEATURE(kWebViewInvokeZoomPickerOnGSU);

android_webview/java/src/org/chromium/android_webview/AwContents.java

@@ -4575,6 +4575,13 @@ public void onDraw(Canvas canvas) {
                 setFunctor(newFunctor);
             }
 
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM
+                    && AwFeatureMap.isEnabled(AwFeatures.WEBVIEW_FRAME_RATE_HINTS)) {
+                float velocity =
+                        AwContentsJni.get().getVelocityInPixelsPerSecond(mNativeAwContents);
+                mContainerView.setFrameContentVelocity(velocity);
+            }
+
             mScrollOffsetManager.syncScrollOffsetFromOnDraw();
             int scrollX = mContainerView.getScrollX();
             int scrollY = mContainerView.getScrollY();
@@ -5035,6 +5042,8 @@ boolean onDraw(
                 int visibleBottom,
                 boolean forceAuxiliaryBitmapRendering);
 
+        float getVelocityInPixelsPerSecond(long nativeAwContents);
+
         boolean needToDrawBackgroundColor(long nativeAwContents);
 
         void findAllAsync(long nativeAwContents, String searchString);

android_webview/java/src/org/chromium/android_webview/common/ProductionSupportedFlagList.java

@@ -399,6 +399,9 @@ private ProductionSupportedFlagList() {}
                 AwFeatures.WEBVIEW_FORCE_DARK_MODE_MATCH_THEME,
                 "Automatically darken page if"
                         + " WebView is set to FORCE_DARK_AUTO and the app has dark theme"),
+        Flag.baseFeature(
+                AwFeatures.WEBVIEW_FRAME_RATE_HINTS,
+                "Provide frame rate hints to View system if supported by OS"),
         Flag.baseFeature(
                 ContentFeatures.VERIFY_DID_COMMIT_PARAMS,
                 "Enables reporting of browser and renderer navigation inconsistencies on"

content/browser/android/synchronous_compositor_host.cc

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cmath>
 #include <memory>
 #include <utility>
 
@@ -216,6 +217,7 @@ SynchronousCompositorHost::DemandDrawHwAsync(
     const gfx::Size& viewport_size,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
+  velocity_in_pixels_per_second_ = 0.f;
   draw_hw_called_ = true;
   invalidate_needs_draw_ = false;
   num_invalidates_since_last_draw_ = 0u;
@@ -386,6 +388,7 @@ struct SynchronousCompositorHost::SharedMemoryWithSize {
 
 bool SynchronousCompositorHost::DemandDrawSw(SkCanvas* canvas,
                                              bool software_canvas) {
+  velocity_in_pixels_per_second_ = 0.f;
   num_invalidates_since_last_draw_ = 0u;
   if (use_in_process_zero_copy_software_draw_)
     return DemandDrawSwInProc(canvas);
@@ -546,6 +549,10 @@ void SynchronousCompositorHost::SetMemoryPolicy(size_t bytes_limit) {
     compositor->SetMemoryPolicy(bytes_limit_);
 }
 
+float SynchronousCompositorHost::GetVelocityInPixelsPerSecond() {
+  return velocity_in_pixels_per_second_;
+}
+
 void SynchronousCompositorHost::DidChangeRootLayerScrollOffset(
     const gfx::PointF& root_offset) {
   if (root_scroll_offset_ == root_offset)
@@ -694,6 +701,9 @@ void SynchronousCompositorHost::OnBeginFrame(const viz::BeginFrameArgs& args) {
       (outstanding_begin_frame_requests_ & BEGIN_FRAME) ||
       (outstanding_begin_frame_requests_ & PERSISTENT_BEGIN_FRAME);
 
+  last_begin_frame_time_delta_ =
+      args.frame_time - last_begin_frame_args_.frame_time;
+
   // Update |last_begin_frame_args_| before handling
   // |outstanding_begin_frame_requests_| to prevent the BeginFrameSource from
   // sending the same MISSED args in infinite recursion.
@@ -780,6 +790,28 @@ void SynchronousCompositorHost::SendBeginFrame(viz::BeginFrameArgs args) {
   timing_details_.clear();
 }
 
+void SynchronousCompositorHost::BeginFrameComplete(
+    blink::mojom::SyncCompositorCommonRendererParamsPtr params) {
+  velocity_in_pixels_per_second_ = 0.f;
+  gfx::PointF offset = root_scroll_offset_;
+  if (params) {
+    UpdateState(std::move(params));
+  }
+  // Sanity check frame time delta.
+  if (last_begin_frame_time_delta_.InMicroseconds() < 100 ||
+      last_begin_frame_time_delta_.InMicroseconds() > 1000000) {
+    return;
+  }
+  gfx::Vector2dF scroll = root_scroll_offset_ - offset;
+  float major_scroll_in_last_begin_frame =
+      std::abs(scroll.x()) > std::abs(scroll.y()) ? scroll.x() : scroll.y();
+  velocity_in_pixels_per_second_ = major_scroll_in_last_begin_frame /
+                                   last_begin_frame_time_delta_.InSecondsF();
+  TRACE_EVENT_INSTANT("cc", "SynchronousCompositorHost::BeginFrameComplete",
+                      "scroll", major_scroll_in_last_begin_frame, "delta",
+                      last_begin_frame_time_delta_.InMicroseconds());
+}
+
 void SynchronousCompositorHost::SetBeginFrameSource(
     viz::BeginFrameSource* begin_frame_source) {
   DCHECK(!begin_frame_source_);

content/browser/android/synchronous_compositor_host.h

@@ -74,6 +74,7 @@ class CONTENT_EXPORT SynchronousCompositorHost
   void DidPresentCompositorFrames(viz::FrameTimingDetailsMap timing_details,
                                   uint32_t frame_token) override;
   void SetMemoryPolicy(size_t bytes_limit) override;
+  float GetVelocityInPixelsPerSecond() override;
   void DidBecomeActive() override;
   void DidChangeRootLayerScrollOffset(const gfx::PointF& root_offset) override;
   void SynchronouslyZoomBy(float zoom_delta, const gfx::Point& anchor) override;
@@ -90,6 +91,8 @@ class CONTENT_EXPORT SynchronousCompositorHost
       uint32_t version,
       viz::CompositorFrameMetadata frame_metadata,
       std::optional<viz::LocalSurfaceId> new_local_surface_id);
+  void BeginFrameComplete(
+      blink::mojom::SyncCompositorCommonRendererParamsPtr params);
 
   // Called when the mojo channel should be created.
   void InitMojo();
@@ -182,6 +185,9 @@ class CONTENT_EXPORT SynchronousCompositorHost
   // Updated by both renderer and browser. This is in physical pixels.
   gfx::PointF root_scroll_offset_;
 
+  float velocity_in_pixels_per_second_ = 0.f;
+  base::TimeDelta last_begin_frame_time_delta_;
+
   // Indicates that whether OnComputeScroll is called or overridden. The
   // fling_controller should advance the fling only when OnComputeScroll is not
   // overridden.

content/browser/android/synchronous_compositor_sync_call_bridge.cc

@@ -157,8 +157,9 @@ void SynchronousCompositorSyncCallBridge::BeginFrameCompleteOnUIThread() {
       render_params = last_render_params_.Clone();
     }
   }
-  if (render_params)
-    host_->UpdateState(std::move(render_params));
+  if (render_params) {
+    host_->BeginFrameComplete(std::move(render_params));
+  }
 }
 
 void SynchronousCompositorSyncCallBridge::ProcessFrameMetadataOnUIThread(

content/public/browser/android/synchronous_compositor.h

@@ -121,6 +121,10 @@ class CONTENT_EXPORT SynchronousCompositor {
   // Set the memory limit policy of this compositor.
   virtual void SetMemoryPolicy(size_t bytes_limit) = 0;
 
+  // Returns the higher of x or y scroll velocity. Only returns valid value
+  // after begin frame and before DemandDraw of a frame.
+  virtual float GetVelocityInPixelsPerSecond() = 0;
+
   // Called during renderer swap. Should push any relevant up to
   // SynchronousCompositorClient.
   virtual void DidBecomeActive() = 0;

content/public/test/test_synchronous_compositor_android.cc

@@ -56,6 +56,10 @@ bool TestSynchronousCompositor::DemandDrawSw(SkCanvas* canvas,
   return true;
 }
 
+float TestSynchronousCompositor::GetVelocityInPixelsPerSecond() {
+  return 0.f;
+}
+
 void TestSynchronousCompositor::SetHardwareFrame(
     uint32_t layer_tree_frame_sink_id,
     std::unique_ptr<viz::CompositorFrame> frame) {

content/public/test/test_synchronous_compositor_android.h

@@ -45,6 +45,7 @@ class CONTENT_EXPORT TestSynchronousCompositor : public SynchronousCompositor {
                                   uint32_t frame_token) override {}
   bool DemandDrawSw(SkCanvas* canvas, bool software_canvas) override;
   void SetMemoryPolicy(size_t bytes_limit) override {}
+  float GetVelocityInPixelsPerSecond() override;
   void DidBecomeActive() override {}
   void DidChangeRootLayerScrollOffset(const gfx::PointF& root_offset) override {
   }