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

cc/quads/render_pass_draw_quad.h

 // Copyright 2011 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.
 
 #ifndef CC_QUADS_RENDER_PASS_DRAW_QUAD_H_
 #define CC_QUADS_RENDER_PASS_DRAW_QUAD_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
@@ skipping 10 matching lines @@
   virtual ~RenderPassDrawQuad();
 
   void SetNew(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
               RenderPass::Id render_pass_id,
               bool is_replica,
               ResourceProvider::ResourceId mask_resource_id,
               const gfx::Rect& contents_changed_since_last_frame,
               const gfx::RectF& mask_uv_rect,
               const FilterOperations& filters,
-              const FilterOperations& background_filters);
+              const FilterOperations& background_filters,
+              const gfx::Transform& scale);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
               const gfx::Rect& opaque_rect,
               const gfx::Rect& visible_rect,
               bool needs_blending,
               RenderPass::Id render_pass_id,
               bool is_replica,
               ResourceProvider::ResourceId mask_resource_id,
               const gfx::Rect& contents_changed_since_last_frame,
               const gfx::RectF& mask_uv_rect,
               const FilterOperations& filters,
-              const FilterOperations& background_filters);
+              const FilterOperations& background_filters,
+              const gfx::Transform& scale);
 
   scoped_ptr<RenderPassDrawQuad> Copy(
       const SharedQuadState* copied_shared_quad_state,
       RenderPass::Id copied_render_pass_id) const;
 
   RenderPass::Id render_pass_id;
   bool is_replica;
   ResourceProvider::ResourceId mask_resource_id;
   gfx::Rect contents_changed_since_last_frame;
   gfx::RectF mask_uv_rect;
 
   // Post-processing filters, applied to the pixels in the render pass' texture.
   FilterOperations filters;
 
   // Post-processing filters, applied to the pixels showing through the
   // background of the render pass, from behind it.
   FilterOperations background_filters;
+  gfx::Transform scale;

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

Since you only care about the scale components, you could pull them out in
RenderSurfaceImpl instead of storing a whole transform.

That said, this transform is the full transform from the owning layer to the
render surface. Maybe you should just apply the whole transform to the canvas?

[Stephen White, 2014/03/07 17:46:43]

Yeah, that's probably a better idea.
For one thing, the transform is a 4x4 matrix, and this is an SkMatrix, which is
3x2 (2D).

Aside from that, the bigger issue is that filters just don't handle anything
other than scales and transforms well. They're really meant to be applied as an
orthographic, device-pixels post-process. If there's a 3D transform further up
the hierarchy, that should be flattened into the RenderSurface. If there's one
directly on the layer, it should be applied after the filters. So we shouldn't
end up with any 3D transforms here, IIUC.

For my edification: what else (other than pinch zoom) can end up in this
transform? What web content /browser settings can produce it?

[danakj, 2014/03/07 17:49:23]

Oh actually, because this is a transform from the owning layer to the surface
texture, it will only be scale. I was thinking the origin transform might be
built in, but that origin is in the quad rect instead. So grabbing the scale
components should be the best thing to do here. You can DCHECK that the
transform has only a 2d scale to it to encode these assumptions.

[danakj, 2014/03/07 17:50:22]

This is the full computation of the transform:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/layer_tre...

Identity * Scale.

[Stephen White, 2014/03/07 20:45:58]

Done.

[Stephen White, 2014/03/07 20:45:58]

Done.

 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const RenderPassDrawQuad* MaterialCast(const DrawQuad*);
 
  private:
   RenderPassDrawQuad();
   virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
 };
 
 }  // namespace cc
 
 #endif  // CC_QUADS_RENDER_PASS_DRAW_QUAD_H_