Update from https://crrev.com/309717

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 535 matching lines @@
 
 static inline void SavePaintPropertiesLayer(Layer* layer) {
   layer->SavePaintProperties();
 
   if (layer->mask_layer())
     layer->mask_layer()->SavePaintProperties();
   if (layer->replica_layer() && layer->replica_layer()->mask_layer())
     layer->replica_layer()->mask_layer()->SavePaintProperties();
 }
 
-template <typename LayerType>
 static bool SubtreeShouldRenderToSeparateSurface(
-    LayerType* layer,
+    Layer* layer,
     bool axis_aligned_with_respect_to_parent) {
   //
   // A layer and its descendants should render onto a new RenderSurfaceImpl if
   // any of these rules hold:
   //
 
   // The root layer owns a render surface, but it never acts as a contributing
   // surface to another render target. Compositor features that are applied via
   // a contributing surface can not be applied to the root layer. In order to
   // use these effects, another child of the root would need to be introduced
@@ skipping 535 matching lines @@
     *combined_maximum_animation_contents_scale = 0.f;
     return;
   }
   gfx::Vector2dF ancestor_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f);
   *combined_maximum_animation_contents_scale =
       layer_maximum_animated_scale *
       std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
 }
 
-template <typename LayerType>
-static inline typename LayerType::RenderSurfaceType* CreateOrReuseRenderSurface(
-    LayerType* layer) {
-  if (!layer->render_surface()) {
-    layer->CreateRenderSurface();
-    return layer->render_surface();
-  }
-
-  layer->render_surface()->ClearLayerLists();
-  return layer->render_surface();
-}
-
 template <typename LayerTypePtr>
 static inline void MarkLayerWithRenderSurfaceLayerListId(
     LayerTypePtr layer,
     int current_render_surface_layer_list_id) {
   layer->draw_properties().last_drawn_render_surface_layer_list_id =
       current_render_surface_layer_list_id;
 }
 
 template <typename LayerTypePtr>
 static inline void MarkMasksWithRenderSurfaceLayerListId(
@@ skipping 63 matching lines @@
   void Merge(const PreCalculateMetaInformationRecursiveData& data) {
     layer_or_descendant_has_copy_request |=
         data.layer_or_descendant_has_copy_request;
     layer_or_descendant_has_input_handler |=
         data.layer_or_descendant_has_input_handler;
     num_unclipped_descendants +=
         data.num_unclipped_descendants;
   }
 };
 
+static bool ValidateRenderSurface(LayerImpl* layer) {
+  // There are a few cases in which it is incorrect to not have a
+  // render_surface.
+  if (layer->render_surface())
+    return true;
+
+  return layer->filters().IsEmpty() && layer->background_filters().IsEmpty() &&
+         !layer->mask_layer() && !layer->replica_layer() &&
+         !IsRootLayer(layer) && !layer->is_root_for_isolated_group() &&
+         !layer->HasCopyRequest();
+}
+
+static bool ValidateRenderSurface(Layer* layer) {
+  return true;
+}
+
 // Recursively walks the layer tree to compute any information that is needed
 // before doing the main recursion.
 template <typename LayerType>
 static void PreCalculateMetaInformation(
     LayerType* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
+  DCHECK(ValidateRenderSurface(layer));
 
   layer->draw_properties().sorted_for_recursion = false;
   layer->draw_properties().has_child_with_a_scroll_parent = false;
 
   if (!HasInvertibleOrAnimatedTransform(layer)) {
     // Layers with singular transforms should not be drawn, the whole subtree
     // can be skipped.
     return;
   }
 
@@ skipping 377 matching lines @@
   // the right results.
   const bool layer_is_visible =
       data_from_ancestor.subtree_is_visible_from_ancestor &&
       !layer->hide_layer_and_subtree();
   const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest();
 
   // The root layer cannot skip CalcDrawProperties.
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
     if (layer->render_surface())
       layer->ClearRenderSurfaceLayerList();
+    layer->draw_properties().render_target = nullptr;
     return;
   }
 
   // We need to circumvent the normal recursive flow of information for clip
   // children (they don't inherit their direct ancestor's clip information).
   // This is unfortunate, and would be unnecessary if we were to formally
   // separate the clipping hierarchy from the layer hierarchy.
   bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree;
   gfx::Rect ancestor_clip_rect_in_target_space =
       data_from_ancestor.clip_rect_in_target_space;
@@ skipping 205 matching lines @@
       data_from_ancestor.full_hierarchy_matrix;
 
   // If the subtree will scale layer contents by the transform hierarchy, then
   // we should scale things into the render surface by the transform hierarchy
   // to take advantage of that.
   gfx::Vector2dF render_surface_sublayer_scale =
       globals.can_adjust_raster_scales
       ? combined_transform_scales
       : gfx::Vector2dF(layer_scale_factors, layer_scale_factors);
 
-  bool render_to_separate_surface;
-  if (globals.can_render_to_separate_surface) {
-    render_to_separate_surface = SubtreeShouldRenderToSeparateSurface(
-          layer, combined_transform.Preserves2dAxisAlignment());
-  } else {
-    render_to_separate_surface = IsRootLayer(layer);
-  }
-
-  layer->SetHasRenderSurface(render_to_separate_surface);
+  bool render_to_separate_surface =
+      IsRootLayer(layer) ||
+      (globals.can_render_to_separate_surface && layer->render_surface());
 
   if (render_to_separate_surface) {
+    DCHECK(layer->render_surface());
     // Check back-face visibility before continuing with this surface and its
     // subtree
     if (!layer->double_sided() && TransformToParentIsKnown(layer) &&
         IsSurfaceBackFaceVisible(layer, combined_transform)) {
       layer->ClearRenderSurfaceLayerList();
+      layer->draw_properties().render_target = nullptr;
       return;
     }
 
     typename LayerType::RenderSurfaceType* render_surface =
-        CreateOrReuseRenderSurface(layer);
+        layer->render_surface();
+    layer->ClearRenderSurfaceLayerList();
 
+    layer_draw_properties.render_target = layer;
     if (IsRootLayer(layer)) {
       // The root layer's render surface size is predetermined and so the root
       // layer can't directly support non-identity transforms.  It should just
       // forward top-level transforms to the rest of the tree.
       data_for_children.parent_matrix = combined_transform;
 
       // The root surface does not contribute to any other surface, it has no
       // target.
       layer->render_surface()->set_contributes_to_drawn_surface(false);
     } else {
@@ skipping 159 matching lines @@
         animating_transform_to_target;
     layer_draw_properties.screen_space_transform_is_animating =
         animating_transform_to_screen;
     layer_draw_properties.opacity = accumulated_draw_opacity;
     layer_draw_properties.blend_mode = layer->blend_mode();
     layer_draw_properties.opacity_is_animating = animating_opacity_to_target;
     layer_draw_properties.screen_space_opacity_is_animating =
         animating_opacity_to_screen;
     data_for_children.parent_matrix = combined_transform;
 
-    layer->ClearRenderSurface();
-
     // Layers without render_surfaces directly inherit the ancestor's clip
     // status.
     layer_or_ancestor_clips_descendants = ancestor_clips_subtree;
     if (ancestor_clips_subtree) {
       clip_rect_in_target_space =
           ancestor_clip_rect_in_target_space;
     }
 
     // The surface's cached clip rect value propagates regardless of what
     // clipping goes on between layers here.
@@ skipping 20 matching lines @@
   // Thus we can omit contents scale in the following calculation.
   gfx::Vector2d bounds_delta =  BoundsDelta(layer);
   content_size_affected_by_delta.Enlarge(bounds_delta.x(), bounds_delta.y());
 
   gfx::Rect rect_in_target_space = MathUtil::MapEnclosingClippedRect(
       layer->draw_transform(),
       gfx::Rect(content_size_affected_by_delta));
 
   if (LayerClipsSubtree(layer)) {
     layer_or_ancestor_clips_descendants = true;
-    if (ancestor_clips_subtree && !layer->render_surface()) {
+    if (ancestor_clips_subtree && !render_to_separate_surface) {
       // A layer without render surface shares the same target as its ancestor.
       clip_rect_in_target_space =
           ancestor_clip_rect_in_target_space;
       clip_rect_in_target_space.Intersect(rect_in_target_space);
     } else {
       clip_rect_in_target_space = rect_in_target_space;
     }
   }
 
   // Tell the layer the rect that it's clipped by. In theory we could use a
   // tighter clip rect here (drawable_content_rect), but that actually does not
   // reduce how much would be drawn, and instead it would create unnecessary
   // changes to scissor state affecting GPU performance. Our clip information
   // is used in the recursion below, so we must set it beforehand.
   layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants;
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.clip_rect = clip_rect_in_target_space;
   } else {
     // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
 
   typename LayerType::LayerListType& descendants =
-      (layer->render_surface() ? layer->render_surface()->layer_list()
-                               : *layer_list);
+      (render_to_separate_surface ? layer->render_surface()->layer_list()
+                                  : *layer_list);
 
   // Any layers that are appended after this point are in the layer's subtree
   // and should be included in the sorting process.
   size_t sorting_start_index = descendants.size();
 
   if (!LayerShouldBeSkipped(layer, layer_is_drawn)) {
     MarkLayerWithRenderSurfaceLayerListId(layer,
                                           current_render_surface_layer_list_id);
     descendants.push_back(layer);
   }
 
   // Any layers that are appended after this point may need to be sorted if we
   // visit the children out of order.
   size_t render_surface_layer_list_child_sorting_start_index =
       render_surface_layer_list->size();
   size_t layer_list_child_sorting_start_index = descendants.size();
 
   if (!layer->children().empty()) {
     if (layer == globals.page_scale_application_layer) {
       data_for_children.parent_matrix.Scale(
           globals.page_scale_factor,
           globals.page_scale_factor);
       data_for_children.in_subtree_of_page_scale_application_layer = true;
     }
     if (layer == globals.elastic_overscroll_application_layer) {
-      data_for_children.parent_matrix.Translate(globals.elastic_overscroll.x(),
-                                                globals.elastic_overscroll.y());
+      data_for_children.parent_matrix.Translate(
+          -globals.elastic_overscroll.x(), -globals.elastic_overscroll.y());
     }
 
     // Flatten to 2D if the layer doesn't preserve 3D.
     if (layer->should_flatten_transform())
       data_for_children.parent_matrix.FlattenTo2d();
 
     data_for_children.scroll_compensation_matrix =
         ComputeScrollCompensationMatrixForChildren(
             layer,
             data_from_ancestor.parent_matrix,
@@ skipping 34 matching lines @@
         render_surface_layer_list->size();
 
     CalculateDrawPropertiesInternal<LayerType>(
         child,
         globals,
         data_for_children,
         render_surface_layer_list,
         &descendants,
         accumulated_surface_state,
         current_render_surface_layer_list_id);
-    if (child->render_surface() &&
+    // If the child is its own render target, then it has a render surface.
+    if (child->render_target() == child &&
         !child->render_surface()->layer_list().empty() &&
         !child->render_surface()->content_rect().IsEmpty()) {
       // This child will contribute its render surface, which means
       // we need to mark just the mask layer (and replica mask layer)
       // with the id.
       MarkMasksWithRenderSurfaceLayerListId(
           child, current_render_surface_layer_list_id);
       descendants.push_back(child);
     }
 
@@ skipping 18 matching lines @@
         *layer,
         &descendants,
         layer_list_child_sorting_start_index,
         &GetNewDescendantsStartIndexAndCount<LayerType>);
   }
 
   // Compute the total drawable_content_rect for this subtree (the rect is in
   // target surface space).
   gfx::Rect local_drawable_content_rect_of_subtree =
       accumulated_surface_state->back().drawable_content_rect;
-  if (layer->render_surface()) {
+  if (render_to_separate_surface) {
     DCHECK(accumulated_surface_state->back().render_target == layer);
     accumulated_surface_state->pop_back();
   }
 
-  if (layer->render_surface() && !IsRootLayer(layer) &&
+  if (render_to_separate_surface && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
   // Compute the layer's drawable content rect (the rect is in target surface
   // space).
   layer_draw_properties.drawable_content_rect = rect_in_target_space;
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.drawable_content_rect.Intersect(
         clip_rect_in_target_space);
   }
   if (layer->DrawsContent()) {
     local_drawable_content_rect_of_subtree.Union(
         layer_draw_properties.drawable_content_rect);
   }
 
   // Compute the layer's visible content rect (the rect is in content space).
   layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
       layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space);
 
   // Compute the remaining properties for the render surface, if the layer has
   // one.
   if (IsRootLayer(layer)) {
     // The root layer's surface's content_rect is always the entire viewport.
-    DCHECK(layer->render_surface());
+    DCHECK(render_to_separate_surface);
     layer->render_surface()->SetContentRect(
         ancestor_clip_rect_in_target_space);
-  } else if (layer->render_surface()) {
+  } else if (render_to_separate_surface) {
     typename LayerType::RenderSurfaceType* render_surface =
         layer->render_surface();
     gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree;
 
     // Don't clip if the layer is reflected as the reflection shouldn't be
     // clipped. If the layer is animating, then the surface's transform to
     // its target is not known on the main thread, and we should not use it
     // to clip.
     if (!layer->replica_layer() && TransformToParentIsKnown(layer)) {
       // Note, it is correct to use data_from_ancestor.ancestor_clips_subtree
@@ skipping 73 matching lines @@
           surface_origin_to_replica_origin_transform;
       render_surface->SetReplicaScreenSpaceTransform(
           replica_screen_space_transform);
     }
   }
 
   SavePaintPropertiesLayer(layer);
 
   // If neither this layer nor any of its children were added, early out.
   if (sorting_start_index == descendants.size()) {
-    DCHECK(!layer->render_surface() || IsRootLayer(layer));
+    DCHECK(!render_to_separate_surface || IsRootLayer(layer));
     return;
   }
 
   // If preserves-3d then sort all the descendants in 3D so that they can be
   // drawn from back to front. If the preserves-3d property is also set on the
   // parent then skip the sorting as the parent will sort all the descendants
   // anyway.
   if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() &&
       !LayerIsInExisting3DRenderingContext(layer)) {
     SortLayers(descendants.begin() + sorting_start_index,
@@ skipping 62 matching lines @@
       device_viewport_rect;
   data_for_recursion->maximum_animation_contents_scale = 0.f;
   data_for_recursion->ancestor_is_animating_scale = false;
   data_for_recursion->ancestor_clips_subtree = true;
   data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL;
   data_for_recursion->in_subtree_of_page_scale_application_layer = false;
   data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text;
   data_for_recursion->subtree_is_visible_from_ancestor = true;
 }
 
+void LayerTreeHostCommon::UpdateRenderSurface(
+    Layer* layer,
+    bool can_render_to_separate_surface,
+    gfx::Transform* transform,
+    bool* draw_transform_is_axis_aligned) {
+  bool preserves_2d_axis_alignment =
+      transform->Preserves2dAxisAlignment() && *draw_transform_is_axis_aligned;
+  if (IsRootLayer(layer) || (can_render_to_separate_surface &&
+                             SubtreeShouldRenderToSeparateSurface(
+                                 layer, preserves_2d_axis_alignment))) {
+    // We reset the transform here so that any axis-changing transforms
+    // will now be relative to this RenderSurface.
+    transform->MakeIdentity();
+    *draw_transform_is_axis_aligned = true;
+    if (!layer->render_surface()) {
+      layer->CreateRenderSurface();
+    }
+    layer->SetHasRenderSurface(true);
+    return;
+  }
+  layer->SetHasRenderSurface(false);
+  if (layer->render_surface())
+    layer->ClearRenderSurface();
+}
+
+void LayerTreeHostCommon::UpdateRenderSurfaces(
+    Layer* layer,
+    bool can_render_to_separate_surface,
+    const gfx::Transform& parent_transform,
+    bool draw_transform_is_axis_aligned) {
+  gfx::Transform transform_for_children = layer->transform();
+  transform_for_children *= parent_transform;
+  draw_transform_is_axis_aligned &= layer->AnimationsPreserveAxisAlignment();
+  UpdateRenderSurface(layer, can_render_to_separate_surface,
+                      &transform_for_children, &draw_transform_is_axis_aligned);
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    UpdateRenderSurfaces(layer->children()[i].get(),
+                         can_render_to_separate_surface, transform_for_children,
+                         draw_transform_is_axis_aligned);
+  }
+}
+
 static bool ApproximatelyEqual(const gfx::Rect& r1, const gfx::Rect& r2) {
   static const int tolerance = 1;
   return std::abs(r1.x() - r2.x()) <= tolerance &&
          std::abs(r1.y() - r2.y()) <= tolerance &&
          std::abs(r1.width() - r2.width()) <= tolerance &&
          std::abs(r1.height() - r2.height()) <= tolerance;
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
+  UpdateRenderSurfaces(inputs->root_layer,
+                       inputs->can_render_to_separate_surface, gfx::Transform(),
+                       false);
   LayerList dummy_layer_list;
   SubtreeGlobals<Layer> globals;
   DataForRecursion<Layer> data_for_recursion;
   ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<Layer>> accumulated_surface_state;
   CalculateDrawPropertiesInternal<Layer>(
       inputs->root_layer,
@@ skipping 64 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