Refactoring the GLRenderer::GetBackgroundWithFilters method.

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 832 matching lines @@
   }
 
   // Flush the GrContext to ensure all buffered GL calls are drawn to the
   // backing store before we access and return it, and have cc begin using the
   // GL context again.
   canvas->flush();
 
   return image;
 }
 
-scoped_ptr<ScopedResource> GLRenderer::GetBackgroundWithFilters(
+bool GLRenderer::ShouldApplyBackgroundFilters(DrawingFrame* frame,
+                                              const RenderPassDrawQuad* quad) {
+  if (quad->background_filters.IsEmpty())
+    return false;
+
+  // TODO(danakj): We only allow background filters on an opaque render surface
+  // because other surfaces may contain translucent pixels, and the contents
+  // behind those translucent pixels wouldn't have the filter applied.
+  if (frame->current_render_pass->has_transparent_background)
+    return false;
+
+  // TODO(ajuma): Add support for reference filters once
+  // FilterOperations::GetOutsets supports reference filters.
+  if (quad->background_filters.HasReferenceFilter())
+    return false;
+  return true;
+}
+
+gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
-    const gfx::Transform& contents_device_transform,
+    const gfx::Transform& contents_device_transform) {
+  gfx::Rect backdrop_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
+      contents_device_transform, SharedGeometryQuad().BoundingBox()));
+
+  if (ShouldApplyBackgroundFilters(frame, quad)) {
+    int top, right, bottom, left;
+    quad->background_filters.GetOutsets(&top, &right, &bottom, &left);
+    backdrop_rect.Inset(-left, -top, -right, -bottom);
+  }
+
+  backdrop_rect.Intersect(
+      MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
+  return backdrop_rect;
+}
+
+scoped_ptr<ScopedResource> GLRenderer::GetBackdropTexture(
+    const gfx::Rect& bounding_rect) {
+  scoped_ptr<ScopedResource> device_background_texture =
+      ScopedResource::Create(resource_provider_);
+  // CopyTexImage2D fails when called on a texture having immutable storage.
+  device_background_texture->Allocate(
+      bounding_rect.size(), ResourceProvider::TextureHintDefault, RGBA_8888);
+  {
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
+                                             device_background_texture->id());
+    GetFramebufferTexture(
+        lock.texture_id(), device_background_texture->format(), bounding_rect);
+  }
+  return device_background_texture.Pass();
+}
+
+skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters(
+    DrawingFrame* frame,
+    const RenderPassDrawQuad* quad,
+    ScopedResource* background_texture) {
+  DCHECK(ShouldApplyBackgroundFilters(frame, quad));
+  skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
+      quad->background_filters, background_texture->size());
+
+  skia::RefPtr<SkImage> background_with_filters =
+      ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
+                       resource_provider_,
+                       quad->rect.origin(),
+                       quad->filters_scale,
+                       filter.get(),
+                       background_texture);
+  return background_with_filters;
+}
+
+scoped_ptr<ScopedResource>
+GLRenderer::ApplyInverseTransformForBackgroundFilters(
+    DrawingFrame* frame,
+    const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform_inverse,
-    bool* background_changed) {
+    ScopedResource* device_background_texture,
+    skia::RefPtr<SkImage> filtered_device_background,
+    const gfx::Rect& backdrop_bounding_rect) {
   // This method draws a background filter, which applies a filter to any pixels
   // behind the quad and seen through its background.  The algorithm works as
   // follows:
-  // 1. Compute a bounding box around the pixels that will be visible through
-  // the quad.
+  // 1. Read the pixels in the bounding box into a buffer.
+  // Moved to GLRenderer::GetBackdropBoundingBoxForRenderPassQuad().
   // 2. Read the pixels in the bounding box into a buffer R.
+  // Moved to GLRenderer::GetBackdropTexture().
   // 3. Apply the background filter to R, so that it is applied in the pixels'
-  // coordinate space.
+  // coordinate space. Moved to GLRenderer::ApplyBackgroundFilters().
   // 4. Apply the quad's inverse transform to map the pixels in R into the
   // quad's content space. This implicitly clips R by the content bounds of the
   // quad since the destination texture has bounds matching the quad's content.
   // 5. Draw the background texture for the contents using the same transform as
   // used to draw the contents itself. This is done without blending to replace
   // the current background pixels with the new filtered background.
   // 6. Draw the contents of the quad over drop of the new background with
   // blending, as per usual. The filtered background pixels will show through
   // any non-opaque pixels in this draws.
   //
   // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
   // TODO(danakj): When this algorithm changes, update
   // LayerTreeHost::PrioritizeTextures() accordingly.
 
-  // TODO(danakj): We only allow background filters on an opaque render surface
-  // because other surfaces may contain translucent pixels, and the contents
-  // behind those translucent pixels wouldn't have the filter applied.
-  bool apply_background_filters =
-      !frame->current_render_pass->has_transparent_background;
-  DCHECK(!frame->current_texture);
-
-  // TODO(ajuma): Add support for reference filters once
-  // FilterOperations::GetOutsets supports reference filters.
-  if (apply_background_filters && quad->background_filters.HasReferenceFilter())
-    apply_background_filters = false;
-
-  // TODO(danakj): Do a single readback for both the surface and replica and
-  // cache the filtered results (once filter textures are not reused).
-  gfx::Rect window_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
-      contents_device_transform, SharedGeometryQuad().BoundingBox()));
-
-  int top, right, bottom, left;
-  quad->background_filters.GetOutsets(&top, &right, &bottom, &left);
-  window_rect.Inset(-left, -top, -right, -bottom);
-
-  window_rect.Intersect(
-      MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
-
-  scoped_ptr<ScopedResource> device_background_texture =
-      ScopedResource::Create(resource_provider_);
-  // CopyTexImage2D fails when called on a texture having immutable storage.
-  device_background_texture->Allocate(
-      window_rect.size(), ResourceProvider::TextureHintDefault, RGBA_8888);
-  {
-    ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
-                                             device_background_texture->id());
-    GetFramebufferTexture(
-        lock.texture_id(), device_background_texture->format(), window_rect);
-  }
-
-  skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-      quad->background_filters, device_background_texture->size());
-
-  skia::RefPtr<SkImage> filtered_device_background;
-  if (apply_background_filters) {
-    filtered_device_background =
-        ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
-                         resource_provider_,
-                         quad->rect.origin(),
-                         quad->filters_scale,
-                         filter.get(),
-                         device_background_texture.get());
-  }
-  *background_changed = (filtered_device_background != NULL);
+  DCHECK(device_background_texture);
 
   int filtered_device_background_texture_id = 0;
   scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
   if (filtered_device_background) {
     GrTexture* texture = filtered_device_background->getTexture();
     filtered_device_background_texture_id = texture->getTextureHandle();
   } else {
     lock.reset(new ResourceProvider::ScopedReadLockGL(
         resource_provider_, device_background_texture->id()));
     filtered_device_background_texture_id = lock->texture_id();
@@ skipping 17 matching lines @@
     QuadRectTransform(
         &device_to_framebuffer_transform, gfx::Transform(), quad->rect);
     device_to_framebuffer_transform.PreconcatTransform(
         contents_device_transform_inverse);
 
 #ifndef NDEBUG
     GLC(gl_, gl_->ClearColor(0, 0, 1, 1));
     gl_->Clear(GL_COLOR_BUFFER_BIT);
 #endif
 
-    // The filtered_deveice_background_texture is oriented the same as the frame
-    // buffer. The transform we are copying with has a vertical flip, as well as
+    // The background_texture is oriented the same as the frame buffer.
+    // The transform we are copying with has a vertical flip, as well as
     // the |device_to_framebuffer_transform|, which cancel each other out. So do
     // not flip the contents in the shader to maintain orientation.
     bool flip_vertically = false;
 
     CopyTextureToFramebuffer(frame,
                              filtered_device_background_texture_id,
-                             window_rect,
+                             backdrop_bounding_rect,
                              device_to_framebuffer_transform,
                              flip_vertically);
   }
 
   UseRenderPass(frame, target_render_pass);
 
   if (!using_background_texture)
     return nullptr;
   return background_texture.Pass();
 }
@@ skipping 14 matching lines @@
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   gfx::Transform contents_device_transform_inverse(
       gfx::Transform::kSkipInitialization);
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return;
 
   bool need_background_texture = !ShouldApplyBlendModeUsingBlendFunc(quad) ||
-                                 !quad->background_filters.IsEmpty();
-  bool background_changed = false;
+                                 ShouldApplyBackgroundFilters(frame, quad);
+
   scoped_ptr<ScopedResource> background_texture;
   if (need_background_texture) {
     // The pixels from the filtered background should completely replace the
     // current pixel values.
     bool disable_blending = blend_enabled();
     if (disable_blending)
       SetBlendEnabled(false);
 
-    background_texture =
-        GetBackgroundWithFilters(frame,
-                                 quad,
-                                 contents_device_transform,
-                                 contents_device_transform_inverse,
-                                 &background_changed);
+    // Compute a bounding box around the pixels that will be visible through
+    // the quad.
+    gfx::Rect backdrop_rect = GetBackdropBoundingBoxForRenderPassQuad(
+        frame, quad, contents_device_transform);
+
+    // Read the pixels in the bounding box into a buffer R.
+    scoped_ptr<ScopedResource> scoped_background_texture =
+        GetBackdropTexture(backdrop_rect);
+
+    skia::RefPtr<SkImage> background_with_filters;
+    if (ShouldApplyBackgroundFilters(frame, quad)) {
+      // Apply the background filters to R, so that it is applied in the pixels'
+      // coordinate space.
+      background_with_filters =
+          ApplyBackgroundFilters(frame, quad, scoped_background_texture.get());
+    }
+    // Apply the quad's inverse transform to map the pixels in R into the
+    // quad's content space. This implicitly clips R by the content bounds of
+    // the quad since the destination texture has bounds matching the quad's
+    // content.
+    background_texture = ApplyInverseTransformForBackgroundFilters(
+        frame,
+        quad,
+        contents_device_transform_inverse,
+        scoped_background_texture.get(),
+        background_with_filters,
+        backdrop_rect);
 
     if (disable_blending)
       SetBlendEnabled(true);
   }
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
   skia::RefPtr<SkImage> filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
@@ skipping 18 matching lines @@
             ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
                              resource_provider_,
                              quad->rect.origin(),
                              quad->filters_scale,
                              filter.get(),
                              contents_texture);
       }
     }
   }
 
+  // If blending is applied using shaders, the background texture with
+  // filters will be used as backdrop for blending operation, so we don't
+  // need to copy it to the frame buffer.
   if (background_texture && !ShouldApplyBlendModeUsingBlendFunc(quad)) {
     filter_bitmap =
         ApplyBlendModeWithBackdrop(ScopedUseGrContext::Create(this, frame),
                                    resource_provider_,
                                    filter_bitmap,
                                    contents_texture,
                                    background_texture.get(),
                                    quad->shared_quad_state->blend_mode);
-  }
-
-  // Draw the background texture if it has some filters applied.
-  if (background_texture && background_changed) {
+  } else if (background_texture) {
+    // Draw the background texture if it has some filters applied.
+    DCHECK(ShouldApplyBackgroundFilters(frame, quad));
     DCHECK(background_texture->size() == quad->rect.size());
     ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                             background_texture->id());
 
     // The background_texture is oriented the same as the frame buffer. The
     // transform we are copying with has a vertical flip, so flip the contents
     // in the shader to maintain orientation
     bool flip_vertically = true;
 
     CopyTextureToFramebuffer(frame,
@@ skipping 2132 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc