Make PageScaleFactor work for oopif subframes.

cc/trees/layer_tree_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 38 matching lines @@
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
+    scoped_refptr<SyncedProperty<ScaleGroup>> subframe_page_scale_factor,
     scoped_refptr<SyncedBrowserControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       is_first_frame_after_commit_tracker_(-1),
       root_layer_for_testing_(nullptr),
       hud_layer_(nullptr),
       background_color_(0),
       has_transparent_background_(false),
       last_scrolled_layer_id_(Layer::INVALID_ID),
       overscroll_elasticity_layer_id_(Layer::INVALID_ID),
       page_scale_layer_id_(Layer::INVALID_ID),
       inner_viewport_scroll_layer_id_(Layer::INVALID_ID),
       outer_viewport_scroll_layer_id_(Layer::INVALID_ID),
       page_scale_factor_(page_scale_factor),
+      subframe_page_scale_factor_(subframe_page_scale_factor),
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       device_scale_factor_(1.f),
       painted_device_scale_factor_(1.f),
       elastic_overscroll_(elastic_overscroll),
       layers_(new OwnedLayerImplList),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true),
       next_activation_forces_redraw_(false),
@@ skipping 360 matching lines @@
   swap_promise_list_.clear();
 
   target_tree->set_browser_controls_shrink_blink_size(
       browser_controls_shrink_blink_size_);
   target_tree->set_top_controls_height(top_controls_height_);
   target_tree->set_bottom_controls_height(bottom_controls_height_);
   target_tree->PushBrowserControls(nullptr);
 
   // Active tree already shares the page_scale_factor object with pending
   // tree so only the limits need to be provided.
-  target_tree->PushPageScaleFactorAndLimits(nullptr, min_page_scale_factor(),
-                                            max_page_scale_factor());
+  target_tree->PushPageScaleFactorAndLimits(
+      nullptr, nullptr, min_page_scale_factor(), max_page_scale_factor());
   target_tree->SetDeviceScaleFactor(device_scale_factor());
   target_tree->set_painted_device_scale_factor(painted_device_scale_factor());
   target_tree->SetDeviceColorSpace(device_color_space_);
   target_tree->elastic_overscroll()->PushPendingToActive();
 
   target_tree->pending_page_scale_animation_ =
       std::move(pending_page_scale_animation_);
 
   target_tree->SetViewportLayersFromIds(
       overscroll_elasticity_layer_id_, page_scale_layer_id_,
@@ skipping 270 matching lines @@
     if (PageScaleLayer()) {
       draw_property_utils::UpdatePageScaleFactor(
           property_trees(), PageScaleLayer(), current_page_scale_factor(),
           device_scale_factor(), layer_tree_host_impl_->DrawTransform());
     } else {
       DCHECK(layer_list_.empty() || active_page_scale == 1);
     }
   }
 }
 
+void LayerTreeImpl::SetSubframePageScaleOnActiveTree(
+    float active_subframe_page_scale) {
+  DCHECK(IsActiveTree());
+  if (subframe_page_scale_factor()->SetCurrent(
+          ClampPageScaleFactorToLimits(active_subframe_page_scale))) {
+    DidUpdatePageScale();
+  }
+}
+
 void LayerTreeImpl::PushPageScaleFromMainThread(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
-  PushPageScaleFactorAndLimits(&page_scale_factor, min_page_scale_factor,
-                               max_page_scale_factor);
+  PushPageScaleFactorAndLimits(&page_scale_factor, nullptr,
+                               min_page_scale_factor, max_page_scale_factor);
 }
 
-void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* page_scale_factor,
-                                                 float min_page_scale_factor,
-                                                 float max_page_scale_factor) {
-  DCHECK(page_scale_factor || IsActiveTree());
+void LayerTreeImpl::PushPageScaleFromMainThread(
+    float page_scale_factor,
+    float subframe_page_scale_factor,
+    float min_page_scale_factor,
+    float max_page_scale_factor) {
+  PushPageScaleFactorAndLimits(&page_scale_factor, &subframe_page_scale_factor,
+                               min_page_scale_factor, max_page_scale_factor);
+}
+
+void LayerTreeImpl::PushPageScaleFactorAndLimits(
+    const float* page_scale_factor,
+    const float* subframe_page_scale_factor,
+    float min_page_scale_factor,
+    float max_page_scale_factor) {
+  DCHECK(page_scale_factor || subframe_page_scale_factor || IsActiveTree());
   bool changed_page_scale = false;
+  bool changed_subframe_page_scale = false;
 
   changed_page_scale |=
       SetPageScaleFactorLimits(min_page_scale_factor, max_page_scale_factor);
 
   if (page_scale_factor) {
     DCHECK(!IsActiveTree() || !layer_tree_host_impl_->pending_tree());
     changed_page_scale |= page_scale_factor_->Delta() != 1.f;
     // TODO(enne): Once CDP goes away, ignore this call below.  The only time
     // the property trees will differ is if there's been a page scale on the
     // compositor thread after the begin frame, which is the delta check above.
     changed_page_scale |=
         page_scale_factor_->PushFromMainThread(*page_scale_factor);
   }
 
+  if (subframe_page_scale_factor) {
+    changed_subframe_page_scale |= subframe_page_scale_factor_->Delta() != 1.f;
+    changed_subframe_page_scale |=
+        subframe_page_scale_factor_->PushFromMainThread(
+            *subframe_page_scale_factor);
+  }
+
   if (IsActiveTree()) {
     // TODO(enne): Pushing from pending to active should never require
     // DidUpdatePageScale.  The values should already be set by the fully
     // computed property trees being synced from one tree to another.  Remove
     // this once CDP goes away.
     changed_page_scale |= page_scale_factor_->PushPendingToActive();
+    // TODO(wjmaclean): subframe_page_scale_factor is not involved in CDP so far
+    // as I know, not sure that that means for this next line.
+    changed_subframe_page_scale |=
+        subframe_page_scale_factor_->PushPendingToActive();
   }
 
-  if (changed_page_scale)
+  if (changed_page_scale || changed_subframe_page_scale)
     DidUpdatePageScale();
 
   if (page_scale_factor) {
     if (PageScaleLayer()) {
       draw_property_utils::UpdatePageScaleFactor(
           property_trees(), PageScaleLayer(), current_page_scale_factor(),
           device_scale_factor(), layer_tree_host_impl_->DrawTransform());
     } else {
       DCHECK(layer_list_.empty() || *page_scale_factor == 1);
     }
@@ skipping 66 matching lines @@
       max_page_scale_factor == max_page_scale_factor_)
     return false;
 
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
 
   return true;
 }
 
 void LayerTreeImpl::DidUpdatePageScale() {
-  if (IsActiveTree())
+  if (IsActiveTree()) {
     page_scale_factor()->SetCurrent(
         ClampPageScaleFactorToLimits(current_page_scale_factor()));
+    subframe_page_scale_factor()->SetCurrent(
+        ClampPageScaleFactorToLimits(GetSubframePageScaleFactor()));
+  }
 
   set_needs_update_draw_properties();
   DidUpdateScrollState(inner_viewport_scroll_layer_id_);
 }
 
 void LayerTreeImpl::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
@@ skipping 11 matching lines @@
 }
 
 SyncedProperty<ScaleGroup>* LayerTreeImpl::page_scale_factor() {
   return page_scale_factor_.get();
 }
 
 const SyncedProperty<ScaleGroup>* LayerTreeImpl::page_scale_factor() const {
   return page_scale_factor_.get();
 }
 
+SyncedProperty<ScaleGroup>* LayerTreeImpl::subframe_page_scale_factor() {
+  return subframe_page_scale_factor_.get();
+}
+
+const SyncedProperty<ScaleGroup>* LayerTreeImpl::subframe_page_scale_factor()
+    const {
+  return subframe_page_scale_factor_.get();
+}
+
 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const {
   if (!InnerViewportContainerLayer())
     return gfx::SizeF();
 
   return gfx::ScaleSize(InnerViewportContainerLayer()->BoundsForScrolling(),
                         1.0f / current_page_scale_factor());
 }
 
 gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
   LayerImpl* root_scroll_layer = OuterViewportScrollLayer()
                                      ? OuterViewportScrollLayer()
                                      : InnerViewportScrollLayer();
   if (!root_scroll_layer)
     return gfx::Rect();
   return MathUtil::MapEnclosingClippedRect(
       root_scroll_layer->ScreenSpaceTransform(),
       gfx::Rect(root_scroll_layer->bounds()));
 }
 
 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
   DCHECK(IsActiveTree());
 
   page_scale_factor()->AbortCommit();
+  subframe_page_scale_factor()->AbortCommit();
   top_controls_shown_ratio()->AbortCommit();
   elastic_overscroll()->AbortCommit();
 
   if (layer_list_.empty())
     return;
 
   property_trees()->scroll_tree.ApplySentScrollDeltasFromAbortedCommit();
 }
 
 void LayerTreeImpl::SetViewportLayersFromIds(
@@ skipping 1172 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc