Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

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 143 matching lines @@
     // Ensure that this translation is truly 2d.
     DCHECK(trans.IsIdentityOrTranslation());
     DCHECK_EQ(0.f, trans.matrix().get(2, 3));
     translation += trans.To2dTranslation();
   }
 
   return translation;
 }
 
 enum TranslateRectDirection {
-  TRANSLATE_RECT_DIRECTION_TO_ANCESTOR,
-  TRANSLATE_RECT_DIRECTION_TO_DESCENDANT
+  TranslateRectDirectionToAncestor,
+  TranslateRectDirectionToDescendant
 };
 
 template <typename LayerType>
 static gfx::Rect TranslateRectToTargetSpace(const LayerType& ancestor_layer,
                                             const LayerType& descendant_layer,
                                             const gfx::Rect& rect,
                                             TranslateRectDirection direction) {
   gfx::Vector2dF translation = ComputeChangeOfBasisTranslation<LayerType>(
       ancestor_layer, descendant_layer);
-  if (direction == TRANSLATE_RECT_DIRECTION_TO_DESCENDANT)
+  if (direction == TranslateRectDirectionToDescendant)
     translation.Scale(-1.f);
   return gfx::ToEnclosingRect(
       gfx::RectF(rect.origin() + translation, rect.size()));
 }
 
 // Attempts to update the clip rects for the given layer. If the layer has a
 // clip_parent, it may not inherit its immediate ancestor's clip.
 template <typename LayerType>
 static void UpdateClipRectsForClipChild(
     const LayerType* layer,
@@ skipping 18 matching lines @@
   *subtree_should_be_clipped = clip_parent->is_clipped();
 
   // We may have to project the clip rect into our parent's target space. Note,
   // it must be our parent's target space, not ours. For one, we haven't
   // computed our transforms, so we couldn't put it in our space yet even if we
   // wanted to. But more importantly, this matches the expectations of
   // CalculateDrawPropertiesInternal. If we, say, create a render surface, these
   // clip rects will want to be in its target space, not ours.
   if (clip_parent == layer->clip_parent()) {
     *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>(
-        *clip_parent, *layer->parent(), *clip_rect_in_parent_target_space,
-        TRANSLATE_RECT_DIRECTION_TO_DESCENDANT);
+        *clip_parent,
+        *layer->parent(),
+        *clip_rect_in_parent_target_space,
+        TranslateRectDirectionToDescendant);
   } else {
     // If we're being clipped by our scroll parent, we must translate through
     // our common ancestor. This happens to be our parent, so it is sufficent to
     // translate from our clip parent's space to the space of its ancestor (our
     // parent).
-    *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>(
-        *layer->parent(), *clip_parent, *clip_rect_in_parent_target_space,
-        TRANSLATE_RECT_DIRECTION_TO_ANCESTOR);
+    *clip_rect_in_parent_target_space =
+        TranslateRectToTargetSpace<LayerType>(*layer->parent(),
+                                              *clip_parent,
+                                              *clip_rect_in_parent_target_space,
+                                              TranslateRectDirectionToAncestor);
   }
 }
 
 // We collect an accumulated drawable content rect per render surface.
 // Typically, a layer will contribute to only one surface, the surface
 // associated with its render target. Clip children, however, may affect
 // several surfaces since there may be several surfaces between the clip child
 // and its parent.
 //
 // NB: we accumulate the layer's *clipped* drawable content rect.
@@ skipping 41 matching lines @@
     target_rect =
         gfx::ToEnclosedRect(layer->render_surface()->DrawableContentRect());
   }
 
   if (render_target->is_clipped()) {
     gfx::Rect clip_rect = render_target->clip_rect();
     // If the layer has a clip parent, the clip rect may be in the wrong space,
     // so we'll need to transform it before it is applied.
     if (layer->clip_parent()) {
       clip_rect = TranslateRectToTargetSpace<LayerType>(
-          *layer->clip_parent(), *layer, clip_rect,
-          TRANSLATE_RECT_DIRECTION_TO_DESCENDANT);
+          *layer->clip_parent(),
+          *layer,
+          clip_rect,
+          TranslateRectDirectionToDescendant);
     }
     target_rect.Intersect(clip_rect);
   }
 
   // We must have at least one entry in the vector for the root.
   DCHECK_LT(0ul, accumulated_surface_state->size());
 
   typedef typename std::vector<AccumulatedSurfaceState<LayerType>>
       AccumulatedSurfaceStateVector;
   typedef typename AccumulatedSurfaceStateVector::reverse_iterator
@@ skipping 893 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) {
-  // This test verifies that there are no cases where a LayerImpl needs
-  // a render surface, but doesn't have one.
-  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;
   }
 
   if (layer->clip_parent())
@@ skipping 1336 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