Update from https://crrev.com/320931

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 663 matching lines @@
   // If we'll make a copy of the layer's contents.
   if (layer->HasCopyRequest())
     return true;
 
   return false;
 }
 
 // This function returns a translation matrix that can be applied on a vector
 // that's in the layer's target surface coordinate, while the position offset is
 // specified in some ancestor layer's coordinate.
+template <typename LayerType>
 gfx::Transform ComputeSizeDeltaCompensation(
-    LayerImpl* layer,
-    LayerImpl* container,
+    LayerType* layer,
+    LayerType* container,
     const gfx::Vector2dF& position_offset) {
   gfx::Transform result_transform;
 
   // To apply a translate in the container's layer space,
   // the following steps need to be done:
   //     Step 1a. transform from target surface space to the container's target
   //              surface space
   //     Step 1b. transform from container's target surface space to the
   //              container's layer space
   //     Step 2. apply the compensation
   //     Step 3. transform back to target surface space
 
   gfx::Transform target_surface_space_to_container_layer_space;
   // Calculate step 1a
-  LayerImpl* container_target_surface = container->render_target();
-  for (LayerImpl* current_target_surface = NextTargetSurface(layer);
+  LayerType* container_target_surface = container->render_target();
+  for (LayerType* current_target_surface = NextTargetSurface(layer);
       current_target_surface &&
           current_target_surface != container_target_surface;
       current_target_surface = NextTargetSurface(current_target_surface)) {
     // Note: Concat is used here to convert the result coordinate space from
     //       current render surface to the next render surface.
     target_surface_space_to_container_layer_space.ConcatTransform(
         current_target_surface->render_surface()->draw_transform());
   }
   // Calculate step 1b
   gfx::Transform container_layer_space_to_container_target_surface_space =
@@ skipping 26 matching lines @@
   // Apply step 2
   result_transform.Translate(position_offset.x(), position_offset.y());
 
   // Apply step 1
   result_transform.PreconcatTransform(
       target_surface_space_to_container_layer_space);
 
   return result_transform;
 }
 
+template <typename LayerType>
 void ApplyPositionAdjustment(
-    Layer* layer,
-    Layer* container,
-    const gfx::Transform& scroll_compensation,
-    gfx::Transform* combined_transform) {}
-void ApplyPositionAdjustment(
-    LayerImpl* layer,
-    LayerImpl* container,
+    LayerType* layer,
+    LayerType* container,
     const gfx::Transform& scroll_compensation,
     gfx::Transform* combined_transform) {
   if (!layer->position_constraint().is_fixed_position())
     return;
 
   // Special case: this layer is a composited fixed-position layer; we need to
   // explicitly compensate for all ancestors' nonzero scroll_deltas to keep
   // this layer fixed correctly.
   // Note carefully: this is Concat, not Preconcat
   // (current_scroll_compensation * combined_transform).
@@ skipping 10 matching lines @@
   position_offset.set_y(fixed_to_bottom_edge ? position_offset.y() : 0);
   if (position_offset.IsZero())
     return;
 
   // Note: Again, this is Concat. The compensation matrix will be applied on
   //       the vector in target surface space.
   combined_transform->ConcatTransform(
       ComputeSizeDeltaCompensation(layer, container, position_offset));
 }
 
+template <typename LayerType>
 gfx::Transform ComputeScrollCompensationForThisLayer(
-    LayerImpl* scrolling_layer,
+    LayerType* scrolling_layer,
     const gfx::Transform& parent_matrix,
     const gfx::Vector2dF& scroll_delta) {
   // For every layer that has non-zero scroll_delta, we have to compute a
   // transform that can undo the scroll_delta translation. In particular, we
   // want this matrix to premultiply a fixed-position layer's parent_matrix, so
   // we design this transform in three steps as follows. The steps described
   // here apply from right-to-left, so Step 1 would be the right-most matrix:
   //
   //     Step 1. transform from target surface space to the exact space where
   //           scroll_delta is actually applied.
@@ skipping 17 matching lines @@
   gfx::Transform inverse_parent_matrix(gfx::Transform::kSkipInitialization);
   if (!parent_matrix.GetInverse(&inverse_parent_matrix)) {
     // TODO(shawnsingh): Either we need to handle uninvertible transforms
     // here, or DCHECK that the transform is invertible.
   }
   scroll_compensation_for_this_layer.PreconcatTransform(
       inverse_parent_matrix);  // Step 1
   return scroll_compensation_for_this_layer;
 }
 
+template <typename LayerType>
 gfx::Transform ComputeScrollCompensationMatrixForChildren(
-    Layer* current_layer,
-    const gfx::Transform& current_parent_matrix,
-    const gfx::Transform& current_scroll_compensation,
-    const gfx::Vector2dF& scroll_delta) {
-  // The main thread (i.e. Layer) does not need to worry about scroll
-  // compensation.  So we can just return an identity matrix here.
-  return gfx::Transform();
-}
-
-gfx::Transform ComputeScrollCompensationMatrixForChildren(
-    LayerImpl* layer,
+    LayerType* layer,
     const gfx::Transform& parent_matrix,
     const gfx::Transform& current_scroll_compensation_matrix,
     const gfx::Vector2dF& scroll_delta) {
   // "Total scroll compensation" is the transform needed to cancel out all
   // scroll_delta translations that occurred since the nearest container layer,
   // even if there are render_surfaces in-between.
   //
   // There are some edge cases to be aware of, that are not explicit in the
   // code:
   //  - A layer that is both a fixed-position and container should not be its
@@ skipping 1720 matching lines @@
       inputs->current_render_surface_layer_list_id);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 }  // namespace cc