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/browser/renderer_host/render_widget_host_view_android.cc

@@ -10,6 +10,7 @@
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ -992,29 +993,31 @@ bool RenderWidgetHostViewAndroid::RequestRepaintForTesting() {
 }
 
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
-    viz::CompositorFrameMetadata frame_metadata) {
+    viz::CompositorFrameMetadata metadata) {
   if (!view_.parent())
     return;
 
-  bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
+  bool is_mobile_optimized = IsMobileOptimizedFrame(
+      metadata.page_scale_factor, metadata.min_page_scale_factor,
+      metadata.max_page_scale_factor, metadata.scrollable_viewport_size,
+      metadata.root_layer_size);
 
   if (host() && host()->input_router()) {
     host()->input_router()->NotifySiteIsMobileOptimized(is_mobile_optimized);
   }
 
-  if (host() && frame_metadata.frame_token)
-    host()->DidProcessFrame(frame_metadata.frame_token);
+  if (host() && metadata.frame_token)
+    host()->DidProcessFrame(metadata.frame_token);
 
   // This is a subset of OnSwapCompositorFrame() used in the synchronous
   // compositor flow.
-  OnFrameMetadataUpdated(frame_metadata.Clone(), false);
+  OnFrameMetadataUpdated(metadata.Clone(), false);
 
   // DevTools ScreenCast support for Android WebView.
   RenderFrameHost* frame_host = RenderViewHost::From(host())->GetMainFrame();
   if (frame_host) {
     RenderFrameDevToolsAgentHost::SignalSynchronousSwapCompositorFrame(
-        frame_host,
-        std::move(frame_metadata));
+        frame_host, std::move(metadata));
   }
 }
 
@@ -1160,16 +1163,22 @@ RenderWidgetHostViewAndroid::GetWebContentsAccessibilityAndroid() const {
 }
 
 void RenderWidgetHostViewAndroid::OnFrameMetadataUpdated(
-    const viz::CompositorFrameMetadata& frame_metadata,
+    const viz::CompositorFrameMetadata& metadata,
     bool is_transparent) {
-  bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
+  if (features::IsSurfaceSynchronizationEnabled())
+    return;
+
+  bool is_mobile_optimized = IsMobileOptimizedFrame(
+      metadata.page_scale_factor, metadata.min_page_scale_factor,
+      metadata.max_page_scale_factor, metadata.scrollable_viewport_size,
+      metadata.root_layer_size);
+
   gesture_provider_.SetDoubleTapSupportForPageEnabled(!is_mobile_optimized);
 
   float dip_scale = view_.GetDipScale();
-  gfx::SizeF root_layer_size_dip = frame_metadata.root_layer_size;
-  gfx::SizeF scrollable_viewport_size_dip =
-      frame_metadata.scrollable_viewport_size;
-  gfx::Vector2dF root_scroll_offset_dip = frame_metadata.root_scroll_offset;
+  gfx::SizeF root_layer_size_dip = metadata.root_layer_size;
+  gfx::SizeF scrollable_viewport_size_dip = metadata.scrollable_viewport_size;
+  gfx::Vector2dF root_scroll_offset_dip = metadata.root_scroll_offset;
   if (IsUseZoomForDSFEnabled()) {
     float pix_to_dip = 1 / dip_scale;
     root_layer_size_dip.Scale(pix_to_dip);
@@ -1180,62 +1189,57 @@ void RenderWidgetHostViewAndroid::OnFrameMetadataUpdated(
   float to_pix = IsUseZoomForDSFEnabled() ? 1.f : dip_scale;
   // Note that the height of browser control is not affected by page scale
   // factor. Thus, |top_content_offset| in CSS pixels is also in DIPs.
-  float top_content_offset = frame_metadata.top_controls_height *
-                             frame_metadata.top_controls_shown_ratio;
+  float top_content_offset =
+      metadata.top_controls_height * metadata.top_controls_shown_ratio;
   float top_shown_pix = top_content_offset * to_pix;
 
-  if (ime_adapter_android_)
-    ime_adapter_android_->UpdateFrameInfo(frame_metadata.selection.start,
-                                          dip_scale, top_shown_pix);
+  if (ime_adapter_android_) {
+    ime_adapter_android_->UpdateFrameInfo(metadata.selection.start, dip_scale,
+                                          top_shown_pix);
+  }
 
   auto* wcax = GetWebContentsAccessibilityAndroid();
   if (wcax)
-    wcax->UpdateFrameInfo(frame_metadata.page_scale_factor);
+    wcax->UpdateFrameInfo(metadata.page_scale_factor);
 
   if (!gesture_listener_manager_)
     return;
 
-  if (overscroll_controller_)
-    overscroll_controller_->OnFrameMetadataUpdated(frame_metadata);
-
-  if (!features::IsSurfaceSynchronizationEnabled()) {
-    UpdateTouchSelectionController(
-        frame_metadata.selection, frame_metadata.page_scale_factor,
-        frame_metadata.top_controls_height,
-        frame_metadata.top_controls_shown_ratio, scrollable_viewport_size_dip);
+  if (overscroll_controller_) {
+    overscroll_controller_->OnFrameMetadataUpdated(
+        metadata.page_scale_factor, metadata.device_scale_factor,
+        metadata.scrollable_viewport_size, metadata.root_layer_size,
+        metadata.root_scroll_offset, metadata.root_overflow_y_hidden);
   }
 
-  SetContentBackgroundColor(is_transparent
-                                ? SK_ColorTRANSPARENT
-                                : frame_metadata.root_background_color);
-
+  UpdateTouchSelectionController(metadata.selection, metadata.page_scale_factor,
+                                 metadata.top_controls_height,
+                                 metadata.top_controls_shown_ratio,
+                                 scrollable_viewport_size_dip);
   // ViewAndroid::content_offset() must be in CSS scale
   float top_content_offset_dip = IsUseZoomForDSFEnabled()
                                      ? top_content_offset / dip_scale
                                      : top_content_offset;
   view_.UpdateFrameInfo({scrollable_viewport_size_dip, top_content_offset});
-  bool controls_changed =
-      features::IsSurfaceSynchronizationEnabled()
-          ? false
-          : UpdateControls(view_.GetDipScale(),
-                           frame_metadata.top_controls_height,
-                           frame_metadata.top_controls_shown_ratio,
-                           frame_metadata.bottom_controls_height,
-                           frame_metadata.bottom_controls_shown_ratio);
-
-  page_scale_ = frame_metadata.page_scale_factor;
-  min_page_scale_ = frame_metadata.min_page_scale_factor;
-  max_page_scale_ = frame_metadata.max_page_scale_factor;
+  bool controls_changed = UpdateControls(
+      view_.GetDipScale(), metadata.top_controls_height,
+      metadata.top_controls_shown_ratio, metadata.bottom_controls_height,
+      metadata.bottom_controls_shown_ratio);
 
   // All offsets and sizes except |top_shown_pix| are in CSS pixels.
-  // TODO(fsamuel): This needs to be synchronized with RenderFrameMetadata when
-  // surface synchronization is enabled.
   gesture_listener_manager_->UpdateScrollInfo(
-      root_scroll_offset_dip, frame_metadata.page_scale_factor,
-      frame_metadata.min_page_scale_factor,
-      frame_metadata.max_page_scale_factor, root_layer_size_dip,
-      scrollable_viewport_size_dip, top_content_offset_dip, top_shown_pix,
-      controls_changed);
+      root_scroll_offset_dip, metadata.page_scale_factor,
+      metadata.min_page_scale_factor, metadata.max_page_scale_factor,
+      root_layer_size_dip, scrollable_viewport_size_dip, top_content_offset_dip,
+      top_shown_pix, controls_changed);
+
+  // TODO(fsamuel): Plumb the |is_transparent| flag through RenderFrameMetadata.
+  SetContentBackgroundColor(is_transparent ? SK_ColorTRANSPARENT
+                                           : metadata.root_background_color);
+
+  page_scale_ = metadata.page_scale_factor;
+  min_page_scale_ = metadata.min_page_scale_factor;
+  max_page_scale_ = metadata.max_page_scale_factor;
 
   EvictFrameIfNecessary();
 }
@@ -1308,35 +1312,90 @@ bool RenderWidgetHostViewAndroid::UpdateControls(
 
 void RenderWidgetHostViewAndroid::OnDidUpdateVisualPropertiesComplete(
     const cc::RenderFrameMetadata& metadata) {
-  if (local_surface_id_allocator_.UpdateFromChild(
+  base::ScopedClosureRunner sync_visual_props_runner(base::BindOnce(
+      base::IgnoreResult(
+          &RenderWidgetHostViewAndroid::SynchronizeVisualProperties),
+      base::Unretained(this)));
+
+  if (!local_surface_id_allocator_.UpdateFromChild(
           metadata.local_surface_id.value_or(viz::LocalSurfaceId()))) {
-    if (features::IsSurfaceSynchronizationEnabled()) {
-      // A synchronization event was initiated by the renderer so let's updated
-      // the top/bottom bar controls now.
-      UpdateControls(view_.GetDipScale(), metadata.top_controls_height,
-                     metadata.top_controls_shown_ratio,
-                     metadata.bottom_controls_height,
-                     metadata.bottom_controls_shown_ratio);
+    return;
+  }
+
+  if (!features::IsSurfaceSynchronizationEnabled())
+    return;
+
+  bool is_mobile_optimized = IsMobileOptimizedFrame(
+      metadata.page_scale_factor, metadata.min_page_scale_factor,
+      metadata.max_page_scale_factor, metadata.scrollable_viewport_size,
+      metadata.root_layer_size);
+
+  gesture_provider_.SetDoubleTapSupportForPageEnabled(!is_mobile_optimized);
+
   float dip_scale = view_.GetDipScale();
-      gfx::SizeF scrollable_viewport_size_dip =
-          metadata.scrollable_viewport_size;
+  gfx::SizeF root_layer_size_dip = metadata.root_layer_size;
+  gfx::SizeF scrollable_viewport_size_dip = metadata.scrollable_viewport_size;
+  gfx::Vector2dF root_scroll_offset_dip =
+      metadata.root_scroll_offset.value_or(gfx::Vector2dF());
   if (IsUseZoomForDSFEnabled()) {
-        float pix_to_dip = 1.f / dip_scale;
+    float pix_to_dip = 1 / dip_scale;
+    root_layer_size_dip.Scale(pix_to_dip);
     scrollable_viewport_size_dip.Scale(pix_to_dip);
+    root_scroll_offset_dip.Scale(pix_to_dip);
   }
-      UpdateTouchSelectionController(
-          metadata.selection, metadata.page_scale_factor,
-          metadata.top_controls_height, metadata.top_controls_shown_ratio,
-          scrollable_viewport_size_dip);
-    }
-    if (delegated_frame_host_) {
-      delegated_frame_host_->EmbedSurface(
-          local_surface_id_allocator_.GetCurrentLocalSurfaceId(),
-          GetCompositorViewportPixelSize(),
-          cc::DeadlinePolicy::UseDefaultDeadline());
+
+  float to_pix = IsUseZoomForDSFEnabled() ? 1.f : dip_scale;
+  // Note that the height of browser control is not affected by page scale
+  // factor. Thus, |top_content_offset| in CSS pixels is also in DIPs.
+  float top_content_offset =
+      metadata.top_controls_height * metadata.top_controls_shown_ratio;
+  float top_shown_pix = top_content_offset * to_pix;
+
+  if (ime_adapter_android_) {
+    ime_adapter_android_->UpdateFrameInfo(metadata.selection.start, dip_scale,
+                                          top_shown_pix);
   }
+
+  auto* wcax = GetWebContentsAccessibilityAndroid();
+  if (wcax)
+    wcax->UpdateFrameInfo(metadata.page_scale_factor);
+
+  if (!gesture_listener_manager_)
+    return;
+
+  if (overscroll_controller_) {
+    overscroll_controller_->OnFrameMetadataUpdated(
+        metadata.page_scale_factor, metadata.device_scale_factor,
+        metadata.scrollable_viewport_size, metadata.root_layer_size,
+        metadata.root_scroll_offset.value_or(gfx::Vector2dF()),
+        metadata.root_overflow_y_hidden);
   }
-  host()->SynchronizeVisualProperties();
+
+  UpdateTouchSelectionController(metadata.selection, metadata.page_scale_factor,
+                                 metadata.top_controls_height,
+                                 metadata.top_controls_shown_ratio,
+                                 scrollable_viewport_size_dip);
+
+  // ViewAndroid::content_offset() must be in CSS scale
+  float top_content_offset_dip = IsUseZoomForDSFEnabled()
+                                     ? top_content_offset / dip_scale
+                                     : top_content_offset;
+  view_.UpdateFrameInfo({scrollable_viewport_size_dip, top_content_offset});
+  bool controls_changed = UpdateControls(
+      view_.GetDipScale(), metadata.top_controls_height,
+      metadata.top_controls_shown_ratio, metadata.bottom_controls_height,
+      metadata.bottom_controls_shown_ratio);
+
+  // All offsets and sizes except |top_shown_pix| are in CSS pixels.
+  gesture_listener_manager_->UpdateScrollInfo(
+      root_scroll_offset_dip, metadata.page_scale_factor,
+      metadata.min_page_scale_factor, metadata.max_page_scale_factor,
+      root_layer_size_dip, scrollable_viewport_size_dip, top_content_offset_dip,
+      top_shown_pix, controls_changed);
+
+  page_scale_ = metadata.page_scale_factor;
+  min_page_scale_ = metadata.min_page_scale_factor;
+  max_page_scale_ = metadata.max_page_scale_factor;
 }
 
 void RenderWidgetHostViewAndroid::ShowInternal() {

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;
   }