Enable general CSS filters in the software compositor

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 419 matching lines @@
                             SkMatrix::kFill_ScaleToFit);
 
   const SkBitmap* content = lock.sk_bitmap();
   skia::RefPtr<SkShader> shader = skia::AdoptRef(
       SkShader::CreateBitmapShader(*content,
                                    SkShader::kClamp_TileMode,
                                    SkShader::kClamp_TileMode));
   shader->setLocalMatrix(content_mat);
   current_paint_.setShader(shader.get());
 
-  // TODO(ajuma): Remove this condition once general CSS filters are working
-  // correctly (http://crbug.com/160302), and add corresponding pixel tests.
-  if (quad->filters.HasReferenceFilter()) {
+  if (!quad->filters.IsEmpty()) {
     skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, content_texture->size());
+    // TODO(ajuma): Pass the quad's rect origin when applying the filter.

[ajuma, 2013/09/11 15:59:45]

This is why ImageFilterClipped pixel test doesn't pass with the software
renderer. We need something analogous to
https://chromiumcodereview.appspot.com/23060011. Thoughts on how to approach
this? 

[Stephen White, 2013/09/11 16:48:06]

It should just be a matter of getting the correct origin from
quad->rect.origin(), and applying that as a transform in current_canvas_. This
may require changing the draw call below from a drawRect() to a drawSprite(),
however, since we want the CTM to apply to the filter, but not to the
primitive's position. I suppose we could do a special case for filters here, and
early out. That would skip the mask code below, but I'm not sure filters + mask
does the correct thing in the existing code anyway -- TBD. The other option
would be to do a drawSprite() with only the filter applied, and then use the
resulting bitmap for the drawRect() call below. Then we could handle masks
correctly, I think.

[slavi, 2013/09/13 18:53:20]

AFAIK (I wrote the code) masks + filters do work correctly together with the
current code. I think there might be a layout test or two testing that.

[ajuma, 2013/10/15 19:36:20]

Done.

     if (filter)
       current_paint_.setImageFilter(filter.get());
   }
 
   if (quad->mask_resource_id) {
     ResourceProvider::ScopedReadLockSoftware mask_lock(resource_provider_,
                                                        quad->mask_resource_id);
 
     const SkBitmap* mask = mask_lock.sk_bitmap();
 
@@ skipping 99 matching lines @@
     EnsureBackbuffer();
   else
     DiscardBackbuffer();
 }
 
 void SoftwareRenderer::SetDiscardBackBufferWhenNotVisible(bool discard) {
   // The software renderer always discards the backbuffer when not visible.
 }
 
 }  // namespace cc