cc: correctly fix edge-AA for filtered render surfaces.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 881 matching lines @@
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   ScopedResource* contents_texture =
       render_pass_textures_[quad->render_pass_id].get();
   DCHECK(contents_texture);
   DCHECK(contents_texture->id());
 
+  SkMatrix scale_matrix;
+  scale_matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
+  gfx::RectF dst_rect(quad->filters.MapRect(quad->rect, scale_matrix));
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
-                    gfx::RectF(quad->rect));
+                    dst_rect);
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   if (!contents_device_transform.IsInvertible())
     return;
 
   gfx::QuadF surface_quad = SharedGeometryQuad();
 
@@ skipping 93 matching lines @@
       sk_sp<SkColorFilter> cf(colorfilter_rawptr);
 
       if (cf && cf->asColorMatrix(color_matrix)) {
         // We have a color matrix at the root of the filter DAG; apply it
         // locally in the compositor and process the rest of the DAG (if any)
         // in Skia.
         use_color_matrix = true;
         filter = sk_ref_sp(filter->getInput(0));
       }
       if (filter) {
-        gfx::Vector2dF scale = quad->filters_scale;
-        SkMatrix scale_matrix;
-        scale_matrix.setScale(scale.x(), scale.y());
-        SkIRect result_rect =
-            filter->filterBounds(gfx::RectToSkIRect(quad->rect), scale_matrix,
-                                 SkImageFilter::kForward_MapDirection);
-        gfx::RectF dst_rect = gfx::SkRectToRectF(SkRect::Make(result_rect));
-        // If the destination rect is not the same as the source rect, the edges
-        // previously computed for AA will be wrong. Rather than recompute them
-        // here, disable antialiasing and use a 1-pixel transparent
-        // border to achieve a similar effect.
-        if (use_aa && dst_rect != rect) {
-          dst_rect.Inset(-1.0f, -1.0f);
-          use_aa = false;
-        }
         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;
         }
         // Expand dst_rect size to the nearest power of 2, in order to get
         // more cache hits in Skia's texture cache.
         RoundUpToPow2(&dst_rect);
         filter_image = ApplyImageFilter(
             ScopedUseGrContext::Create(this, frame), resource_provider_, rect,
-            dst_rect, scale, std::move(filter), contents_texture);
-        if (filter_image) {
-          filter_image_id = skia::GrBackendObjectToGrGLTextureInfo(
-                                filter_image->getTextureHandle(true))
-                                ->fID;
-          DCHECK(filter_image_id);
-          rect = dst_rect;
+            dst_rect, quad->filters_scale, std::move(filter), contents_texture);
+        if (!filter_image) {
+          return;
         }
+        filter_image_id = skia::GrBackendObjectToGrGLTextureInfo(
+                              filter_image->getTextureHandle(true))
+                              ->fID;
+        DCHECK(filter_image_id);
       }
     }
   }
 
   std::unique_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
   SamplerType mask_sampler = SAMPLER_TYPE_NA;
   if (quad->mask_resource_id()) {
     mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(
         resource_provider_, quad->mask_resource_id(), GL_TEXTURE1, GL_LINEAR));
@@ skipping 198 matching lines @@
               resource_provider_, background_texture->id(),
               GL_TEXTURE0 + last_texture_unit, GL_LINEAR));
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 shader_background_sampler_lock->target());
     }
   }
 
   SetShaderOpacity(quad->shared_quad_state->opacity, locations.alpha);
   SetShaderQuadF(surface_quad, locations.quad);
   DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
-                   rect, locations.matrix);
+                   dst_rect, locations.matrix);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (filter_image_id)
     gl_->Flush();
 
   if (!use_shaders_for_blending)
     RestoreBlendFuncToDefault(blend_mode);
 }
 
@@ skipping 2374 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc