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

cc/layers/render_surface_impl.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/layers/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 172 matching lines @@
     return;
 
   surface_property_changed_ = true;
   draw_properties_.content_rect = content_rect;
 }
 
 void RenderSurfaceImpl::SetContentRectForTesting(const gfx::Rect& rect) {
   SetContentRect(rect);
 }
 
+gfx::Rect RenderSurfaceImpl::CalculateExpandedClipForFilters(
+    const gfx::Transform& target_to_surface) {
+  gfx::Rect clip_in_surface_space =
+      MathUtil::ProjectEnclosingClippedRect(target_to_surface, clip_rect());
+  gfx::Rect expanded_clip_in_surface_space = Filters().MapRectReverse(
+      clip_in_surface_space, FiltersTransform().matrix());
+  gfx::Rect expanded_clip_in_target_space = MathUtil::MapEnclosingClippedRect(
+      draw_transform(), expanded_clip_in_surface_space);
+  return expanded_clip_in_target_space;
+}
+
 gfx::Rect RenderSurfaceImpl::CalculateClippedAccumulatedContentRect() {
   if (HasCopyRequest() || !is_clipped())
     return accumulated_content_rect();
 
   if (accumulated_content_rect().IsEmpty())
     return gfx::Rect();
 
   // Calculate projection from the target surface rect to local
   // space. Non-invertible draw transforms means no able to bring clipped rect
   // in target space back to local space, early out without clip.
   gfx::Transform target_to_surface(gfx::Transform::kSkipInitialization);
   if (!draw_transform().GetInverse(&target_to_surface))
     return accumulated_content_rect();
 
   // Clip rect is in target space. Bring accumulated content rect to
   // target space in preparation for clipping.
   gfx::Rect accumulated_rect_in_target_space =
       MathUtil::MapEnclosingClippedRect(draw_transform(),
                                         accumulated_content_rect());
   // If accumulated content rect is contained within clip rect, early out
   // without clipping.
   if (clip_rect().Contains(accumulated_rect_in_target_space))
     return accumulated_content_rect();
 
-  gfx::Rect clipped_accumulated_rect_in_target_space = clip_rect();
+  gfx::Rect clipped_accumulated_rect_in_target_space;
+  if (Filters().HasFilterThatMovesPixels()) {
+    clipped_accumulated_rect_in_target_space =
+        CalculateExpandedClipForFilters(target_to_surface);
+  } else {
+    clipped_accumulated_rect_in_target_space = clip_rect();
+  }
   clipped_accumulated_rect_in_target_space.Intersect(
       accumulated_rect_in_target_space);
 
   if (clipped_accumulated_rect_in_target_space.IsEmpty())
     return gfx::Rect();
 
   gfx::Rect clipped_accumulated_rect_in_local_space =
       MathUtil::ProjectEnclosingClippedRect(
           target_to_surface, clipped_accumulated_rect_in_target_space);
   // Bringing clipped accumulated rect back to local space may result
@@ skipping 172 matching lines @@
 
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
                render_pass_id, mask_resource_id, mask_uv_scale,
                mask_texture_size, Filters(), owning_layer_to_target_scale,
                FiltersOrigin(), BackgroundFilters());
 }
 
 }  // namespace cc