Implement hidpi and pinch-zoom scaling of filter params in cc.

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 466 matching lines @@
   GLC(gl_, gl_->LineWidth(quad->width));
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   GLC(gl_, gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
 }
 
 static SkBitmap ApplyImageFilter(GLRenderer* renderer,
                                  ContextProvider* offscreen_contexts,
                                  const gfx::Point& origin,
+                                 const gfx::Transform& scale,
                                  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 43 matching lines @@
 
   // 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);
 
-  // TODO(senorblanco): in addition to the origin translation here, the canvas
-  // should also be scaled to accomodate device pixel ratio and pinch zoom. See
-  // crbug.com/281516 and crbug.com/281518.
   canvas.translate(SkIntToScalar(-origin.x()), SkIntToScalar(-origin.y()));
+  canvas.scale(scale.Scale2d().x(), scale.Scale2d().y());

[danakj, 2014/03/07 17:35:44]

Huh, didn't know we have Scale2d(). MathUtil::ComputeTransform2dScaleComponents
is more rigorous, but I'm not sure if it would matter here or not.

   canvas.drawSprite(source, 0, 0, &paint);
 
   // 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->ContextGL()->Flush();
 
@@ skipping 191 matching lines @@
 
   skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, device_background_texture->size());
 
   SkBitmap filtered_device_background;
   if (apply_background_filters) {
     filtered_device_background =
         ApplyImageFilter(this,
                          frame->offscreen_context_provider,
                          quad->rect.origin(),
+                         quad->scale,
                          filter.get(),
                          device_background_texture.get());
   }
   *background_changed = (filtered_device_background.getTexture() != NULL);
 
   int filtered_device_background_texture_id = 0;
   scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
   if (filtered_device_background.getTexture()) {
     GrTexture* texture =
         reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
@@ skipping 114 matching lines @@
       }
 
       if (cf && cf->asColorMatrix(color_matrix) && !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->scale,
                                          filter.get(),
                                          contents_texture);
       }
     }
   }
 
   if (quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode &&
       background_texture) {
     filter_bitmap =
         ApplyBlendModeWithBackdrop(this,
@@ skipping 2127 matching lines @@
   is_scissor_enabled_ = false;
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   scissor_rect_needs_reset_ = true;
 }
 
 bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
 }  // namespace cc