Pass the quad's rect (contents_rect) origin to skia image filters as an offset in the CTM.

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 475 matching lines @@
   // texture.
   renderer->resource_provider()->Flush();
 
   // Make sure skia uses the correct GL context.
   offscreen_contexts->Context3d()->makeContextCurrent();
 
   // Lazily label this context.
   renderer->LazyLabelOffscreenContext(offscreen_contexts);
 
   SkBitmap source =
       RenderSurfaceFilters::Apply(filters,

[danakj, 2013/08/28 22:26:58]

Will this path do the right thing already? Are there just no filter operations
that depend on knowing the origin of the filter?

[Stephen White, 2013/08/29 00:36:34]

No, there are none. There are no crop rects in filter operations, and all the
filter parameters are translation-independent.

                                   lock.texture_id(),
                                   source_texture_resource->size(),
                                   offscreen_contexts->GrContext());
 
   // Flush skia context so that all the rendered stuff appears on the
   // texture.
   offscreen_contexts->GrContext()->flush();
 
   // Flush the GL context so rendering results from this context are
   // visible in the compositor's context.
   offscreen_contexts->Context3d()->flush();
 
   // Use the compositor's GL context again.
   renderer->Context()->makeContextCurrent();
   return source;
 }
 
 static SkBitmap ApplyImageFilter(GLRenderer* renderer,
                                  ContextProvider* offscreen_contexts,
+                                 gfx::Point origin,
                                  SkImageFilter* filter,
                                  ScopedResource* source_texture_resource) {
   if (!filter)
     return SkBitmap();
 
   if (!offscreen_contexts || !offscreen_contexts->GrContext())
     return SkBitmap();
 
   ResourceProvider::ScopedWriteLockGL lock(renderer->resource_provider(),
                                            source_texture_resource->id());
@@ skipping 44 matching lines @@
       skia::AdoptRef(scratch_texture.detach());
 
   // Create a device and canvas using that backing store.
   SkGpuDevice device(offscreen_contexts->GrContext(), backing_store.get());
   SkCanvas canvas(&device);
 
   // Draw the source bitmap through the filter to the canvas.
   SkPaint paint;
   paint.setImageFilter(filter);
   canvas.clear(SK_ColorTRANSPARENT);
+  canvas.translate(SkFloatToScalar(-origin.x()), SkFloatToScalar(-origin.y()));

[danakj, 2013/08/28 22:26:58]

nit: I think you want SkIntToScalar?

[Stephen White, 2013/08/29 00:36:34]

Done. Thanks!

   canvas.drawSprite(source, 0, 0, &paint);

[danakj, 2013/08/28 22:26:58]

Could you just pass the origin here instead of 0,0 and do the same thing?

[Stephen White, 2013/08/29 00:36:34]

Nope. We're drawing the bitmap in the correct place, it's just the filter
parameters we want to affect. If we applied the origin here, the bitmap would be
offset.

 
   // Flush skia context so that all the rendered stuff appears on the
   // texture.
   offscreen_contexts->GrContext()->flush();
 
   // Flush the GL context so rendering results from this context are
   // visible in the compositor's context.
   offscreen_contexts->Context3d()->flush();
 
   // Use the compositor's GL context again.
@@ skipping 180 matching lines @@
       cf = skia::AdoptRef(colorfilter_rawptr);
     }
 
     if (cf && cf->asColorMatrix(color_matrix) && !quad->filter->getInput(0)) {
       // We have a single color matrix as a filter; apply it locally
       // in the compositor.
       use_color_matrix = true;
     } else {
       filter_bitmap = ApplyImageFilter(this,
                                        frame->offscreen_context_provider,
+                                       quad->rect.origin(),
                                        quad->filter.get(),
                                        contents_texture);
     }
   } else if (!quad->filters.IsEmpty()) {
     FilterOperations optimized_filters =
         RenderSurfaceFilters::Optimize(quad->filters);
 
     if ((optimized_filters.size() == 1) &&
         (optimized_filters.at(0).type() == FilterOperation::COLOR_MATRIX)) {
       memcpy(
@@ skipping 2362 matching lines @@
   std::string unique_context_name = base::StringPrintf(
       "%s-Offscreen-%p",
       Settings().compositor_name.c_str(),
       context_);
   offscreen_context_provider->Context3d()->pushGroupMarkerEXT(
       unique_context_name.c_str());
 }
 
 
 }  // namespace cc