cc: Move filters from RenderPassDrawQuad to RenderPass

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 149 matching lines @@
   ~DrawRenderPassDrawQuadParams() {}
 
   // Required Inputs.
   const RenderPassDrawQuad* quad = nullptr;
   const Resource* contents_texture = nullptr;
   const gfx::QuadF* clip_region = nullptr;
   bool flip_texture = false;
   gfx::Transform window_matrix;
   gfx::Transform projection_matrix;
   gfx::Transform quad_to_target_transform;
+  const FilterOperations* filters = nullptr;
+  const FilterOperations* background_filters = nullptr;
 
   // |frame| is only used for background effects.
   DirectRenderer::DrawingFrame* frame = nullptr;
 
   // Whether the texture to be sampled from needs to be flipped.
   bool source_needs_flip = false;
 
   float edge[24];
   SkScalar color_matrix[20];
 
@@ skipping 605 matching lines @@
   if (blend_mode == SkBlendMode::kSrcOver)
     return;
 
   if (use_blend_equation_advanced_) {
     gl_->BlendEquation(GL_FUNC_ADD);
   } else {
     gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
   }
 }
 
-bool GLRenderer::ShouldApplyBackgroundFilters(const RenderPassDrawQuad* quad) {
-  if (quad->background_filters.IsEmpty())
+bool GLRenderer::ShouldApplyBackgroundFilters(
+    const RenderPassDrawQuad* quad,
+    const FilterOperations* background_filters) {
+  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;
 }
 
 // This takes a gfx::Rect and a clip region quad in the same space,
 // and returns a quad with the same proportions in the space -0.5->0.5.
 bool GetScaledRegion(const gfx::Rect& rect,
@@ skipping 28 matching lines @@
   uvs[5] = ((clip->p3().y() - rect.y()) / rect.height());
   uvs[6] = ((clip->p4().x() - rect.x()) / rect.width());
   uvs[7] = ((clip->p4().y() - rect.y()) / rect.height());
   return true;
 }
 
 gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
+    const FilterOperations* filters,
+    const FilterOperations* background_filters,
     const gfx::QuadF* clip_region,
     bool use_aa,
     gfx::Rect* unclipped_rect) {
   gfx::QuadF scaled_region;
   if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {
     scaled_region = SharedGeometryQuad().BoundingBox();
   }
 
   gfx::Rect backdrop_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, scaled_region.BoundingBox()));
 
-  if (ShouldApplyBackgroundFilters(quad)) {
+  if (ShouldApplyBackgroundFilters(quad, background_filters)) {
     SkMatrix matrix;
     matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
     if (FlippedFramebuffer(frame)) {
       // TODO(jbroman): This probably isn't the right way to account for this.
       // Probably some combination of frame->projection_matrix,
       // frame->window_matrix and contents_device_transform?
       matrix.postScale(1, -1);
     }
-    backdrop_rect =
-        quad->background_filters.MapRectReverse(backdrop_rect, matrix);
+    backdrop_rect = background_filters->MapRectReverse(backdrop_rect, matrix);
   }
 
   if (!backdrop_rect.IsEmpty() && use_aa) {
     const int kOutsetForAntialiasing = 1;
     backdrop_rect.Inset(-kOutsetForAntialiasing, -kOutsetForAntialiasing);
   }
 
-  if (!quad->filters.IsEmpty()) {
+  if (filters) {
+    DCHECK(!filters->IsEmpty());
     // If we have filters, grab an extra one-pixel border around the
     // background, so texture edge clamping gives us a transparent border
     // in case the filter expands the result.
     backdrop_rect.Inset(-1, -1, -1, -1);
   }
 
   *unclipped_rect = backdrop_rect;
   backdrop_rect.Intersect(MoveFromDrawToWindowSpace(
       frame, frame->current_render_pass->output_rect));
   return backdrop_rect;
@@ skipping 11 matching lines @@
   {
     ResourceProvider::ScopedWriteLockGL lock(
         resource_provider_, device_background_texture->id(), false);
     GetFramebufferTexture(lock.texture_id(), bounding_rect);
   }
   return device_background_texture;
 }
 
 sk_sp<SkImage> GLRenderer::ApplyBackgroundFilters(
     const RenderPassDrawQuad* quad,
+    const FilterOperations* background_filters,

[danakj, 2016/12/01 01:50:46]

if this can't be null maybe pass it by const& to here already

[weiliangc, 2016/12/01 19:04:31]

So it's every RP always have filters, but most times are empty v.s. RP only has
filters when they are not empty?

[danakj, 2016/12/01 21:14:34]

No we don't call this function if it was null (we deref it on 925).

[ajuma, 2016/12/13 15:08:11]

Done.

     ScopedResource* background_texture,
     const gfx::RectF& rect,
     const gfx::RectF& unclipped_rect) {
-  DCHECK(ShouldApplyBackgroundFilters(quad));
+  DCHECK(ShouldApplyBackgroundFilters(quad, background_filters));
   auto use_gr_context = ScopedUseGrContext::Create(this);
 
   gfx::Vector2dF clipping_offset =
       (rect.top_right() - unclipped_rect.top_right()) +
       (rect.bottom_left() - unclipped_rect.bottom_left());
   sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-      quad->background_filters, gfx::SizeF(background_texture->size()),
+      *background_filters, gfx::SizeF(background_texture->size()),
       clipping_offset);
 
   // TODO(senorblanco): background filters should be moved to the
   // makeWithFilter fast-path, and go back to calling ApplyImageFilter().
   // See http://crbug.com/613233.
   if (!filter || !use_gr_context)
     return nullptr;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           background_texture->id());
@@ skipping 153 matching lines @@
   UpdateRPDQUniforms(params);
   DrawRPDQ(*params);
 }
 
 bool GLRenderer::InitializeRPDQParameters(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   SkMatrix local_matrix;
   local_matrix.setTranslate(quad->filters_origin.x(), quad->filters_origin.y());
   local_matrix.postScale(quad->filters_scale.x(), quad->filters_scale.y());
-  gfx::Rect dst_rect = quad->filters.MapRect(quad->rect, local_matrix);
+  params->filters = FiltersForPass(quad->render_pass_id);
+  params->background_filters = BackgroundFiltersForPass(quad->render_pass_id);
+  gfx::Rect dst_rect = params->filters
+                           ? params->filters->MapRect(quad->rect, local_matrix)
+                           : quad->rect;
   params->dst_rect.SetRect(static_cast<float>(dst_rect.x()),
                            static_cast<float>(dst_rect.y()),
                            static_cast<float>(dst_rect.width()),
                            static_cast<float>(dst_rect.height()));
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, params->quad_to_target_transform,
                     params->dst_rect);
   params->contents_device_transform =
       params->window_matrix * params->projection_matrix * quad_rect_matrix;
   params->contents_device_transform.FlattenTo2d();
@@ skipping 20 matching lines @@
 
   return true;
 }
 
 void GLRenderer::UpdateRPDQShadersForBlending(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   SkBlendMode blend_mode = quad->shared_quad_state->blend_mode;
   params->use_shaders_for_blending =
       !CanApplyBlendModeUsingBlendFunc(blend_mode) ||
-      ShouldApplyBackgroundFilters(quad) ||
+      ShouldApplyBackgroundFilters(quad, params->background_filters) ||
       settings_->force_blending_with_shaders;
 
   if (params->use_shaders_for_blending) {
     DCHECK(params->frame);
     // Compute a bounding box around the pixels that will be visible through
     // the quad.
     gfx::Rect unclipped_rect;
     params->background_rect = GetBackdropBoundingBoxForRenderPassQuad(
-        params->frame, quad, params->contents_device_transform,
-        params->clip_region, params->use_aa, &unclipped_rect);
+        params->frame, quad, params->contents_device_transform, params->filters,
+        params->background_filters, params->clip_region, params->use_aa,
+        &unclipped_rect);
 
     if (!params->background_rect.IsEmpty()) {
       // The pixels from the filtered background should completely replace the
       // current pixel values.
       if (blend_enabled())
         SetBlendEnabled(false);
 
       // Read the pixels in the bounding box into a buffer R.
       // This function allocates a texture, which should contribute to the
       // amount of memory used by render surfaces:
       // LayerTreeHost::CalculateMemoryForRenderSurfaces.
       params->background_texture =
           GetBackdropTexture(params->frame, params->background_rect);
 
-      if (ShouldApplyBackgroundFilters(quad) && params->background_texture) {
+      if (ShouldApplyBackgroundFilters(quad, params->background_filters) &&
+          params->background_texture) {
         // Apply the background filters to R, so that it is applied in the
         // pixels' coordinate space.
         params->background_image = ApplyBackgroundFilters(
-            quad, params->background_texture.get(),
+            quad, params->background_filters, params->background_texture.get(),
             gfx::RectF(params->background_rect), gfx::RectF(unclipped_rect));
         if (params->background_image) {
           params->background_image_id =
               skia::GrBackendObjectToGrGLTextureInfo(
                   params->background_image->getTextureHandle(true))
                   ->fID;
           DCHECK(params->background_image_id);
         }
       }
     }
 
     if (!params->background_texture) {
       // Something went wrong with reading the backdrop.
       DCHECK(!params->background_image_id);
       params->use_shaders_for_blending = false;
     } else if (params->background_image_id) {
       // Reset original background texture if there is not any mask
       if (!quad->mask_resource_id())
         params->background_texture.reset();
     } else if (CanApplyBlendModeUsingBlendFunc(blend_mode) &&
-               ShouldApplyBackgroundFilters(quad)) {
+               ShouldApplyBackgroundFilters(quad, params->background_filters)) {
       // Something went wrong with applying background filters to the backdrop.
       params->use_shaders_for_blending = false;
       params->background_texture.reset();
     }
   }
   // Need original background texture for mask?
   params->mask_for_background =
       params->background_texture &&   // Have original background texture
       params->background_image_id &&  // Have filtered background texture
       quad->mask_resource_id();       // Have mask texture
   DCHECK_EQ(params->background_texture || params->background_image_id,
             params->use_shaders_for_blending);
 }
 
 bool GLRenderer::UpdateRPDQWithSkiaFilters(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   // Apply filters to the contents texture.
-  if (!quad->filters.IsEmpty()) {
+  if (params->filters) {
+    DCHECK(!params->filters->IsEmpty());
     sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-        quad->filters, gfx::SizeF(params->contents_texture->size()));
+        *params->filters, gfx::SizeF(params->contents_texture->size()));
     if (filter) {
       SkColorFilter* colorfilter_rawptr = NULL;
       filter->asColorFilter(&colorfilter_rawptr);
       sk_sp<SkColorFilter> cf(colorfilter_rawptr);
 
       if (cf && cf->asColorMatrix(params->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.
         params->use_color_matrix = true;
@@ skipping 2841 matching lines @@
   // The alpha has already been applied when copying the RPDQ to an IOSurface.
   GLfloat alpha = 1;
   gl_->ScheduleCALayerSharedStateCHROMIUM(alpha, is_clipped, clip_rect,
                                           sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc