Move implementation of WebFilterOperations into cc

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
@@ skipping 211 matching lines @@
 
   RenderSurfaceType* surface = finished_target->render_surface();
 
   // If the occlusion within the surface can not be applied to things outside of
   // the surface's subtree, then clear the occlusion here so it won't be used.
   // TODO(senorblanco):  Make this smarter for SkImageFilter case:  once
   // SkImageFilters can report affectsOpacity(), call that.
   if (finished_target->mask_layer() ||
       !SurfaceOpacityKnown(surface) ||
       surface->draw_opacity() < 1 ||
-      finished_target->filters().hasFilterThatAffectsOpacity() ||
+      finished_target->filters().HasFilterThatAffectsOpacity() ||
       finished_target->filter()) {
     stack_.back().occlusion_from_outside_target.Clear();
     stack_.back().occlusion_from_inside_target.Clear();
   } else if (!SurfaceTransformsToTargetKnown(surface)) {
     stack_.back().occlusion_from_inside_target.Clear();
     stack_.back().occlusion_from_outside_target.Clear();
   }
 }
 
 template <typename LayerType>
 static void ReduceOcclusionBelowSurface(LayerType* contributing_layer,
                                         gfx::Rect surface_rect,
                                         const gfx::Transform& surface_transform,
                                         LayerType* render_target,
                                         Region* occlusion_from_inside_target) {
   if (surface_rect.IsEmpty())
     return;
 
   gfx::Rect affected_area_in_target = gfx::ToEnclosingRect(
       MathUtil::MapClippedRect(surface_transform, gfx::RectF(surface_rect)));
   if (contributing_layer->render_surface()->is_clipped()) {
     affected_area_in_target.Intersect(
         contributing_layer->render_surface()->clip_rect());
   }
   if (affected_area_in_target.IsEmpty())
     return;
 
   int outset_top, outset_right, outset_bottom, outset_left;
-  contributing_layer->background_filters().getOutsets(
-      outset_top, outset_right, outset_bottom, outset_left);
+  contributing_layer->background_filters().GetOutsets(
+      &outset_top, &outset_right, &outset_bottom, &outset_left);
 
   // The filter can move pixels from outside of the clip, so allow affected_area
   // to expand outside the clip.
   affected_area_in_target.Inset(
       -outset_left, -outset_top, -outset_right, -outset_bottom);
 
   gfx::Rect FilterOutsetsInTarget(-outset_left,
                                   -outset_top,
                                   outset_left + outset_right,
                                   outset_top + outset_bottom);
@@ skipping 58 matching lines @@
 
   Region old_occlusion_from_outside_target_in_new_target =
       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
           stack_[last_index].occlusion_from_outside_target,
           false,
           gfx::Rect(),
           old_surface->draw_transform());
 
   gfx::Rect unoccluded_surface_rect;
   gfx::Rect unoccluded_replica_rect;
-  if (old_target->background_filters().hasFilterThatMovesPixels()) {
+  if (old_target->background_filters().HasFilterThatMovesPixels()) {
     unoccluded_surface_rect = UnoccludedContributingSurfaceContentRect(
         old_target, false, old_surface->content_rect(), NULL);
     if (old_target->has_replica()) {
       unoccluded_replica_rect = UnoccludedContributingSurfaceContentRect(
           old_target, true, old_surface->content_rect(), NULL);
     }
   }
 
   if (surface_will_be_at_top_after_pop) {
     // Merge the top of the stack down.
@@ skipping 12 matching lines @@
     stack_.back().occlusion_from_inside_target =
         old_occlusion_from_inside_target_in_new_target;
     if (new_target->parent()) {
       stack_.back().occlusion_from_outside_target =
           old_occlusion_from_outside_target_in_new_target;
     } else {
       stack_.back().occlusion_from_outside_target.Clear();
     }
   }
 
-  if (!old_target->background_filters().hasFilterThatMovesPixels())
+  if (!old_target->background_filters().HasFilterThatMovesPixels())
     return;
 
   ReduceOcclusionBelowSurface(old_target,
                               unoccluded_surface_rect,
                               old_surface->draw_transform(),
                               new_target,
                               &stack_.back().occlusion_from_inside_target);
   ReduceOcclusionBelowSurface(old_target,
                               unoccluded_surface_rect,
                               old_surface->draw_transform(),
@@ skipping 343 matching lines @@
   }
 
   return unoccluded_rect;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc