cc: Move filters from RenderPassDrawQuad to RenderPass

cc/output/software_renderer.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/output/software_renderer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 453 matching lines @@
 
   SkRect dest_rect = gfx::RectFToSkRect(QuadVertexRect());
   SkRect dest_visible_rect = gfx::RectFToSkRect(
       MathUtil::ScaleRectProportional(QuadVertexRect(), gfx::RectF(quad->rect),
                                       gfx::RectF(quad->visible_rect)));
   SkRect content_rect = SkRect::MakeWH(quad->rect.width(), quad->rect.height());
 
   const SkBitmap* content = lock.sk_bitmap();
 
   sk_sp<SkImage> filter_image;
-  if (!quad->filters.IsEmpty()) {
-    sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-        quad->filters, gfx::SizeF(content_texture->size()));
-    if (filter) {
+  const FilterOperations* filters = FiltersForPass(quad->render_pass_id);
+  if (filters) {
+    DCHECK(!filters->IsEmpty());
+    sk_sp<SkImageFilter> image_filter = RenderSurfaceFilters::BuildImageFilter(
+        *filters, gfx::SizeF(content_texture->size()));
+    if (image_filter) {
       SkIRect result_rect;
       // TODO(ajuma): Apply the filter in the same pass as the content where
       // possible (e.g. when there's no origin offset). See crbug.com/308201.
       filter_image =
-          ApplyImageFilter(filter.get(), quad, *content, &result_rect);
+          ApplyImageFilter(image_filter.get(), quad, *content, &result_rect);
       if (result_rect.isEmpty()) {
         return;
       }
       if (filter_image) {
         gfx::RectF rect = gfx::SkRectToRectF(SkRect::Make(result_rect));
         dest_rect = dest_visible_rect =
             gfx::RectFToSkRect(MathUtil::ScaleRectProportional(
                 QuadVertexRect(), gfx::RectF(quad->rect), rect));
         content_rect =
             SkRect::MakeWH(result_rect.width(), result_rect.height());
@@ skipping 89 matching lines @@
 }
 
 void SoftwareRenderer::DidChangeVisibility() {
   if (visible_)
     output_surface_->EnsureBackbuffer();
   else
     output_surface_->DiscardBackbuffer();
 }
 
 bool SoftwareRenderer::ShouldApplyBackgroundFilters(
-    const RenderPassDrawQuad* quad) const {
-  if (quad->background_filters.IsEmpty())
+    const RenderPassDrawQuad* quad,
+    const FilterOperations* background_filters) const {
+  if (!background_filters)
     return false;
+  DCHECK(!background_filters->IsEmpty());
 
   // TODO(hendrikw): Look into allowing background filters to see pixels from
   // other render targets.  See crbug.com/314867.
 
   return true;
 }
 
 // If non-null, auto_bounds will be filled with the automatically-computed
 // destination bounds. If null, the output will be the same size as the
 // input bitmap.
@@ skipping 43 matching lines @@
   bitmap.setInfo(SkImageInfo::MakeN32Premul(bounding_rect.width(),
                                             bounding_rect.height()));
   current_canvas_->readPixels(&bitmap, bounding_rect.x(), bounding_rect.y());
   return bitmap;
 }
 
 gfx::Rect SoftwareRenderer::GetBackdropBoundingBoxForRenderPassQuad(
     const DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
+    const FilterOperations* background_filters,
     gfx::Rect* unclipped_rect) const {
-  DCHECK(ShouldApplyBackgroundFilters(quad));
+  DCHECK(ShouldApplyBackgroundFilters(quad, background_filters));
   gfx::Rect backdrop_rect = gfx::ToEnclosingRect(
       MathUtil::MapClippedRect(contents_device_transform, QuadVertexRect()));
 
   SkMatrix matrix;
   matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
-  backdrop_rect =
-      quad->background_filters.MapRectReverse(backdrop_rect, matrix);
+  backdrop_rect = background_filters->MapRectReverse(backdrop_rect, matrix);
 
   *unclipped_rect = backdrop_rect;
   backdrop_rect.Intersect(MoveFromDrawToWindowSpace(
       frame, frame->current_render_pass->output_rect));
 
   return backdrop_rect;
 }
 
 sk_sp<SkShader> SoftwareRenderer::GetBackgroundFilterShader(
     const DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     SkShader::TileMode content_tile_mode) const {
-  if (!ShouldApplyBackgroundFilters(quad))
+  const FilterOperations* background_filters =
+      BackgroundFiltersForPass(quad->render_pass_id);
+  if (!ShouldApplyBackgroundFilters(quad, background_filters))
     return nullptr;
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
                     gfx::RectF(quad->rect));
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   gfx::Rect unclipped_rect;
   gfx::Rect backdrop_rect = GetBackdropBoundingBoxForRenderPassQuad(
-      frame, quad, contents_device_transform, &unclipped_rect);
+      frame, quad, contents_device_transform, background_filters,
+      &unclipped_rect);
 
   // Figure out the transformations to move it back to pixel space.
   gfx::Transform contents_device_transform_inverse;
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return nullptr;
 
   SkMatrix filter_backdrop_transform =
       contents_device_transform_inverse.matrix();
   filter_backdrop_transform.preTranslate(backdrop_rect.x(), backdrop_rect.y());
 
   // Draw what's behind, and apply the filter to it.
   SkBitmap backdrop_bitmap = GetBackdropBitmap(backdrop_rect);
 
   gfx::Vector2dF clipping_offset =
       (unclipped_rect.top_right() - backdrop_rect.top_right()) +
       (backdrop_rect.bottom_left() - unclipped_rect.bottom_left());
   sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-      quad->background_filters,
+      *background_filters,
       gfx::SizeF(backdrop_bitmap.width(), backdrop_bitmap.height()),
       clipping_offset);
   sk_sp<SkImage> filter_backdrop_image =
       ApplyImageFilter(filter.get(), quad, backdrop_bitmap, nullptr);
 
   if (!filter_backdrop_image)
     return nullptr;
 
   return filter_backdrop_image->makeShader(content_tile_mode, content_tile_mode,
                                            &filter_backdrop_transform);
 }
 
 }  // namespace cc