Update from https://crrev.com/306901

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
@@ skipping 603 matching lines @@
   stacking_order_changed_ = false;
   update_rect_ = gfx::Rect();
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 gfx::Vector2dF LayerImpl::FixedContainerSizeDelta() const {
   if (!scroll_clip_layer_)
     return gfx::Vector2dF();
 
-  float scale_delta = layer_tree_impl()->page_scale_delta();
-  float scale = layer_tree_impl()->page_scale_factor();
-
   gfx::Vector2dF delta_from_scroll = scroll_clip_layer_->bounds_delta();
 
   // In virtual-viewport mode, we don't need to compensate for pinch zoom or
   // scale since the fixed container is the outer viewport, which sits below
   // the page scale.
   if (layer_tree_impl()->settings().use_pinch_virtual_viewport)
     return delta_from_scroll;
 
+  float scale_delta = layer_tree_impl()->page_scale_delta();
+  float scale = layer_tree_impl()->current_page_scale_factor() /
+                layer_tree_impl()->page_scale_delta();
+
   delta_from_scroll.Scale(1.f / scale);
 
   // The delta-from-pinch component requires some explanation: A viewport of
   // size (w,h) will appear to be size (w/s,h/s) under scale s in the content
   // space. If s -> s' on the impl thread, where s' = s * ds, then the apparent
   // viewport size change in the content space due to ds is:
   //
   // (w/s',h/s') - (w/s,h/s) = (w,h)(1/s' - 1/s) = (w,h)(1 - ds)/(s ds)
   //
   gfx::Vector2dF delta_from_pinch =
@@ skipping 561 matching lines @@
   float scale_factor = 1.f;
   for (LayerImpl const* current_layer = this;
        current_layer != scroll_clip_layer_;
        current_layer = current_layer->parent()) {
     DCHECK(current_layer);
     float current_layer_scale = 1.f;
 
     const gfx::Transform& layer_transform = current_layer->transform();
     if (current_layer == page_scale_layer) {
       DCHECK(layer_transform.IsIdentity());
-      current_layer_scale = layer_tree_impl()->total_page_scale_factor();
+      current_layer_scale = layer_tree_impl()->current_page_scale_factor();
     } else {
       // TODO(wjmaclean) Should we allow for translation too?
       DCHECK(layer_transform.IsScale2d());
       gfx::Vector2dF layer_scale = layer_transform.Scale2d();
       // TODO(wjmaclean) Allow for non-isotropic scales.
       DCHECK(layer_scale.x() == layer_scale.y());
       current_layer_scale = layer_scale.x();
     }
 
     scale_factor *= current_layer_scale;
   }
   // TODO(wjmaclean) Once we move to a model where the two-viewport model is
   // turned on in all builds, remove the next two lines. For now however, the
   // page scale layer may coincide with the clip layer, and so this is
   // necessary.
   if (page_scale_layer == scroll_clip_layer_)
-    scale_factor *= layer_tree_impl()->total_page_scale_factor();
+    scale_factor *= layer_tree_impl()->current_page_scale_factor();
 
   scaled_scroll_bounds.SetSize(scale_factor * scaled_scroll_bounds.width(),
                                scale_factor * scaled_scroll_bounds.height());
   scaled_scroll_bounds = gfx::ToFlooredSize(scaled_scroll_bounds);
 
   gfx::ScrollOffset max_offset(
       scaled_scroll_bounds.width() - scroll_clip_layer_->bounds().width(),
       scaled_scroll_bounds.height() - scroll_clip_layer_->bounds().height());
   // We need the final scroll offset to be in CSS coords.
   max_offset.Scale(1 / scale_factor);
@@ skipping 38 matching lines @@
   // TODO(wjmaclean) This computation is nearly identical to the one in
   // MaxScrollOffset. Find some way to combine these.
   gfx::ScrollOffset current_offset;
   for (LayerImpl const* current_layer = this;
        current_layer != scrollbar_clip_layer;
        current_layer = current_layer->parent()) {
     DCHECK(current_layer);
     const gfx::Transform& layer_transform = current_layer->transform();
     if (current_layer == page_scale_layer) {
       DCHECK(layer_transform.IsIdentity());
-      float scale_factor = layer_tree_impl()->total_page_scale_factor();
+      float scale_factor = layer_tree_impl()->current_page_scale_factor();
       current_offset.Scale(scale_factor);
       scroll_rect.Scale(scale_factor);
     } else {
       DCHECK(layer_transform.IsScale2d());
       gfx::Vector2dF layer_scale = layer_transform.Scale2d();
       DCHECK(layer_scale.x() == layer_scale.y());
       gfx::ScrollOffset new_offset = ScrollOffsetWithDelta(
           current_layer->scroll_offset(), current_layer->ScrollDelta());
       new_offset.Scale(layer_scale.x(), layer_scale.y());
       current_offset += new_offset;
     }
   }
   // TODO(wjmaclean) Once we move to a model where the two-viewport model is
   // turned on in all builds, remove the next two lines. For now however, the
   // page scale layer may coincide with the clip layer, and so this is
   // necessary.
   if (page_scale_layer == scrollbar_clip_layer) {
-    scroll_rect.Scale(layer_tree_impl()->total_page_scale_factor());
-    current_offset.Scale(layer_tree_impl()->total_page_scale_factor());
+    scroll_rect.Scale(layer_tree_impl()->current_page_scale_factor());
+    current_offset.Scale(layer_tree_impl()->current_page_scale_factor());
   }
 
   bool scrollbar_needs_animation = false;
   scrollbar_needs_animation |= scrollbar_layer->SetVerticalAdjust(
       scrollbar_clip_layer->bounds_delta().y());
   if (scrollbar_layer->orientation() == HORIZONTAL) {
     float visible_ratio = clip_rect.width() / scroll_rect.width();
     scrollbar_needs_animation |=
         scrollbar_layer->SetCurrentPos(current_offset.x());
     scrollbar_needs_animation |=
@@ skipping 14 matching lines @@
     // TODO(wjmaclean) The scrollbar animator for the pinch-zoom scrollbars
     // should activate for every scroll on the main frame, not just the
     // scrolls that move the pinch virtual viewport (i.e. trigger from
     // either inner or outer viewport).
     if (scrollbar_animation_controller_) {
       // When both non-overlay and overlay scrollbars are both present, don't
       // animate the overlay scrollbars when page scale factor is at the min.
       // Non-overlay scrollbars also shouldn't trigger animations.
       bool is_animatable_scrollbar =
           scrollbar_layer->is_overlay_scrollbar() &&
-          ((layer_tree_impl()->total_page_scale_factor() >
+          ((layer_tree_impl()->current_page_scale_factor() >
             layer_tree_impl()->min_page_scale_factor()) ||
            !layer_tree_impl()->settings().use_pinch_zoom_scrollbars);
       if (is_animatable_scrollbar)
         scrollbar_animation_controller_->DidScrollUpdate(on_resize);
     }
   }
 }
 
 void LayerImpl::DidBecomeActive() {
   if (layer_tree_impl_->settings().scrollbar_animator ==
@@ skipping 232 matching lines @@
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property,
     int group) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc