Raster PictureLayerTiling with fractional translation

cc/tiles/picture_layer_tiling.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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 15 matching lines @@
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
 PictureLayerTiling::PictureLayerTiling(
     WhichTree tree,
     float contents_scale,
+    const gfx::Vector2dF& contents_translation,
     scoped_refptr<RasterSource> raster_source,
     PictureLayerTilingClient* client)
     : contents_scale_(contents_scale),
+      contents_translation_(contents_translation),
       client_(client),
       tree_(tree),
       raster_source_(raster_source),
       resolution_(NON_IDEAL_RESOLUTION),
       may_contain_low_resolution_tiles_(false),
       tiling_data_(gfx::Size(), gfx::Size(), kBorderTexels),
       can_require_tiles_for_activation_(false),
       current_content_to_screen_scale_(0.f),
       has_visible_rect_tiles_(false),
       has_skewport_rect_tiles_(false),
       has_soon_border_rect_tiles_(false),
       has_eventually_rect_tiles_(false),
       all_tiles_done_(true) {
   DCHECK(!raster_source->IsSolidColor());
-  gfx::Size content_bounds =
-      gfx::ScaleToCeiledSize(raster_source_->GetSize(), contents_scale);
-  gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
+  DCHECK(contents_translation.x() >= 0.f && contents_translation.x() < 1.f);
+  DCHECK(contents_translation.y() >= 0.f && contents_translation.y() < 1.f);
+
+  gfx::Rect content_bounds_rect =
+      EnclosingContentsRectFromLayerRect(gfx::Rect(raster_source_->GetSize()));
+  DCHECK(content_bounds_rect.origin() == gfx::Point());
+
+  gfx::Size tile_size = client_->CalculateTileSize(content_bounds_rect.size());
 
   DCHECK(!gfx::ScaleToFlooredSize(raster_source_->GetSize(), contents_scale)
               .IsEmpty())
       << "Tiling created with scale too small as contents become empty."
       << " Layer bounds: " << raster_source_->GetSize().ToString()
       << " Contents scale: " << contents_scale;
 
-  tiling_data_.SetTilingSize(content_bounds);
+  tiling_data_.SetTilingSize(content_bounds_rect.size());
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
 }
 
 Tile* PictureLayerTiling::CreateTile(const Tile::CreateInfo& info) {
   const int i = info.tiling_i_index;
   const int j = info.tiling_j_index;
   TileMapKey key(i, j);
@@ skipping 33 matching lines @@
       // the previous content ID of these tiles. In that case, we need only
       // partially raster the tile content.
       if (tile && invalidation && TilingMatchesTileIndices(active_twin)) {
         if (const Tile* old_tile =
                 active_twin->TileAt(key.index_x, key.index_y)) {
           gfx::Rect tile_rect = tile->content_rect();
           gfx::Rect invalidated;
           for (Region::Iterator iter(*invalidation); iter.has_rect();
                iter.next()) {
             gfx::Rect invalid_content_rect =
-                gfx::ScaleToEnclosingRect(iter.rect(), contents_scale_);
+                EnclosingContentsRectFromLayerRect(iter.rect());
             invalid_content_rect.Intersect(tile_rect);
             invalidated.Union(invalid_content_rect);
           }
           tile->SetInvalidated(invalidated, old_tile->id());
         }
       }
     }
   }
   VerifyLiveTilesRect(false);
 }
@@ skipping 41 matching lines @@
                        pending_twin->current_eventually_rect_,
                        pending_twin->current_occlusion_in_layer_space_);
 }
 
 void PictureLayerTiling::SetRasterSourceAndResize(
     scoped_refptr<RasterSource> raster_source) {
   DCHECK(!raster_source->IsSolidColor());
   gfx::Size old_layer_bounds = raster_source_->GetSize();
   raster_source_ = std::move(raster_source);
   gfx::Size new_layer_bounds = raster_source_->GetSize();
-  gfx::Size content_bounds =
-      gfx::ScaleToCeiledSize(new_layer_bounds, contents_scale_);
-  gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
+  gfx::Rect content_rect =
+      EnclosingContentsRectFromLayerRect(gfx::Rect(new_layer_bounds));
+  DCHECK(content_rect.origin() == gfx::Point());
+  gfx::Size tile_size = client_->CalculateTileSize(content_rect.size());
 
   if (tile_size != tiling_data_.max_texture_size()) {
-    tiling_data_.SetTilingSize(content_bounds);
+    tiling_data_.SetTilingSize(content_rect.size());
     tiling_data_.SetMaxTextureSize(tile_size);
     // When the tile size changes, the TilingData positions no longer work
     // as valid keys to the TileMap, so just drop all tiles and clear the live
     // tiles rect.
     Reset();
     return;
   }
 
   if (old_layer_bounds == new_layer_bounds)
     return;
 
   // The SetLiveTilesRect() method would drop tiles outside the new bounds,
   // but may do so incorrectly if resizing the tiling causes the number of
   // tiles in the tiling_data_ to change.
-  gfx::Rect content_rect(content_bounds);
   int before_left = tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.x());
   int before_top = tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.y());
   int before_right =
       tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.right() - 1);
   int before_bottom =
       tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.bottom() - 1);
 
   // The live_tiles_rect_ is clamped to stay within the tiling size as we
   // change it.
   live_tiles_rect_.Intersect(content_rect);
-  tiling_data_.SetTilingSize(content_bounds);
+  tiling_data_.SetTilingSize(content_rect.size());
 
   int after_right = -1;
   int after_bottom = -1;
   if (!live_tiles_rect_.IsEmpty()) {
     after_right =
         tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.right() - 1);
     after_bottom =
         tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.bottom() - 1);
   }
 
@@ skipping 44 matching lines @@
   // unordered_map instead of a vector in the SmallMap.
   base::SmallMap<std::unordered_map<TileMapKey, gfx::Rect, TileMapKeyHash>, 16>
       remove_tiles;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_invalidation); iter.has_rect();
        iter.next()) {
     gfx::Rect layer_rect = iter.rect();
     // The pixels which are invalid in content space.
     gfx::Rect invalid_content_rect =
-        gfx::ScaleToEnclosingRect(layer_rect, contents_scale_);
+        EnclosingContentsRectFromLayerRect(layer_rect);
     gfx::Rect coverage_content_rect = invalid_content_rect;
     // Avoid needless work by not bothering to invalidate where there aren't
     // tiles.
     coverage_content_rect.Intersect(expanded_live_tiles_rect);
     if (coverage_content_rect.IsEmpty())
       continue;
     // Since the content_rect needs to invalidate things that only touch a
     // border of a tile, we need to include the borders while iterating.
     bool include_borders = true;
     for (TilingData::Iterator iter(&tiling_data_, coverage_content_rect,
@@ skipping 16 matching lines @@
       if (Tile* tile = CreateTile(info))
         tile->SetInvalidated(invalid_content_rect, old_tile->id());
     }
   }
 }
 
 Tile::CreateInfo PictureLayerTiling::CreateInfoForTile(int i, int j) const {
   gfx::Rect tile_rect = tiling_data_.TileBoundsWithBorder(i, j);
   tile_rect.set_size(tiling_data_.max_texture_size());
   gfx::Rect enclosing_layer_rect =
-      gfx::ScaleToEnclosingRect(tile_rect, 1.f / contents_scale_);
+      EnclosingLayerRectFromContentsRect(tile_rect);
   return Tile::CreateInfo(i, j, enclosing_layer_rect, tile_rect,
-                          contents_scale_);
+                          contents_scale_, contents_translation_);
 }
 
 bool PictureLayerTiling::ShouldCreateTileAt(
     const Tile::CreateInfo& info) const {
   const int i = info.tiling_i_index;
   const int j = info.tiling_j_index;
   // Active tree should always create a tile. The reason for this is that active
   // tree represents content that we draw on screen, which means that whenever
   // we check whether a tile should exist somewhere, the answer is yes. This
   // doesn't mean it will actually be created (if raster source doesn't cover
@@ skipping 19 matching lines @@
     return true;
 
   const Region* layer_invalidation = client_->GetPendingInvalidation();
 
   // If this tile is invalidated, then the pending tree should create one.
   // Do the intersection test in content space to match the corresponding check
   // on the active tree and avoid floating point inconsistencies.
   for (Region::Iterator iter(*layer_invalidation); iter.has_rect();
        iter.next()) {
     gfx::Rect invalid_content_rect =
-        gfx::ScaleToEnclosingRect(iter.rect(), contents_scale_);
+        EnclosingContentsRectFromLayerRect(iter.rect());
     if (invalid_content_rect.Intersects(info.content_rect))
       return true;
   }
   // If the active tree doesn't have a tile here, but it's in the pending tree's
   // visible rect, then the pending tree should create a tile. This can happen
   // if the pending visible rect is outside of the active tree's live tiles
   // rect. In those situations, we need to block activation until we're ready to
   // display content, which will have to come from the pending tree.
   if (!active_twin->TileAt(i, j) &&
       current_visible_rect_.Intersects(info.content_rect))
@@ skipping 33 matching lines @@
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
   DCHECK(tiling_);
   if (dest_rect_.IsEmpty())
     return;
 
   dest_to_content_scale_ = tiling_->contents_scale_ / dest_scale;
 
-  gfx::Rect content_rect =
-      gfx::ScaleToEnclosingRect(dest_rect_,
-                                dest_to_content_scale_,
-                                dest_to_content_scale_);
+  gfx::RectF dest_rect_in_contents_space(dest_rect_);
+  dest_rect_in_contents_space.Scale(dest_to_content_scale_);
+  dest_rect_in_contents_space.Offset(tiling->contents_translation());
+  gfx::Rect content_rect = gfx::ToEnclosingRect(dest_rect_in_contents_space);
+
   // IndexFromSrcCoord clamps to valid tile ranges, so it's necessary to
   // check for non-intersection first.
   content_rect.Intersect(gfx::Rect(tiling_->tiling_size()));
   if (content_rect.IsEmpty())
     return;
 
   left_ = tiling_->tiling_data_.TileXIndexFromSrcCoord(content_rect.x());
   top_ = tiling_->tiling_data_.TileYIndexFromSrcCoord(content_rect.y());
   right_ = tiling_->tiling_data_.TileXIndexFromSrcCoord(
       content_rect.right() - 1);
@@ skipping 26 matching lines @@
     }
   }
 
   current_tile_ = tiling_->TileAt(tile_i_, tile_j_);
 
   // Calculate the current geometry rect.  Due to floating point rounding
   // and ToEnclosingRect, tiles might overlap in destination space on the
   // edges.
   gfx::Rect last_geometry_rect = current_geometry_rect_;
 
-  gfx::Rect content_rect = tiling_->tiling_data_.TileBounds(tile_i_, tile_j_);
-
-  current_geometry_rect_ =
-      gfx::ScaleToEnclosingRect(content_rect, 1 / dest_to_content_scale_);
+  gfx::RectF tile_bounds_in_dest_space(
+      tiling_->tiling_data_.TileBounds(tile_i_, tile_j_));
+  tile_bounds_in_dest_space.Offset(-tiling_->contents_translation());
+  tile_bounds_in_dest_space.Scale(1 / dest_to_content_scale_);
+  current_geometry_rect_ = gfx::ToEnclosingRect(tile_bounds_in_dest_space);

[enne (OOO), 2016/07/26 00:22:16]

This is a little unexpected to me.  You're generating geometry rects that are
outside of the requested rect for the coverage iterator, right?

Also, the layer / draw transform itself isn't shifted by the contents
translation, so at best you're moving over the geometry rect by integer amounts?
I don't understand how this gets tiling pixels to line up with destination
pixels if the layer itself is still at an offset.

Maybe I'm just missing something, but I expected somewhere to see adjustments to
the layer size and the draw transform or something along those lines.

[trchen, 2016/08/03 06:06:07]

It won't, as the bound of the tiling would be
layer_size*raster_scale+raster_translation. Doing the reverse won't exceed the
layer bound for more than 1px (due to rounding up).
The geometry rect is not a precise rect, even without this CL, because it is
rounded up. It is okay to round it up because tiles overdraw 1px (i.e. border
texels) to cover it

Texture pixels line up with target pixels because the texture mapping is
adjusted by the translation too. See line #516.

Let's make a concrete example:

Say we have a layer that has transform:translate(12.3px, 45.6px). The layer will
be rastered into tiling with CTM of translate(0.3px, 0.6px).

What happens when we draw the top-left (partial) pixel at (12, 45)? The GPU will
generate sample point at the center of the pixel, that is (12.5, 45.5). Then it
will be projected to (0.2, -0.1) in the layer space by inverse draw_transform.
Then it will be projected to (0.5, 0.5) in the content space by the raster
transform. Magic! that's the dead center of the top-left texel!
No, the layer size should stay the same. The raster translation is applied at
PictureLayerTiling, not layer level.

Basically 3 spaces are involved here:

              draw_transform               contents_scale
target space <==============> layer space <==============> content(tiling) space

What's done in this CL is to extend contents_scale with a translation. In theory
any transform can be used, just that calculating coverage across multiple
tilings become really hard.

 
   current_geometry_rect_.Intersect(dest_rect_);
   DCHECK(!current_geometry_rect_.IsEmpty());
 
   if (first_time)
     return *this;
 
   // Iteration happens left->right, top->bottom.  Running off the bottom-right
   // edge is handled by the intersection above with dest_rect_.  Here we make
   // sure that the new current geometry rect doesn't overlap with the last.
@@ skipping 25 matching lines @@
 }
 
 gfx::RectF PictureLayerTiling::CoverageIterator::texture_rect() const {
   auto tex_origin = gfx::PointF(
       tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_).origin());
 
   // Convert from dest space => content space => texture space.
   gfx::RectF texture_rect(current_geometry_rect_);
   texture_rect.Scale(dest_to_content_scale_,
                      dest_to_content_scale_);
+  texture_rect.Offset(tiling_->contents_translation());
   texture_rect.Intersect(gfx::RectF(gfx::SizeF(tiling_->tiling_size())));
   if (texture_rect.IsEmpty())
     return texture_rect;
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
 
   return texture_rect;
 }
 
 ScopedTilePtr PictureLayerTiling::TakeTileAt(int i, int j) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
@@ skipping 31 matching lines @@
       current_occlusion_in_layer_space_.HasOcclusion()) {
     set_all_tiles_done(false);
   }
 
   const float content_to_screen_scale = ideal_contents_scale / contents_scale_;
 
   const gfx::Rect* input_rects[] = {
       &visible_rect_in_layer_space, &skewport_in_layer_space,
       &soon_border_rect_in_layer_space, &eventually_rect_in_layer_space};
   gfx::Rect output_rects[4];
-  for (size_t i = 0; i < arraysize(input_rects); ++i) {
-    output_rects[i] = gfx::ToEnclosingRect(
-        gfx::ScaleRect(gfx::RectF(*input_rects[i]), contents_scale_));
-  }
+  for (size_t i = 0; i < arraysize(input_rects); ++i)
+    output_rects[i] = EnclosingContentsRectFromLayerRect(*input_rects[i]);
   // Make sure the eventually rect is aligned to tile bounds.
   output_rects[3] =
       tiling_data_.ExpandRectIgnoringBordersToTileBounds(output_rects[3]);
 
   SetTilePriorityRects(content_to_screen_scale, output_rects[0],
                        output_rects[1], output_rects[2], output_rects[3],
                        occlusion_in_layer_space);
   SetLiveTilesRect(output_rects[3]);
 }
 
@@ skipping 110 matching lines @@
 bool PictureLayerTiling::IsTileOccludedOnCurrentTree(const Tile* tile) const {
   if (!current_occlusion_in_layer_space_.HasOcclusion())
     return false;
   gfx::Rect tile_query_rect =
       gfx::IntersectRects(tile->content_rect(), current_visible_rect_);
   // Explicitly check if the tile is outside the viewport. If so, we need to
   // return false, since occlusion for this tile is unknown.
   if (tile_query_rect.IsEmpty())
     return false;
 
-  if (contents_scale_ != 1.f) {
-    tile_query_rect =
-        gfx::ScaleToEnclosingRect(tile_query_rect, 1.f / contents_scale_);
-  }
+  if (contents_scale_ != 1.f || !contents_translation_.IsZero())
+    tile_query_rect = EnclosingLayerRectFromContentsRect(tile_query_rect);
   return current_occlusion_in_layer_space_.IsOccluded(tile_query_rect);
 }
 
 bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
   if (tree_ == PENDING_TREE) {
     if (!can_require_tiles_for_activation_)
       return false;
 
     if (resolution_ != HIGH_RESOLUTION)
       return false;
@@ skipping 61 matching lines @@
   tile->set_required_for_activation(IsTileRequiredForActivation(tile));
   tile->set_required_for_draw(IsTileRequiredForDraw(tile));
 }
 
 PrioritizedTile PictureLayerTiling::MakePrioritizedTile(
     Tile* tile,
     PriorityRectType priority_rect_type) const {
   DCHECK(tile);
   DCHECK(raster_source()->CoversRect(tile->enclosing_layer_rect()))
       << "Recording rect: "
-      << gfx::ScaleToEnclosingRect(tile->content_rect(),
-                                   1.f / tile->contents_scale())
-             .ToString();
+      << EnclosingLayerRectFromContentsRect(tile->content_rect()).ToString();
 
   return PrioritizedTile(tile, this,
                          ComputePriorityForTile(tile, priority_rect_type),
                          IsTileOccluded(tile));
 }
 
 std::map<const Tile*, PrioritizedTile>
 PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
@@ skipping 71 matching lines @@
     Tile* tile = tile_pair.second.get();
     prioritized_tiles->push_back(
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile)));
   }
 }
 
 void PictureLayerTiling::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetInteger("num_tiles", base::saturated_cast<int>(tiles_.size()));
   state->SetDouble("content_scale", contents_scale_);
+  MathUtil::AddToTracedValue("content_translation", contents_translation_,
+                             state);
   MathUtil::AddToTracedValue("visible_rect", current_visible_rect_, state);
   MathUtil::AddToTracedValue("skewport_rect", current_skewport_rect_, state);
   MathUtil::AddToTracedValue("soon_rect", current_soon_border_rect_, state);
   MathUtil::AddToTracedValue("eventually_rect", current_eventually_rect_,
                              state);
   MathUtil::AddToTracedValue("tiling_size", tiling_size(), state);
 }
 
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
+gfx::Rect PictureLayerTiling::EnclosingContentsRectFromLayerRect(
+    const gfx::Rect& layer_rect) const {
+  gfx::RectF contents_rect =
+      gfx::ScaleRect(gfx::RectF(layer_rect), contents_scale_);
+  contents_rect.Offset(contents_translation_);
+  return ToEnclosingRect(contents_rect);
+}
+
+gfx::Rect PictureLayerTiling::EnclosingLayerRectFromContentsRect(
+    const gfx::Rect& contents_rect) const {
+  gfx::RectF layer_rect(contents_rect);
+  layer_rect.Offset(-contents_translation_);
+  layer_rect.Scale(1.f / contents_scale_);
+  return ToEnclosingRect(layer_rect);
+}
+
 }  // namespace cc