Update from https://crrev.com/316786

cc/trees/property_tree_builder.cc

 // Copyright 2014 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/property_tree_builder.h"
 
 #include <map>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 12 matching lines @@
   ClipTree* clip_tree;
   Layer* transform_tree_parent;
   Layer* transform_fixed_parent;
   Layer* render_target;
   int clip_tree_parent;
   gfx::Vector2dF offset_to_transform_tree_parent;
   gfx::Vector2dF offset_to_transform_fixed_parent;
   const Layer* page_scale_layer;
   float page_scale_factor;
   float device_scale_factor;
+  bool in_subtree_of_page_scale_application_layer;
+  const gfx::Transform* device_transform;
 };
 
 static Layer* GetTransformParent(const DataForRecursion& data, Layer* layer) {
   return layer->position_constraint().is_fixed_position()
              ? data.transform_fixed_parent
              : data.transform_tree_parent;
 }
 
 static ClipNode* GetClipParent(const DataForRecursion& data, Layer* layer) {
   const bool inherits_clip = !layer->parent() || !layer->clip_parent();
@@ skipping 115 matching lines @@
   data_for_children->transform_tree_parent = layer;
 
   if (!requires_node) {
     gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
                                   layer->transform().To2dTranslation();
     layer->set_offset_to_transform_parent(parent_offset + local_offset);
     layer->set_transform_tree_index(transform_parent->transform_tree_index());
     return;
   }
 
-  if (!is_root) {
-    data_for_children->transform_tree->Insert(
-        TransformNode(), transform_parent->transform_tree_index());
-  }
+  int parent_index = 0;
+  if (transform_parent)
+    parent_index = transform_parent->transform_tree_index();
+
+  data_for_children->transform_tree->Insert(TransformNode(), parent_index);
 
   TransformNode* node = data_for_children->transform_tree->back();
   layer->set_transform_tree_index(node->id);
 
+  node->data.scrolls = is_scrollable;
   node->data.flattens = layer->should_flatten_transform();
   node->data.target_id =
       data_from_ancestor.render_target->transform_tree_index();
+  node->data.content_target_id =
+      data_for_children->render_target->transform_tree_index();
   DCHECK_NE(node->data.target_id, -1);
   node->data.is_animated = layer->TransformIsAnimating();
 
-  gfx::Transform transform;
-  float device_and_page_scale_factors = 1.0f;
-  if (is_root)
-    device_and_page_scale_factors = data_from_ancestor.device_scale_factor;
-  if (is_page_scale_application_layer)
-    device_and_page_scale_factors *= data_from_ancestor.page_scale_factor;
-
-  transform.Scale(device_and_page_scale_factors, device_and_page_scale_factors);
-
-  // TODO(vollick): We've accounted for the scroll offset here but we haven't
-  // taken into account snapping to screen space pixels. For the purposes of
-  // computing rects we need to record, this should be fine (the visible rects
-  // we compute may be slightly different than what we'd compute with snapping,
-  // but since we significantly expand the visible rect when determining what to
-  // record, the slight difference should be inconsequential).
-  gfx::Vector2dF position = layer->position().OffsetFromOrigin();
-  if (!layer->scroll_parent()) {
-    position -= gfx::Vector2dF(layer->CurrentScrollOffset().x(),
-                               layer->CurrentScrollOffset().y());
+  float scale_factors = 1.0f;
+  if (is_root) {
+    node->data.post_local = *data_from_ancestor.device_transform;
+    scale_factors = data_from_ancestor.device_scale_factor;
   }
 
-  position += parent_offset;
+  if (is_page_scale_application_layer)
+    scale_factors *= data_from_ancestor.page_scale_factor;
 
-  transform.Translate3d(position.x() + layer->transform_origin().x(),
-                        position.y() + layer->transform_origin().y(),
-                        layer->transform_origin().z());
-  transform.PreconcatTransform(layer->transform());
-  transform.Translate3d(-layer->transform_origin().x(),
-                        -layer->transform_origin().y(),
-                        -layer->transform_origin().z());
+  if (has_surface && !is_root) {
+    node->data.needs_sublayer_scale = true;
+    node->data.layer_scale_factor = data_from_ancestor.device_scale_factor;
+    if (data_from_ancestor.in_subtree_of_page_scale_application_layer)
+      node->data.layer_scale_factor *= data_from_ancestor.page_scale_factor;
+  }
 
-  node->data.to_parent = transform;
-  node->data.is_invertible = transform.GetInverse(&node->data.from_parent);
+  node->data.post_local.Scale(scale_factors, scale_factors);
+  node->data.post_local.Translate3d(
+      layer->position().x() + parent_offset.x() + layer->transform_origin().x(),
+      layer->position().y() + parent_offset.y() + layer->transform_origin().y(),
+      layer->transform_origin().z());
 
-  data_from_ancestor.transform_tree->UpdateScreenSpaceTransform(node->id);
+  if (!layer->scroll_parent()) {
+    node->data.scroll_offset =
+        gfx::ScrollOffsetToVector2dF(layer->CurrentScrollOffset());
+  }
+
+  node->data.local = layer->transform();
+  node->data.pre_local.Translate3d(-layer->transform_origin().x(),
+                                   -layer->transform_origin().y(),
+                                   -layer->transform_origin().z());
+
+  node->data.needs_local_transform_update = true;
+  data_from_ancestor.transform_tree->UpdateTransforms(node->id);
 
   layer->set_offset_to_transform_parent(gfx::Vector2dF());
 }
 
 void BuildPropertyTreesInternal(Layer* layer,
                                 const DataForRecursion& data_from_parent) {
   DataForRecursion data_for_children(data_from_parent);
   if (layer->render_surface())
     data_for_children.render_target = layer;
 
   AddTransformNodeIfNeeded(data_from_parent, layer, &data_for_children);
   AddClipNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
+  if (layer == data_from_parent.page_scale_layer)
+    data_for_children.in_subtree_of_page_scale_application_layer = true;
+
   for (size_t i = 0; i < layer->children().size(); ++i) {
     if (!layer->children()[i]->scroll_parent())
       BuildPropertyTreesInternal(layer->children()[i].get(), data_for_children);
   }
 
   if (layer->scroll_children()) {
     for (Layer* scroll_child : *layer->scroll_children()) {
       BuildPropertyTreesInternal(scroll_child, data_for_children);
     }
   }
@@ skipping 16 matching lines @@
   DataForRecursion data_for_recursion;
   data_for_recursion.transform_tree = transform_tree;
   data_for_recursion.clip_tree = clip_tree;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.render_target = root_layer;
   data_for_recursion.clip_tree_parent = 0;
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.device_scale_factor = device_scale_factor;
-
-  int transform_root_id = transform_tree->Insert(TransformNode(), 0);
+  data_for_recursion.in_subtree_of_page_scale_application_layer = false;
+  data_for_recursion.device_transform = &device_transform;
 
   ClipNode root_clip;
   root_clip.data.clip = viewport;
   root_clip.data.transform_id = 0;
   data_for_recursion.clip_tree_parent = clip_tree->Insert(root_clip, 0);
-
   BuildPropertyTreesInternal(root_layer, data_for_recursion);
-
-  TransformNode* transform_root = transform_tree->Node(transform_root_id);
-  transform_root->data.set_to_parent(device_transform *
-                                     transform_root->data.to_parent);
 }
 
 }  // namespace cc