Raster PictureLayerTiling with fractional translation

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
+#include "cc/base/scale_translate2d.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/micro_benchmark_impl.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
@@ skipping 236 matching lines @@
           width = DebugColors::OOMTileBorderWidth(layer_tree_impl());
         } else if (iter->draw_info().has_compressed_resource()) {
           color = DebugColors::CompressedTileBorderColor();
           width = DebugColors::CompressedTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
-        } else if (iter->contents_scale() > max_contents_scale) {
+        } else if (iter->contents_transform().pre_scale() >
+                   max_contents_scale) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
           color = DebugColors::ExtraLowResTileBorderColor();
           width = DebugColors::ExtraLowResTileBorderWidth(layer_tree_impl());
         }
       } else {
         color = DebugColors::MissingTileBorderColor();
         width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
       }
@@ skipping 47 matching lines @@
       switch (draw_info.mode()) {
         case TileDrawInfo::RESOURCE_MODE: {
           gfx::RectF texture_rect = iter.texture_rect();
 
           // The raster_contents_scale_ is the best scale that the layer is
           // trying to produce, even though it may not be ideal. Since that's
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
           // scale.
-          if (iter->contents_scale() != raster_contents_scale_ &&
-              iter->contents_scale() != ideal_contents_scale_ &&
+          if (iter->contents_transform().pre_scale() !=
+                  raster_contents_scale_ &&
+              iter->contents_transform().pre_scale() != ideal_contents_scale_ &&
               geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
             append_quads_data->num_incomplete_tiles++;
           }
 
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                        visible_geometry_rect, draw_info.resource_id(),
                        texture_rect, draw_info.resource_size(),
                        draw_info.contents_swizzled(), nearest_neighbor_);
@@ skipping 284 matching lines @@
 
   DCHECK(!RasterSourceUsesLCDText());
 }
 
 bool PictureLayerImpl::RasterSourceUsesLCDText() const {
   return raster_source_ ? raster_source_->CanUseLCDText()
                         : layer_tree_impl()->settings().can_use_lcd_text;
 }
 
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
-  if (layer_tree_impl()->IsActiveTree()) {
-    gfx::Rect layer_damage_rect = gfx::ScaleToEnclosingRect(
-        tile->content_rect(), 1.f / tile->contents_scale());
-    AddDamageRect(layer_damage_rect);
-  }
+  if (layer_tree_impl()->IsActiveTree())
+    AddDamageRect(tile->enclosing_layer_rect());
   if (tile->draw_info().NeedsRaster()) {
     PictureLayerTiling* tiling =
-        tilings_->FindTilingWithScale(tile->contents_scale());
-    if (tiling)
+        tilings_->FindTilingWithScale(tile->contents_transform().pre_scale());

[enne (OOO), 2016/08/29 20:21:19]

This is also wrong and needs to take into account the full transform of the
tile.

+    if (tiling) {
+      DCHECK_EQ(tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index()),
+                tile);
       tiling->set_all_tiles_done(false);
+    }
   }
 }
 
 void PictureLayerImpl::DidBeginTracing() {
   raster_source_->DidBeginTracing();
 }
 
 void PictureLayerImpl::ReleaseResources() {
   // Recreate tilings with new settings, since some of those might change when
   // we release resources.
@@ skipping 47 matching lines @@
   if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
     return &twin_layer->invalidation_;
   return nullptr;
 }
 
 const PictureLayerTiling* PictureLayerImpl::GetPendingOrActiveTwinTiling(
     const PictureLayerTiling* tiling) const {
   PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
   if (!twin_layer)
     return nullptr;
-  return twin_layer->tilings_->FindTilingWithScale(tiling->contents_scale());
+  const PictureLayerTiling* twin_tiling =
+      twin_layer->tilings_->FindTilingWithScale(

[enne (OOO), 2016/08/29 20:21:19]

I think this you need to be more explicit here in most of the cases where
FindTilingWithScale is used.  Yes, you check the translation, but you should
just pass that into FindTilingWithTransform() function.

+          tiling->contents_transform().pre_scale());
+  return twin_tiling &&
+                 twin_tiling->contents_transform() ==
+                     tiling->contents_transform()
+             ? twin_tiling
+             : nullptr;
 }
 
 bool PictureLayerImpl::RequiresHighResToDraw() const {
   return layer_tree_impl()->RequiresHighResToDraw();
 }
 
 gfx::Rect PictureLayerImpl::GetEnclosingRectInTargetSpace() const {
   return GetScaledEnclosingRectInTargetSpace(MaximumTilingContentsScale());
 }
 
@@ skipping 125 matching lines @@
 }
 
 void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) {
   if (nearest_neighbor_ == nearest_neighbor)
     return;
 
   nearest_neighbor_ = nearest_neighbor;
   NoteLayerPropertyChanged();
 }
 
-PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
+PictureLayerTiling* PictureLayerImpl::AddTiling(
+    const ScaleTranslate2d& contents_transform) {
   DCHECK(CanHaveTilings());
-  DCHECK_GE(contents_scale, MinimumContentsScale());
-  DCHECK_LE(contents_scale, MaximumContentsScale());
+  DCHECK_GE(contents_transform.pre_scale(), MinimumContentsScale());
+  DCHECK_LE(contents_transform.pre_scale(), MaximumContentsScale());
   DCHECK(raster_source_->HasRecordings());
-  return tilings_->AddTiling(contents_scale, raster_source_);
+  return tilings_->AddTiling(contents_transform, raster_source_);
 }
 
 void PictureLayerImpl::RemoveAllTilings() {
   tilings_->RemoveAllTilings();
   // If there are no tilings, then raster scales are no longer meaningful.
   ResetRasterScale();
 }
 
 void PictureLayerImpl::AddTilingsForRasterScale() {
   // Reset all resolution enums on tilings, we'll be setting new values in this
   // function.
   tilings_->MarkAllTilingsNonIdeal();
 
   PictureLayerTiling* high_res =
       tilings_->FindTilingWithScale(raster_contents_scale_);

[enne (OOO), 2016/08/29 20:21:18]

Here is another case where I think FindTilingWithScale is wrong.  I think this
patch needs to be much more deliberate about when it is creating a new tiling
that should snap and when it is reusing a tiling with any translation that can
be blurry.

   if (!high_res) {
+    gfx::Vector2dF raster_translation =
+        CalculateRasterTranslation(raster_contents_scale_);
     // We always need a high res tiling, so create one if it doesn't exist.
-    high_res = AddTiling(raster_contents_scale_);
+    high_res =
+        AddTiling(ScaleTranslate2d(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.
     high_res->Reset();
     // Reset the flag now that we'll make it high res, it will have fully
     // rastered content.
     high_res->reset_may_contain_low_resolution_tiles();
   }
   high_res->set_resolution(HIGH_RESOLUTION);
 
@@ skipping 81 matching lines @@
       tilings_->FindTilingWithScale(low_res_raster_contents_scale_);
   DCHECK(!low_res || low_res->resolution() != HIGH_RESOLUTION);
 
   // Only create new low res tilings when the transform is static.  This
   // prevents wastefully creating a paired low res tiling for every new high
   // res tiling during a pinch or a CSS animation.
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   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(
+          ScaleTranslate2d(low_res_raster_contents_scale_, gfx::Vector2dF()));
     low_res->set_resolution(LOW_RESOLUTION);
   }
 }
 
+gfx::Vector2dF PictureLayerImpl::CalculateRasterTranslation(
+    float raster_scale) {
+  // Do not align if the layer is animating, as we don't plan to re-raster
+  // during animation. Aligning to the first frame will only introduce extra
+  // aliasing error.
+  if (draw_properties().screen_space_transform_is_animating)
+    return gfx::Vector2dF();
+
+  // Can't align by just translation if the draw transform contains more than
+  // scale and translation. e.g. rotation, perspective, etc...
+  gfx::Transform draw_transform = DrawTransform();
+  if (!draw_transform.IsScaleOrTranslation())
+    return gfx::Vector2dF();
+
+  // It is only useful to align the content space to the target space if their
+  // relative pixel ratio is some small rational number. Currently we only
+  // align if the relative pixel ratio is 1:1.
+  // 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(draw_transform.matrix().getFloat(0, 0) - raster_scale) >
+          kErrorThreshold ||
+      std::abs(draw_transform.matrix().getFloat(1, 1) - raster_scale) >
+          kErrorThreshold)
+    return gfx::Vector2dF();
+
+  // Extract the fractional part of layer origin in the target space.
+  float origin_x = draw_transform.matrix().getFloat(0, 3);
+  float origin_y = draw_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_)
       raster_source_scale_ = 1.f;
 
     float min_scale = MinimumContentsScale();
     float max_scale = std::max(1.f, MinimumContentsScale());
     float clamped_ideal_source_scale_ =
         std::max(min_scale, std::min(ideal_source_scale_, max_scale));
 
@@ skipping 335 matching lines @@
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() &&
          is_drawn_render_surface_layer_list_member();
 }
 
 }  // namespace cc