Update from https://crrev.com/320931

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 155 matching lines @@
 
   if (layer->IsContainerForFixedPositionLayers() || is_root)
     data_for_children->transform_fixed_parent = layer;
   data_for_children->transform_tree_parent = layer;
 
   if (!requires_node) {
     data_for_children->should_flatten |= layer->should_flatten_transform();
     gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
                                   layer->transform().To2dTranslation();
     layer->set_offset_to_transform_parent(parent_offset + local_offset);
+    layer->set_should_flatten_transform_from_property_tree(
+        data_from_ancestor.should_flatten);
     layer->set_transform_tree_index(transform_parent->transform_tree_index());
     return;
   }
 
   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_inherited_transform = data_for_children->should_flatten;
-  node->data.flattens_local_transform = layer->should_flatten_transform();
-  data_for_children->should_flatten = false;
+
+  // Surfaces inherently flatten transforms.
+  data_for_children->should_flatten =
+      layer->should_flatten_transform() || has_surface;
   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();
 
   float scale_factors = 1.0f;
   if (is_root) {
     node->data.post_local = *data_from_ancestor.device_transform;
@@ skipping 23 matching lines @@
 
   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());
+
+  // Flattening (if needed) will be handled by |node|.
+  layer->set_should_flatten_transform_from_property_tree(false);
 }
 
 void AddOpacityNodeIfNeeded(const DataForRecursion& data_from_ancestor,
                             Layer* layer,
                             DataForRecursion* data_for_children) {
   const bool is_root = !layer->parent();
   const bool has_transparency = layer->opacity() != 1.f;
   const bool has_animated_opacity =
       layer->layer_animation_controller()->IsAnimatingProperty(
           Animation::OPACITY) ||
@@ skipping 74 matching lines @@
   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);
 }
 
 }  // namespace cc