Update from https://crrev.com/316786

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 1090 matching lines @@
 }
 
 bool Layer::NeedMoreUpdates() {
   return false;
 }
 
 bool Layer::IsSuitableForGpuRasterization() const {
   return true;
 }
 
-scoped_refptr<base::debug::ConvertableToTraceFormat> Layer::TakeDebugInfo() {
+scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+Layer::TakeDebugInfo() {
   if (client_)
     return client_->TakeDebugInfo();
   else
     return nullptr;
 }
 
 void Layer::SetHasRenderSurface(bool has_render_surface) {
   if (has_render_surface_ == has_render_surface)
     return;
   has_render_surface_ = has_render_surface;
@@ skipping 169 matching lines @@
   if (transform_tree_index() >= 0) {
     gfx::Transform ssxform = tree.Node(transform_tree_index())->data.to_screen;
     xform.ConcatTransform(ssxform);
   }
   xform.Scale(1.0 / contents_scale_x(), 1.0 / contents_scale_y());
   return xform;
 }
 
 gfx::Transform Layer::draw_transform_from_property_trees(
     const TransformTree& tree) const {
-  gfx::Transform xform(1, 0, 0, 1, offset_to_transform_parent().x(),
-                       offset_to_transform_parent().y());
-  if (transform_tree_index() >= 0) {
-    const TransformNode* node = tree.Node(transform_tree_index());
-    gfx::Transform ssxform;
-    tree.ComputeTransform(node->id, node->data.target_id, &ssxform);
-    xform.ConcatTransform(ssxform);
+  const TransformNode* node = tree.Node(transform_tree_index());
+  // TODO(vollick): ultimately we'll need to find this information (whether or
+  // not we establish a render surface) somewhere other than the layer.
+  const TransformNode* target_node =
+      has_render_surface_ ? node : tree.Node(node->data.content_target_id);
+
+  gfx::Transform xform;
+  const bool owns_non_root_surface = parent() && render_surface();
+  if (!owns_non_root_surface) {
+    // If you're not the root, or you don't own a surface, you need to apply
+    // your local offset.
+    xform = node->data.to_target;
+    xform.Translate(offset_to_transform_parent().x(),
+                    offset_to_transform_parent().y());
+  } else {
+    // Surfaces need to apply their sublayer scale.
+    xform.Scale(target_node->data.sublayer_scale.x(),
+                target_node->data.sublayer_scale.y());
   }
   xform.Scale(1.0 / contents_scale_x(), 1.0 / contents_scale_y());
   return xform;
 }
 
 void Layer::SetFrameTimingRequests(
     const std::vector<FrameTimingRequest>& requests) {
   frame_timing_requests_ = requests;
   frame_timing_requests_dirty_ = true;
   SetNeedsCommit();
 }
 
 }  // namespace cc