Revert of cc: Make visible rect computation aware of pixel-moving filters

cc/trees/property_tree_builder.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 "cc/trees/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
 
-#include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/mutable_properties.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
@@ skipping 196 matching lines @@
 }
 
 static size_t NumUnclippedDescendants(Layer* layer) {
   return layer->num_unclipped_descendants();
 }
 
 static size_t NumUnclippedDescendants(LayerImpl* layer) {
   return layer->test_properties()->num_unclipped_descendants;
 }
 
-static inline const FilterOperations& Filters(Layer* layer) {
-  return layer->filters();
-}
-
-static inline const FilterOperations& Filters(LayerImpl* layer) {
-  return layer->test_properties()->filters;
-}
-
 static Layer* MaskLayer(Layer* layer) {
   return layer->mask_layer();
 }
 
 static LayerImpl* MaskLayer(LayerImpl* layer) {
   return layer->test_properties()->mask_layer;
 }
 
 static const gfx::Transform& Transform(Layer* layer) {
   return layer->transform();
@@ skipping 184 matching lines @@
       // clipping state from ancestors must continue to get propagated.
       node.layer_clipping_uses_only_local_clip =
           (created_render_surface && NumUnclippedDescendants(layer) == 0) ||
           !ancestor_clips_subtree;
     } else {
       // Otherwise, we're either unclipped, or exist only in order to apply our
       // parent's clips in our space.
       node.layer_clipping_uses_only_local_clip = false;
     }
 
-    if (layer_clips_subtree) {
+    if (layer_clips_subtree)
       node.clip_type = ClipNode::ClipType::APPLIES_LOCAL_CLIP;
-    } else if (Filters(layer).HasFilterThatMovesPixels()) {
-      node.clip_type = ClipNode::ClipType::EXPANDS_CLIP;
-      node.clip_expander =
-          base::MakeUnique<ClipExpander>(layer->effect_tree_index());
-    } else {
+    else
       node.clip_type = ClipNode::ClipType::NONE;
-    }
     node.resets_clip = has_unclipped_surface;
     node.target_is_clipped = data_for_children->target_is_clipped;
     node.layers_are_clipped = layers_are_clipped;
     node.layers_are_clipped_when_surfaces_disabled =
         layers_are_clipped_when_surfaces_disabled;
 
     data_for_children->clip_tree_parent =
         data_for_children->property_trees->clip_tree.Insert(node, parent_id);
     data_for_children->property_trees->clip_id_to_index_map[layer->id()] =
         data_for_children->clip_tree_parent;
@@ skipping 357 matching lines @@
 }
 
 static inline SkXfermode::Mode BlendMode(Layer* layer) {
   return layer->blend_mode();
 }
 
 static inline SkXfermode::Mode BlendMode(LayerImpl* layer) {
   return layer->test_properties()->blend_mode;
 }
 
+static inline const FilterOperations& Filters(Layer* layer) {
+  return layer->filters();
+}
+
 static inline const gfx::PointF FiltersOrigin(Layer* layer) {
   return layer->filters_origin();
 }
 
 static inline const gfx::PointF FiltersOrigin(LayerImpl* layer) {
   return layer->test_properties()->filters_origin;
 }
 
+static inline const FilterOperations& Filters(LayerImpl* layer) {
+  return layer->test_properties()->filters;
+}
+
 static inline const FilterOperations& BackgroundFilters(Layer* layer) {
   return layer->background_filters();
 }
 
 static inline const FilterOperations& BackgroundFilters(LayerImpl* layer) {
   return layer->test_properties()->background_filters;
 }
 
 static inline bool HideLayerAndSubtree(Layer* layer) {
   return layer->hide_layer_and_subtree();
@@ skipping 652 matching lines @@
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc