cc: fix for huge filtered render surfaces.

cc/output/gl_renderer.cc

Index: cc/output/gl_renderer.cc
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 67382c0765fdbda850124277406ad9363786b6e4..215f58a8d2979d05b0fc13ad7502075d045e7b9c 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -862,6 +862,24 @@ skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters(
   return background_with_filters;
 }
 
+// Map device space quad to local space. Device_transform has no 3d
+// component since it was flattened, so we don't need to project.  We should
+// have already checked that the transform was uninvertible before this call.
+gfx::QuadF MapQuadToLocalSpace(const gfx::Transform& device_transform,
+                               const gfx::QuadF& device_quad) {
+  gfx::Transform inverse_device_transform(gfx::Transform::kSkipInitialization);
+  DCHECK(device_transform.IsInvertible());
+  bool did_invert = device_transform.GetInverse(&inverse_device_transform);
+  DCHECK(did_invert);
+  bool clipped = false;
+  gfx::QuadF local_quad =
+      MathUtil::MapQuad(inverse_device_transform, device_quad, &clipped);
+  // We should not DCHECK(!clipped) here, because anti-aliasing inflation may
+  // cause device_quad to become clipped. To our knowledge this scenario does
+  // not need to be handled differently than the unclipped case.
+  return local_quad;
+}
+
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
@@ -986,7 +1004,6 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
         // in the compositor.
         use_color_matrix = true;
       } else {
-        gfx::RectF src_rect = rect;
         gfx::Vector2dF scale = quad->filters_scale;
         SkMatrix scale_matrix;
         scale_matrix.setScale(scale.x(), scale.y());
@@ -994,13 +1011,28 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
         filter->filterBounds(gfx::RectToSkIRect(quad->rect), scale_matrix,
                              &result_rect,
                              SkImageFilter::kForward_MapDirection);
-        rect = gfx::SkRectToRectF(SkRect::Make(result_rect));
+        gfx::RectF dst_rect = gfx::SkRectToRectF(SkRect::Make(result_rect));
+        gfx::Rect clip_rect = quad->shared_quad_state->clip_rect;
+        if (clip_rect.IsEmpty()) {
+          clip_rect = current_draw_rect_;
+        }
+        gfx::Transform transform =
+            quad->shared_quad_state->quad_to_target_transform;
+        gfx::QuadF clip_quad = gfx::QuadF(gfx::RectF(clip_rect));
+        gfx::QuadF local_clip = MapQuadToLocalSpace(transform, clip_quad);
+        dst_rect.Intersect(local_clip.BoundingBox());
+        // If we've been fully clipped out (by crop rect or clipping), there's
+        // nothing to draw.
+        if (dst_rect.IsEmpty()) {
+          return;
+        }
         filter_image = ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
-                                        resource_provider_, src_rect, rect,
+                                        resource_provider_, rect, dst_rect,
                                         scale, filter.get(), contents_texture);
         if (filter_image) {
           filter_image_id = filter_image->getTextureHandle(true);
           DCHECK(filter_image_id);
+          rect = dst_rect;
         }
       }
     }
@@ -1384,24 +1416,6 @@ void AlignQuadToBoundingBox(gfx::QuadF* clipped_quad) {
   *clipped_quad = best_rotation;
 }
 
-// Map device space quad to local space. Device_transform has no 3d
-// component since it was flattened, so we don't need to project.  We should
-// have already checked that the transform was uninvertible before this call.
-gfx::QuadF MapQuadToLocalSpace(const gfx::Transform& device_transform,
-                               const gfx::QuadF& device_quad) {
-  gfx::Transform inverse_device_transform(gfx::Transform::kSkipInitialization);
-  DCHECK(device_transform.IsInvertible());
-  bool did_invert = device_transform.GetInverse(&inverse_device_transform);
-  DCHECK(did_invert);
-  bool clipped = false;
-  gfx::QuadF local_quad =
-      MathUtil::MapQuad(inverse_device_transform, device_quad, &clipped);
-  // We should not DCHECK(!clipped) here, because anti-aliasing inflation may
-  // cause device_quad to become clipped. To our knowledge this scenario does
-  // not need to be handled differently than the unclipped case.
-  return local_quad;
-}
-
 void InflateAntiAliasingDistances(const gfx::QuadF& quad,
                                   LayerQuad* device_layer_edges,
                                   float edge[24]) {