Raster PictureLayerTiling with fractional translation

cc/layers/picture_layer_impl.cc

Index: cc/layers/picture_layer_impl.cc
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 12fe4e679d06f0b50e5137284e2b2273f5e59f9c..98264a7ec5313bc37a4dd024c9b8e40725adfa37 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -830,12 +830,15 @@ void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) {
   NoteLayerPropertyChanged();
 }
 
-PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
+PictureLayerTiling* PictureLayerImpl::AddTiling(
+    float contents_scale,
+    const gfx::Vector2dF& contents_translation) {
   DCHECK(CanHaveTilings());
   DCHECK_GE(contents_scale, MinimumContentsScale());
   DCHECK_LE(contents_scale, MaximumContentsScale());
   DCHECK(raster_source_->HasRecordings());
-  return tilings_->AddTiling(contents_scale, raster_source_);
+  return tilings_->AddTiling(contents_scale, contents_translation,
+                             raster_source_);
 }
 
 void PictureLayerImpl::RemoveAllTilings() {
@@ -852,8 +855,9 @@ void PictureLayerImpl::AddTilingsForRasterScale() {
   PictureLayerTiling* high_res =
       tilings_->FindTilingWithScale(raster_contents_scale_);
   if (!high_res) {
+    gfx::Vector2dF raster_translation = CalculateRasterTranslation();
     // We always need a high res tiling, so create one if it doesn't exist.
-    high_res = AddTiling(raster_contents_scale_);
+    high_res = AddTiling(raster_contents_scale_, raster_translation);
   } else if (high_res->may_contain_low_resolution_tiles()) {
     // If the tiling we find here was LOW_RESOLUTION previously, it may not be
     // fully rastered, so destroy the old tiles.
@@ -955,11 +959,34 @@ void PictureLayerImpl::AddLowResolutionTilingIfNeeded() {
   bool is_animating = draw_properties().screen_space_transform_is_animating;
   if (!is_pinching && !is_animating) {
     if (!low_res)
-      low_res = AddTiling(low_res_raster_contents_scale_);
+      low_res = AddTiling(low_res_raster_contents_scale_, gfx::Vector2dF());
     low_res->set_resolution(LOW_RESOLUTION);
   }
 }
 
+gfx::Vector2dF PictureLayerImpl::CalculateRasterTranslation() {

[enne (OOO), 2016/08/09 21:02:36]

I think this function should use draw transform and not screen space transform,
as the goal here is to align to the target pixels (which itself might not be
aligned to its target, but that's a separate issue).

As with what I said on
https://bugs.chromium.org/p/chromium/issues/detail?id=629522#c13, I think we
need something like "bool cc::Layer::ShouldBePixelSnapped()" and
"cc::Layer::SetPixelSnapOffset(gfx::Vector2dF)".  Then we can set particular
layer types that cannot reraster (texture layers, video layers, image layers?)
to have a pixel snapped position.  This should probably all be wrapped up at the
property tree level, I think.

I'm not sure if we need a separate transform node for the pixel snap offset, or
if the draw transform itself should just include the pixel snap offset?

It might be worth doing that plumbing first and fixing WebGL, and then we tweak
it for picture layers after that.

[trchen, 2016/08/10 01:44:14]

Agreed. However ajuma@ mentioned that target transform may go away in near
future. Is okay to add more use of it at this time?
Ah! Now I see why we had the misunderstanding yesterday. We are talking about
different approach to this problem.

You are actually suggesting that we apply a small geometry tweak so that layers
will be drawn at a position slightly moved from intended position. My approach
doesn't change the geometry of a layer, but only change the sample position when
we raster it.

I think your approach is a better solution for contents not rastered by us, but
I worry it could worsen edge bleeding issue. Right now the worst edge bleeding
we could have is an edge right in the middle of a pixel, that results in
1-(1-0.5)*(1-0.5)=0.75 alpha value. With geometry snapping, a whole row of
pixels can be skipped (unless we stretch the layer, that degrades quality too).
It will become very visible even on high-DPI displays.

[ajuma, 2016/08/10 13:32:04]

More specifically, once we're able to dynamically update render surfaces at draw
time, it'd be nice to stop computing render surfaces (and draw transforms) on
the pending tree, particularly since the render surfaces we compute there could
change at draw time (if, say, opacities or transforms change).

[enne (OOO), 2016/08/10 18:35:05]

I think it is *required* that this approach change transforms in all cases. 
This is what scroll snapping does currently.  If you do not snap the geometry to
align with target pixels, the result will be blurry as it will smear across
multiple pixels due to bilinear sampling.  Additionally, a raster translation
without a corresponding geometry counter-translation will end up rastering at
the incorrect location on screen.  If you are worried about edge pixels, then we
can change the size of the layer as well.

On 2016/08/10 at 13:32:04, ajuma wrote:
If we are going to commit to the complexity for this feature, I would like to
implement it properly in both the present state of the code and in the future of
property trees.  I think it is required to snap to target pixels (and for those
targets maybe to get a draw offset and pixel snap to their targets if needed,
recursively).  How are we going to accommodate this?

Yes, scroll snapping currently goes to screen space, but it's a hack because
it's not in a position to adjust geometry recursively up the tree.  It's also
much less likely for scrolling regions to be inside of a non-root render
surface.

+  if (draw_properties().screen_space_transform_is_animating)
+    return gfx::Vector2dF();
+
+  gfx::Transform screen_space_transform = ScreenSpaceTransform();
+  if (!screen_space_transform.IsScaleOrTranslation())
+    return gfx::Vector2dF();
+
+  // Good match if the maximum alignment error on a layer of size 10000px
+  // does not exceed 0.001px.
+  static constexpr float kErrorThreshold = 0.0000001f;
+  if (std::abs(screen_space_transform.matrix().getFloat(0, 0) -
+               raster_contents_scale_) > kErrorThreshold ||
+      std::abs(screen_space_transform.matrix().getFloat(1, 1) -
+               raster_contents_scale_) > kErrorThreshold)
+    return gfx::Vector2dF();
+
+  float origin_x = screen_space_transform.matrix().getFloat(0, 3);
+  float origin_y = screen_space_transform.matrix().getFloat(1, 3);
+  return gfx::Vector2dF(origin_x - floorf(origin_x),
+                        origin_y - floorf(origin_y));
+}
+
 void PictureLayerImpl::RecalculateRasterScales() {
   if (is_directly_composited_image_) {
     if (!raster_source_scale_)