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 14 matching lines @@
 #include "ui/gfx/geometry/point_conversions.h"
 #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 ScaleTranslate2d& contents_transform,
     scoped_refptr<RasterSource> raster_source,
     PictureLayerTilingClient* client)
-    : contents_scale_(contents_scale),
+    : contents_transform_(contents_transform),
       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_GE(contents_transform.translation().x(), 0.f);
+  DCHECK_LT(contents_transform.translation().x(), 1.f);
+  DCHECK_GE(contents_transform.translation().y(), 0.f);
+  DCHECK_LT(contents_transform.translation().y(), 1.f);
 
-  DCHECK(!gfx::ScaleToFlooredSize(raster_source_->GetSize(), contents_scale)
+  DCHECK(!gfx::ScaleToFlooredSize(raster_source_->GetSize(),
+                                  contents_transform.pre_scale())
               .IsEmpty())
       << "Tiling created with scale too small as contents become empty."
       << " Layer bounds: " << raster_source_->GetSize().ToString()
-      << " Contents scale: " << contents_scale;
+      << " Contents scale: " << contents_transform.pre_scale();
 
-  tiling_data_.SetTilingSize(content_bounds);
+  gfx::Rect content_bounds_rect =
+      EnclosingContentsRectFromLayerRect(gfx::Rect(raster_source_->GetSize()));
+  gfx::Size tiling_size = gfx::Size(content_bounds_rect.bottom_right().x(),
+                                    content_bounds_rect.bottom_right().y());
+  tiling_data_.SetTilingSize(tiling_size);
+  gfx::Size tile_size = client_->CalculateTileSize(tiling_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_transform_);
 }
 
 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 19 matching lines @@
       right_(-1),
       bottom_(-1) {
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator(
     const PictureLayerTiling* tiling,
     float dest_scale,
     const gfx::Rect& dest_rect)
     : tiling_(tiling),
       dest_rect_(dest_rect),
-      dest_to_content_scale_(0),
+      dest_to_content_(ScaleTranslate2d::PreScale(tiling->contents_transform(),
+                                                  1.f / dest_scale)),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       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::ToEnclosingRect(dest_to_content_.Transform(gfx::RectF(dest_rect_)));
 
-  gfx::Rect content_rect =
-      gfx::ScaleToEnclosingRect(dest_rect_,
-                                dest_to_content_scale_,
-                                dest_to_content_scale_);
   // 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::ToEnclosingRect(dest_to_content_.TransformReverse(
+          gfx::RectF(tiling_->tiling_data_.TileBounds(tile_i_, tile_j_))));
 
   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 22 matching lines @@
 
 gfx::Rect PictureLayerTiling::CoverageIterator::geometry_rect() const {
   return current_geometry_rect_;
 }
 
 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_);
+  gfx::RectF texture_rect =
+      dest_to_content_.Transform(gfx::RectF(current_geometry_rect_));
   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 25 matching lines @@
     const gfx::Rect& eventually_rect_in_layer_space,
     float ideal_contents_scale,
     const Occlusion& occlusion_in_layer_space) {
   // If we have, or had occlusions, mark the tiles as 'not done' to ensure that
   // we reiterate the tiles for rasterization.
   if (occlusion_in_layer_space.HasOcclusion() ||
       current_occlusion_in_layer_space_.HasOcclusion()) {
     set_all_tiles_done(false);
   }
 
-  const float content_to_screen_scale = ideal_contents_scale / contents_scale_;
+  const float content_to_screen_scale =
+      ideal_contents_scale / contents_transform_.pre_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_);
-  }
+  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 70 matching lines @@
   for (const auto& tile_pair : tiles_) {
     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_);
+  state->SetDouble("content_transform_pre_scale",
+                   contents_transform_.pre_scale());
+  MathUtil::AddToTracedValue("content_transform_translation",
+                             contents_transform_.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 {
+  return ToEnclosingRect(contents_transform_.Transform(gfx::RectF(layer_rect)));
+}
+
+gfx::Rect PictureLayerTiling::EnclosingLayerRectFromContentsRect(
+    const gfx::Rect& contents_rect) const {
+  return ToEnclosingRect(
+      contents_transform_.TransformReverse(gfx::RectF(contents_rect)));
+}
+
 }  // namespace cc