Surface synchronization: Plumb more things through RenderFrameMetadata

This CL plumbs through additional data when surface synchronization is on on Android for:

1. IME
2. Accessibility
3. OverScrollController
4. view FrameInfo
5. GestureListenerManager

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I812daf08fa00cfba2d92cffaf988604593299c81
Bug: 672962
TBR: yfriedman@chromium.org
Reviewed-on: https://chromium-review.googlesource.com/1097937
Commit-Queue: Fady Samuel <fsamuel@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#567074}

cc/trees/layer_tree_host_impl.cc

@@ -1922,6 +1922,19 @@ RenderFrameMetadata LayerTreeHostImpl::MakeRenderFrameMetadata() {
   metadata.root_scroll_offset =
       gfx::ScrollOffsetToVector2dF(active_tree_->TotalScrollOffset());
   metadata.page_scale_factor = active_tree_->current_page_scale_factor();
+  metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
+  metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
+  metadata.root_layer_size = active_tree_->ScrollableSize();
+  if (const auto* outer_viewport_scroll_node = OuterViewportScrollNode()) {
+    metadata.root_overflow_y_hidden =
+        !outer_viewport_scroll_node->user_scrollable_vertical;
+  }
+  const auto* inner_viewport_scroll_node = InnerViewportScrollNode();
+  if (inner_viewport_scroll_node) {
+    metadata.root_overflow_y_hidden |=
+        !inner_viewport_scroll_node->user_scrollable_vertical;
+  }
+
   metadata.root_background_color = active_tree_->background_color();
   metadata.is_scroll_offset_at_top = active_tree_->TotalScrollOffset().y() == 0;
   metadata.device_scale_factor = active_tree_->painted_device_scale_factor() *

cc/trees/render_frame_metadata.cc

@@ -25,8 +25,13 @@ bool RenderFrameMetadata::HasAlwaysUpdateMetadataChanged(
          rfm1.is_scroll_offset_at_top != rfm2.is_scroll_offset_at_top ||
          rfm1.selection != rfm2.selection ||
 #if defined(OS_ANDROID)
+         rfm1.root_scroll_offset != rfm2.root_scroll_offset ||
          rfm1.page_scale_factor != rfm2.page_scale_factor ||
+         rfm1.min_page_scale_factor != rfm2.min_page_scale_factor ||
+         rfm1.max_page_scale_factor != rfm2.max_page_scale_factor ||
+         rfm1.root_overflow_y_hidden != rfm2.root_overflow_y_hidden ||
          rfm1.scrollable_viewport_size != rfm2.scrollable_viewport_size ||
+         rfm1.root_layer_size != rfm2.root_layer_size ||
 #endif
          rfm1.is_mobile_optimized != rfm2.is_mobile_optimized ||
          rfm1.device_scale_factor != rfm2.device_scale_factor ||
@@ -50,7 +55,11 @@ bool RenderFrameMetadata::operator==(const RenderFrameMetadata& other) const {
          is_scroll_offset_at_top == other.is_scroll_offset_at_top &&
          selection == other.selection &&
          page_scale_factor == other.page_scale_factor &&
+         min_page_scale_factor == other.min_page_scale_factor &&
+         max_page_scale_factor == other.max_page_scale_factor &&
+         root_overflow_y_hidden == other.root_overflow_y_hidden &&
          scrollable_viewport_size == other.scrollable_viewport_size &&
+         root_layer_size == other.root_layer_size &&
          is_mobile_optimized == other.is_mobile_optimized &&
          device_scale_factor == other.device_scale_factor &&
          viewport_size_in_pixels == other.viewport_size_in_pixels &&

cc/trees/render_frame_metadata.h

@@ -52,10 +52,15 @@ class CC_EXPORT RenderFrameMetadata {
   // empty or otherwise unused, the bound types will indicate such.
   viz::Selection<gfx::SelectionBound> selection;
 
-  // The page scale factor used on the content.
+  // These limits can be used together with the scroll/scale fields above to
+  // determine if scrolling/scaling in a particular direction is possible.
   float page_scale_factor = 1.f;
+  float min_page_scale_factor = 0.f;
+  float max_page_scale_factor = 0.f;
+  bool root_overflow_y_hidden = false;
 
   gfx::SizeF scrollable_viewport_size;
+  gfx::SizeF root_layer_size;
 
   // Determines whether the page is mobile optimized or not, which means at
   // least one of the following has to be true:

content/browser/android/overscroll_controller_android.cc

@@ -287,26 +287,30 @@ bool OverscrollControllerAndroid::Animate(base::TimeTicks current_time,
 }
 
 void OverscrollControllerAndroid::OnFrameMetadataUpdated(
-    const viz::CompositorFrameMetadata& frame_metadata) {
+    float page_scale_factor,
+    float device_scale_factor,
+    const gfx::SizeF& scrollable_viewport_size,
+    const gfx::SizeF& root_layer_size,
+    const gfx::Vector2dF& root_scroll_offset,
+    bool root_overflow_y_hidden) {
   if (!refresh_effect_ && !glow_effect_)
     return;
 
   // When use-zoom-for-dsf is enabled, frame_metadata.page_scale_factor was
   // already scaled by the device scale factor.
-  float scale_factor = frame_metadata.page_scale_factor;
+  float scale_factor = page_scale_factor;
   if (!IsUseZoomForDSFEnabled()) {
-    scale_factor *= frame_metadata.device_scale_factor;
+    scale_factor *= device_scale_factor;
   }
   gfx::SizeF viewport_size =
-      gfx::ScaleSize(frame_metadata.scrollable_viewport_size, scale_factor);
-  gfx::SizeF content_size =
-      gfx::ScaleSize(frame_metadata.root_layer_size, scale_factor);
+      gfx::ScaleSize(scrollable_viewport_size, scale_factor);
+  gfx::SizeF content_size = gfx::ScaleSize(root_layer_size, scale_factor);
   gfx::Vector2dF content_scroll_offset =
-      gfx::ScaleVector2d(frame_metadata.root_scroll_offset, scale_factor);
+      gfx::ScaleVector2d(root_scroll_offset, scale_factor);
 
   if (refresh_effect_) {
     refresh_effect_->OnFrameUpdated(content_scroll_offset,
-                                    frame_metadata.root_overflow_y_hidden);
+                                    root_overflow_y_hidden);
   }
 
   if (glow_effect_) {

content/browser/android/overscroll_controller_android.h

@@ -29,10 +29,6 @@ class WindowAndroidCompositor;
 struct DidOverscrollParams;
 }
 
-namespace viz {
-class CompositorFrameMetadata;
-}
-
 namespace content {
 
 // Glue class for handling all inputs into Android-specific overscroll effects,
@@ -70,7 +66,12 @@ class CONTENT_EXPORT OverscrollControllerAndroid
   bool Animate(base::TimeTicks current_time, cc::Layer* parent_layer);
 
   // To be called whenever the content frame has been updated.
-  void OnFrameMetadataUpdated(const viz::CompositorFrameMetadata& metadata);
+  void OnFrameMetadataUpdated(float page_scale_factor,
+                              float device_scale_factor,
+                              const gfx::SizeF& scrollable_viewport_size,
+                              const gfx::SizeF& root_layer_size,
+                              const gfx::Vector2dF& root_scroll_offset,
+                              bool root_overflow_y_hidden);
 
   // Toggle activity of any overscroll effects. When disabled, events will be
   // ignored until the controller is re-enabled.

content/browser/renderer_host/frame_metadata_util.cc

@@ -13,16 +13,16 @@ namespace {
 // V1 saw errors of ~0.065 between computed window and content widths.
 const float kMobileViewportWidthEpsilon = 0.15f;
 
-bool HasFixedPageScale(const viz::CompositorFrameMetadata& frame_metadata) {
-  return frame_metadata.min_page_scale_factor ==
-         frame_metadata.max_page_scale_factor;
+bool HasFixedPageScale(float min_page_scale_factor,
+                       float max_page_scale_factor) {
+  return min_page_scale_factor == max_page_scale_factor;
 }
 
-bool HasMobileViewport(const viz::CompositorFrameMetadata& frame_metadata) {
-  float window_width_dip =
-      frame_metadata.page_scale_factor *
-          frame_metadata.scrollable_viewport_size.width();
-  float content_width_css = frame_metadata.root_layer_size.width();
+bool HasMobileViewport(float page_scale_factor,
+                       const gfx::SizeF& scrollable_viewport_size,
+                       const gfx::SizeF& root_layer_size) {
+  float window_width_dip = page_scale_factor * scrollable_viewport_size.width();
+  float content_width_css = root_layer_size.width();
   return content_width_css <= window_width_dip + kMobileViewportWidthEpsilon;
 }
 
@@ -30,10 +30,15 @@ bool HasMobileViewport(const viz::CompositorFrameMetadata& frame_metadata) {
 
 namespace content {
 
-bool IsMobileOptimizedFrame(
-    const viz::CompositorFrameMetadata& frame_metadata) {
-  bool has_mobile_viewport = HasMobileViewport(frame_metadata);
-  bool has_fixed_page_scale = HasFixedPageScale(frame_metadata);
+bool IsMobileOptimizedFrame(float page_scale_factor,
+                            float min_page_scale_factor,
+                            float max_page_scale_factor,
+                            const gfx::SizeF& scrollable_viewport_size,
+                            const gfx::SizeF& root_layer_size) {
+  bool has_mobile_viewport = HasMobileViewport(
+      page_scale_factor, scrollable_viewport_size, root_layer_size);
+  bool has_fixed_page_scale =
+      HasFixedPageScale(min_page_scale_factor, max_page_scale_factor);
   return has_fixed_page_scale || has_mobile_viewport;
 }
 

content/browser/renderer_host/frame_metadata_util.h

@@ -7,8 +7,8 @@
 
 #include "content/common/content_export.h"
 
-namespace viz {
-class CompositorFrameMetadata;
+namespace gfx {
+class SizeF;
 }
 
 namespace content {
@@ -19,7 +19,11 @@ namespace content {
 //   (indicating that this is a mobile-optimized or responsive web design);
 // - page that prevents zooming in or out.
 CONTENT_EXPORT bool IsMobileOptimizedFrame(
-    const viz::CompositorFrameMetadata& frame_metadata);
+    float page_scale_factor,
+    float min_page_scale_factor,
+    float max_page_scale_factor,
+    const gfx::SizeF& scrollable_viewport_size,
+    const gfx::SizeF& root_layer_size);
 
 }  // namespace content
 

content/common/render_frame_metadata.mojom

@@ -29,8 +29,12 @@ struct RenderFrameMetadata {
 
   // The page scale factor used on the content.
   float page_scale_factor;
+  float min_page_scale_factor;
+  float max_page_scale_factor;
+  bool root_overflow_y_hidden;
 
   gfx.mojom.SizeF scrollable_viewport_size;
+  gfx.mojom.SizeF root_layer_size;
 
   // Determines whether the page is mobile optimized or not, which means at
   // least one of the following has to be true:

content/common/render_frame_metadata_struct_traits.cc

@@ -16,6 +16,9 @@ bool StructTraits<content::mojom::RenderFrameMetadataDataView,
     Read(content::mojom::RenderFrameMetadataDataView data,
          cc::RenderFrameMetadata* out) {
   out->page_scale_factor = data.page_scale_factor();
+  out->min_page_scale_factor = data.min_page_scale_factor();
+  out->max_page_scale_factor = data.max_page_scale_factor();
+  out->root_overflow_y_hidden = data.root_overflow_y_hidden();
   out->root_background_color = data.root_background_color();
   out->is_scroll_offset_at_top = data.is_scroll_offset_at_top();
   out->is_mobile_optimized = data.is_mobile_optimized();
@@ -27,6 +30,7 @@ bool StructTraits<content::mojom::RenderFrameMetadataDataView,
   return data.ReadRootScrollOffset(&out->root_scroll_offset) &&
          data.ReadSelection(&out->selection) &&
          data.ReadScrollableViewportSize(&out->scrollable_viewport_size) &&
+         data.ReadRootLayerSize(&out->root_layer_size) &&
          data.ReadViewportSizeInPixels(&out->viewport_size_in_pixels) &&
          data.ReadLocalSurfaceId(&out->local_surface_id);
 }

content/common/render_frame_metadata_struct_traits.h

@@ -29,6 +29,18 @@ struct StructTraits<content::mojom::RenderFrameMetadataDataView,
     return metadata.page_scale_factor;
   }
 
+  static float min_page_scale_factor(const cc::RenderFrameMetadata& metadata) {
+    return metadata.min_page_scale_factor;
+  }
+
+  static float max_page_scale_factor(const cc::RenderFrameMetadata& metadata) {
+    return metadata.max_page_scale_factor;
+  }
+
+  static bool root_overflow_y_hidden(const cc::RenderFrameMetadata& metadata) {
+    return metadata.root_overflow_y_hidden;
+  }
+
   static bool is_scroll_offset_at_top(const cc::RenderFrameMetadata& metadata) {
     return metadata.is_scroll_offset_at_top;
   }
@@ -43,6 +55,11 @@ struct StructTraits<content::mojom::RenderFrameMetadataDataView,
     return metadata.scrollable_viewport_size;
   }
 
+  static const gfx::SizeF& root_layer_size(
+      const cc::RenderFrameMetadata& metadata) {
+    return metadata.root_layer_size;
+  }
+
   static bool is_mobile_optimized(const cc::RenderFrameMetadata& metadata) {
     return metadata.is_mobile_optimized;
   }