cc: Add a pixel test for background blur outsets.

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 <set>
 #include <string>
 #include <vector>
@@ skipping 544 matching lines @@
   // 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.
 
   // FIXME: When this algorithm changes, update
-  // LayerTreeHost::prioritizeTextures() accordingly.
+  // LayerTreeHost::PrioritizeTextures() accordingly.
 
   const WebKit::WebFilterOperations& filters = quad->background_filters;
-  if (filters.isEmpty())
-    return scoped_ptr<ScopedResource>();
+  DCHECK(!filters.isEmpty());
 
   // FIXME: 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 scoped_ptr<ScopedResource>();
   DCHECK(!frame->current_texture);
 
   // FIXME: Do a single readback for both the surface and replica and cache the
   // filtered results (once filter textures are not reused).
@@ skipping 75 matching lines @@
   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.
   gfx::Transform contents_device_transform_inverse(
       gfx::Transform::kSkipInitialization);
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return;
 
-  scoped_ptr<ScopedResource> background_texture =
-      DrawBackgroundFilters(frame,
-                            quad,
-                            contents_device_transform,
-                            contents_device_transform_inverse);
+  scoped_ptr<ScopedResource> background_texture;
+  if (!quad->background_filters.isEmpty()) {
+    // 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 = DrawBackgroundFilters(
+        frame,
+        quad,
+        contents_device_transform,
+        contents_device_transform_inverse);
+
+    if (disable_blending)
+      SetBlendEnabled(true);
+  }
 
   // FIXME: 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.
   SkBitmap filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   if (quad->filter) {
     SkColorFilter* cf;
     if ((quad->filter->asColorFilter(&cf)) && cf->asColorMatrix(color_matrix) &&
         !quad->filter->getInput(0)) {
@@ skipping 1773 matching lines @@
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc