Update from https://crrev.com/306901

cc/trees/layer_tree_impl.h

 // 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.
 
 #ifndef CC_TREES_LAYER_TREE_IMPL_H_
 #define CC_TREES_LAYER_TREE_IMPL_H_
 
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/values.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/base/swap_promise.h"
+#include "cc/base/synced_property.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/renderer.h"
 #include "cc/resources/ui_resource_client.h"
 
 namespace base {
 namespace debug {
 class TracedValue;
 }
 }
 
@@ skipping 19 matching lines @@
 class UIResourceRequest;
 struct PendingPageScaleAnimation;
 struct RendererCapabilities;
 struct SelectionHandle;
 
 typedef std::list<UIResourceRequest> UIResourceRequestQueue;
 
 class CC_EXPORT LayerTreeImpl {
  public:
   static scoped_ptr<LayerTreeImpl> create(
-      LayerTreeHostImpl* layer_tree_host_impl) {
-    return make_scoped_ptr(new LayerTreeImpl(layer_tree_host_impl));
+      LayerTreeHostImpl* layer_tree_host_impl,
+      scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor) {
+    return make_scoped_ptr(
+        new LayerTreeImpl(layer_tree_host_impl, page_scale_factor));
   }
   virtual ~LayerTreeImpl();
 
   void Shutdown();
   void ReleaseResources();
 
   // Methods called by the layer tree that pass-through or access LTHI.
   // ---------------------------------------------------------------------------
   const LayerTreeSettings& settings() const;
   const RendererCapabilitiesImpl& GetRendererCapabilities() const;
@@ skipping 86 matching lines @@
   SkColor background_color() const { return background_color_; }
   void set_background_color(SkColor color) { background_color_ = color; }
 
   bool has_transparent_background() const {
     return has_transparent_background_;
   }
   void set_has_transparent_background(bool transparent) {
     has_transparent_background_ = transparent;
   }
 
-  void SetPageScaleFactorAndLimits(float page_scale_factor,
-      float min_page_scale_factor, float max_page_scale_factor);
-  void SetPageScaleDelta(float delta);
-  void SetPageScaleValues(float page_scale_factor,
-      float min_page_scale_factor, float max_page_scale_factor,
-      float page_scale_delta);
-  float total_page_scale_factor() const {
-    return page_scale_factor_ * page_scale_delta_;
+  void SetPageScaleOnActiveTree(float active_page_scale);
+  void PushPageScaleFromMainThread(float page_scale_factor,
+                                   float min_page_scale_factor,
+                                   float max_page_scale_factor);
+  float current_page_scale_factor() const {
+    return page_scale_factor()->Current(IsActiveTree());
   }
-  float page_scale_factor() const { return page_scale_factor_; }
   float min_page_scale_factor() const { return min_page_scale_factor_; }
   float max_page_scale_factor() const { return max_page_scale_factor_; }
-  float page_scale_delta() const  { return page_scale_delta_; }
-  void set_sent_page_scale_delta(float delta) {
-    sent_page_scale_delta_ = delta;
-  }
-  float sent_page_scale_delta() const { return sent_page_scale_delta_; }
+
+  float page_scale_delta() const { return page_scale_factor()->Delta(); }
+
+  SyncedProperty<ScaleGroup>* page_scale_factor();
+  const SyncedProperty<ScaleGroup>* page_scale_factor() const;
 
   // Updates draw properties and render surface layer list, as well as tile
   // priorities. Returns false if it was unable to update.
   bool UpdateDrawProperties();
 
   void set_needs_update_draw_properties() {
     needs_update_draw_properties_ = true;
   }
   bool needs_update_draw_properties() const {
     return needs_update_draw_properties_;
@@ skipping 89 matching lines @@
                          const LayerSelectionBound& end);
 
   // Compute the current selection handle location and visbility with respect to
   // the viewport.
   void GetViewportSelection(ViewportSelectionBound* start,
                             ViewportSelectionBound* end);
 
   void RegisterPictureLayerImpl(PictureLayerImpl* layer);
   void UnregisterPictureLayerImpl(PictureLayerImpl* layer);
 
-  void set_top_controls_layout_height(float height) {
-    top_controls_layout_height_ = height;
+  void set_top_controls_shrink_blink_size(bool shrink) {
+    top_controls_shrink_blink_size_ = shrink;
   }
+  void set_top_controls_height(float height) { top_controls_height_ = height; }
   void set_top_controls_content_offset(float offset) {
     top_controls_content_offset_ = offset;
   }
   void set_top_controls_delta(float delta) {
     top_controls_delta_ = delta;
   }
   void set_sent_top_controls_delta(float sent_delta) {
     sent_top_controls_delta_ = sent_delta;
   }
 
-  float top_controls_layout_height() const {
-    return top_controls_layout_height_;
+  bool top_controls_shrink_blink_size() const {
+    return top_controls_shrink_blink_size_;
   }
+  float top_controls_height() const { return top_controls_height_; }
   float top_controls_content_offset() const {
     return top_controls_content_offset_;
   }
   float top_controls_delta() const {
     return top_controls_delta_;
   }
   float sent_top_controls_delta() const {
     return sent_top_controls_delta_;
   }
   float total_top_controls_content_offset() const {
     return top_controls_content_offset_ + top_controls_delta_;
   }
 
   void SetPendingPageScaleAnimation(
       scoped_ptr<PendingPageScaleAnimation> pending_animation);
   scoped_ptr<PendingPageScaleAnimation> TakePendingPageScaleAnimation();
 
  protected:
-  explicit LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl);
+  explicit LayerTreeImpl(
+      LayerTreeHostImpl* layer_tree_host_impl,
+      scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor);
   void ReleaseResourcesRecursive(LayerImpl* current);
+  float ClampPageScaleFactorToLimits(float page_scale_factor) const;
+  void PushPageScaleFactorAndLimits(const float* page_scale_factor,
+                                    float min_page_scale_factor,
+                                    float max_page_scale_factor);
+  bool SetPageScaleFactorLimits(float min_page_scale_factor,
+                                float max_page_scale_factor);
+  void DidUpdatePageScale();
 
   LayerTreeHostImpl* layer_tree_host_impl_;
   int source_frame_number_;
   scoped_ptr<LayerImpl> root_layer_;
   HeadsUpDisplayLayerImpl* hud_layer_;
   LayerImpl* currently_scrolling_layer_;
   LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
   scoped_ptr<LayerScrollOffsetDelegateProxy>
       inner_viewport_scroll_delegate_proxy_;
   scoped_ptr<LayerScrollOffsetDelegateProxy>
       outer_viewport_scroll_delegate_proxy_;
   SkColor background_color_;
   bool has_transparent_background_;
 
   LayerImpl* overscroll_elasticity_layer_;
   LayerImpl* page_scale_layer_;
   LayerImpl* inner_viewport_scroll_layer_;
   LayerImpl* outer_viewport_scroll_layer_;
 
   LayerSelectionBound selection_start_;
   LayerSelectionBound selection_end_;
 
-  float page_scale_factor_;
-  float page_scale_delta_;
-  float sent_page_scale_delta_;
+  scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor_;
   float min_page_scale_factor_;
   float max_page_scale_factor_;
 
   typedef base::hash_map<int, LayerImpl*> LayerIdMap;
   LayerIdMap layer_id_map_;
 
   std::vector<LayerImpl*> layers_with_copy_output_request_;
 
   // Persisted state for non-impl-side-painting.
   int scrolling_layer_id_from_previous_tree_;
@@ skipping 12 matching lines @@
   bool next_activation_forces_redraw_;
 
   bool has_ever_been_drawn_;
 
   ScopedPtrVector<SwapPromise> swap_promise_list_;
 
   UIResourceRequestQueue ui_resource_request_queue_;
 
   int render_surface_layer_list_id_;
 
-  // The top controls content offset at the time of the last layout (and thus,
-  // viewport resize) in Blink. i.e. How much the viewport was shrunk by the top
-  // controls.
-  float top_controls_layout_height_;
+  // Whether or not Blink's viewport size was shrunk by the height of the top
+  // controls at the time of the last layout.
+  bool top_controls_shrink_blink_size_;
+
+  float top_controls_height_;
 
   // The up-to-date content offset of the top controls, i.e. the amount that the
   // web contents have been shifted down from the top of the device viewport.
   float top_controls_content_offset_;
   float top_controls_delta_;
   float sent_top_controls_delta_;
 
   scoped_ptr<PendingPageScaleAnimation> pending_page_scale_animation_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LayerTreeImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_IMPL_H_