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);

[enne (OOO), 2016/08/22 22:57:39]

Please separate these conditions onto different lines and use
DCHECK_GE/DCHECK_LT

[trchen, 2016/08/29 10:14:48]

Done.

+  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());

[enne (OOO), 2016/08/22 22:57:39]

Can you make this DCHECK_EQ or maybe make a separate helper since you do this
somewhere else as well?

[trchen, 2016/08/29 10:14:48]

I think we need to fix this in base/logging.h. logging::MakeCheckOpString needs
operator<< to work, while the chromium convention is to use ToString. :/

+
+  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());

[enne (OOO), 2016/08/16 23:02:52]

It seems that contents translation is in layer space (given by the fact that you
translate then scale when rastering).  However here dest rect is scaled into
content space and then you translate using this layer space translation?  How is
this correct?

[trchen, 2016/08/29 10:14:48]

It is a cheat to take advantage of transform associativity. In the newly
uploaded CL I replaced dest_to_content_scale_ with the total matrix to go from
dest space to content space to make this more obvious.

+  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());

[enne (OOO), 2016/08/22 22:57:39]

I'm not 100% convinced that this satisfies the assumptions being made by
coverage iterator, in particular that it will always fill the destination space
perfectly.  Can you add some PictureLayerTilingSetTestWithResources unittests
that include translation offsets as well at different scales?

[trchen, 2016/08/29 10:14:48]

It will because the pre-rounding tile_bounds_in_dest_space already fill the dest
space. With ToEnclosingRect, some pixels in the dest space will be covered by
more than one tiles.

In fact, some rounding math here is already questionable prior to my CL. I don't
think we can simply take the enclosing rect for geometry rect. I will follow up
with more numerical analysis.

+  tile_bounds_in_dest_space.Scale(1 / dest_to_content_scale_);
+  current_geometry_rect_ = gfx::ToEnclosingRect(tile_bounds_in_dest_space);
 
   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