Update from https://crrev.com/320343

cc/trees/property_tree.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 <set>
 
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/trees/property_tree.h"
 
@@ skipping 25 matching lines @@
 template class PropertyTree<OpacityNode>;
 
 TransformNodeData::TransformNodeData()
     : target_id(-1),
       content_target_id(-1),
       needs_local_transform_update(true),
       is_invertible(true),
       ancestors_are_invertible(true),
       is_animated(false),
       to_screen_is_animated(false),
-      flattens(false),
+      flattens_inherited_transform(false),
+      flattens_local_transform(false),
       scrolls(false),
       needs_sublayer_scale(false),
       layer_scale_factor(1.0f) {
 }
 
 TransformNodeData::~TransformNodeData() {
 }
 
 ClipNodeData::ClipNodeData() : transform_id(-1), target_id(-1) {
 }
@@ skipping 126 matching lines @@
   node->data.needs_local_transform_update = false;
 }
 
 void TransformTree::UpdateScreenSpaceTransform(TransformNode* node,
                                                TransformNode* parent_node,
                                                TransformNode* target_node) {
   if (!parent_node) {
     node->data.to_screen = node->data.to_parent;
     node->data.ancestors_are_invertible = true;
     node->data.to_screen_is_animated = false;
-  } else if (parent_node->data.flattens) {
+  } else if (parent_node->data.flattens_local_transform ||
+             node->data.flattens_inherited_transform) {
     // Flattening is tricky. Once a layer is drawn into its render target, it
     // cannot escape, so we only need to consider transforms between the layer
     // and its target when flattening (i.e., its draw transform). To compute the
     // screen space transform when flattening is involved we combine three
     // transforms, A * B * C, where A is the screen space transform of the
     // target, B is the flattened draw transform of the layer's parent, and C is
     // the local transform.
     node->data.to_screen = target_node->data.to_screen;
     gfx::Transform flattened;
     ComputeTransform(parent_node->id, target_node->id, &flattened);
@@ skipping 82 matching lines @@
   // combined, to/from matrices.
   node->data.to_parent.PreconcatTransform(delta);
   node->data.from_parent.ConcatTransform(inverse_delta);
   node->data.to_target.PreconcatTransform(delta);
   node->data.from_target.ConcatTransform(inverse_delta);
   node->data.to_screen.PreconcatTransform(delta);
   node->data.from_screen.ConcatTransform(inverse_delta);
 }
 
 }  // namespace cc