cc: Move prepaint region calculations to the tiling set.

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 11 matching lines @@
 #include "cc/tiles/prioritized_tile.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #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 {
-namespace {
-
-const float kSoonBorderDistanceViewportPercentage = 0.15f;
-const float kMaxSoonBorderDistanceInScreenPixels = 312.f;
-
-}  // namespace
-
-std::unique_ptr<PictureLayerTiling> PictureLayerTiling::Create(
-    WhichTree tree,
-    float contents_scale,
-    scoped_refptr<RasterSource> raster_source,
-    PictureLayerTilingClient* client,
-    size_t tiling_interest_area_padding,
-    float skewport_target_time_in_seconds,
-    int skewport_extrapolation_limit_in_content_pixels) {
-  return base::WrapUnique(new PictureLayerTiling(
-      tree, contents_scale, raster_source, client, tiling_interest_area_padding,
-      skewport_target_time_in_seconds,
-      skewport_extrapolation_limit_in_content_pixels));
-}
 
 PictureLayerTiling::PictureLayerTiling(
     WhichTree tree,
     float contents_scale,
     scoped_refptr<RasterSource> raster_source,
-    PictureLayerTilingClient* client,
-    size_t tiling_interest_area_padding,
-    float skewport_target_time_in_seconds,
-    int skewport_extrapolation_limit_in_content_pixels)
-    : tiling_interest_area_padding_(tiling_interest_area_padding),
-      skewport_target_time_in_seconds_(skewport_target_time_in_seconds),
-      skewport_extrapolation_limit_in_content_pixels_(
-          skewport_extrapolation_limit_in_content_pixels),
-      contents_scale_(contents_scale),
+    PictureLayerTilingClient* client)
+    : contents_scale_(contents_scale),
       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),
-      invalidated_since_last_compute_priority_rects_(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(!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_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
 }
 
-// static
-float PictureLayerTiling::CalculateSoonBorderDistance(
-    const gfx::Rect& visible_rect_in_content_space,
-    float content_to_screen_scale) {
-  float max_dimension = std::max(visible_rect_in_content_space.width(),
-                                 visible_rect_in_content_space.height());
-  return std::min(
-      kMaxSoonBorderDistanceInScreenPixels / content_to_screen_scale,
-      max_dimension * kSoonBorderDistanceViewportPercentage);
-}
-
 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);
   DCHECK(tiles_.find(key) == tiles_.end());
 
   if (!raster_source_->CoversRect(info.enclosing_layer_rect))
     return nullptr;
 
   all_tiles_done_ = false;
@@ skipping 163 matching lines @@
     for (int i = before_left; i <= before_right; ++i) {
       Tile::CreateInfo info = CreateInfoForTile(i, after_bottom);
       if (ShouldCreateTileAt(info))
         CreateTile(info);
     }
   }
 }
 
 void PictureLayerTiling::Invalidate(const Region& layer_invalidation) {
   DCHECK(tree_ != ACTIVE_TREE || !client_->GetPendingOrActiveTwinTiling(this));
-  invalidated_since_last_compute_priority_rects_ = true;
   RemoveTilesInRegion(layer_invalidation, true /* recreate tiles */);
 }
 
 void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_invalidation,
                                              bool recreate_tiles) {
   // We only invalidate the active tiling when it's orphaned: it has no pending
   // twin, so it's slated for removal in the future.
   if (live_tiles_rect_.IsEmpty())
     return;
   // Pick 16 for the size of the SmallMap before it promotes to a unordered_map.
@@ skipping 265 matching lines @@
   tiles_.erase(found);
   return true;
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   tiles_.clear();
   all_tiles_done_ = true;
 }
 
-gfx::Rect PictureLayerTiling::ComputeSkewport(
-    double current_frame_time_in_seconds,
-    const gfx::Rect& visible_rect_in_content_space) const {
-  gfx::Rect skewport = visible_rect_in_content_space;
-  if (skewport.IsEmpty())
-    return skewport;
-
-  if (visible_rect_history_[1].frame_time_in_seconds == 0.0)
-    return skewport;
-
-  double time_delta = current_frame_time_in_seconds -
-                      visible_rect_history_[1].frame_time_in_seconds;
-  if (time_delta == 0.0)
-    return skewport;
-
-  double extrapolation_multiplier =
-      skewport_target_time_in_seconds_ / time_delta;
-
-  int old_x = visible_rect_history_[1].visible_rect_in_content_space.x();
-  int old_y = visible_rect_history_[1].visible_rect_in_content_space.y();
-  int old_right =
-      visible_rect_history_[1].visible_rect_in_content_space.right();
-  int old_bottom =
-      visible_rect_history_[1].visible_rect_in_content_space.bottom();
-
-  int new_x = visible_rect_in_content_space.x();
-  int new_y = visible_rect_in_content_space.y();
-  int new_right = visible_rect_in_content_space.right();
-  int new_bottom = visible_rect_in_content_space.bottom();
-
-  // Compute the maximum skewport based on
-  // |skewport_extrapolation_limit_in_content_pixels_|.
-  gfx::Rect max_skewport = skewport;
-  max_skewport.Inset(-skewport_extrapolation_limit_in_content_pixels_,
-                     -skewport_extrapolation_limit_in_content_pixels_);
-
-  // Inset the skewport by the needed adjustment.
-  skewport.Inset(extrapolation_multiplier * (new_x - old_x),
-                 extrapolation_multiplier * (new_y - old_y),
-                 extrapolation_multiplier * (old_right - new_right),
-                 extrapolation_multiplier * (old_bottom - new_bottom));
-
-  // Ensure that visible rect is contained in the skewport.
-  skewport.Union(visible_rect_in_content_space);
-
-  // Clip the skewport to |max_skewport|. This needs to happen after the
-  // union in case intersecting would have left the empty rect.
-  skewport.Intersect(max_skewport);
-
-  // Due to limits in int's representation, it is possible that the two
-  // operations above (union and intersect) result in an empty skewport. To
-  // avoid any unpleasant situations like that, union the visible rect again to
-  // ensure that skewport.Contains(visible_rect_in_content_space) is always
-  // true.
-  skewport.Union(visible_rect_in_content_space);
-
-  return skewport;
-}
-
-bool PictureLayerTiling::ComputeTilePriorityRects(
-    const gfx::Rect& viewport_in_layer_space,
+void PictureLayerTiling::ComputeTilePriorityRects(
+    const gfx::Rect& visible_rect_in_layer_space,
+    const gfx::Rect& skewport_in_layer_space,
+    const gfx::Rect& soon_border_rect_in_layer_space,
+    const gfx::Rect& eventually_rect_in_layer_space,
     float ideal_contents_scale,
-    double current_frame_time_in_seconds,
     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);
   }
 
-  bool invalidated = invalidated_since_last_compute_priority_rects_;
-  invalidated_since_last_compute_priority_rects_ = false;
-  if (!NeedsUpdateForFrameAtTimeAndViewport(current_frame_time_in_seconds,
-                                            viewport_in_layer_space)) {
-    // This should never be zero for the purposes of has_ever_been_updated().
-    DCHECK_NE(current_frame_time_in_seconds, 0.0);
-    return invalidated;
-  }
-
   const float content_to_screen_scale = ideal_contents_scale / contents_scale_;
 
-  // We want to compute the visible rect and eventually rect from it in the
-  // space of the tiling. But the visible rect (viewport) can be arbitrarily
-  // positioned, so be careful when scaling it since we can exceed integer
-  // bounds.
-  gfx::Rect eventually_rect;
-  gfx::Rect visible_rect_in_content_space;
+  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_));
+  }
+  // Make sure the eventually rect is aligned to tile bounds.
+  output_rects[3] =
+      tiling_data_.ExpandRectIgnoringBordersToTileBounds(output_rects[3]);
 
-  // We keep things as floats in here.
-  {
-    gfx::RectF visible_rectf_in_content_space =
-        gfx::ScaleRect(gfx::RectF(viewport_in_layer_space), contents_scale_);
-
-    // Determine if the eventually rect will even touch the tiling, if it's too
-    // far away just treat it as empty so we don't exceed integer bounds.
-    const float pad_in_content_space =
-        tiling_interest_area_padding_ / content_to_screen_scale;
-    gfx::RectF eventually_rectf = visible_rectf_in_content_space;
-    // If the visible rect is empty, keep the eventually rect as empty.
-    if (!eventually_rectf.IsEmpty()) {
-      eventually_rectf.Inset(-pad_in_content_space, -pad_in_content_space);
-
-      // If the eventually rect will touch the tiling, then we convert back to
-      // integers and set the visible and eventually rects.
-      auto bounds = gfx::RectF(gfx::SizeF(tiling_size()));
-      if (eventually_rectf.Intersects(bounds)) {
-        visible_rect_in_content_space =
-            gfx::ToEnclosingRect(visible_rectf_in_content_space);
-        eventually_rect = gfx::ToEnclosingRect(eventually_rectf);
-      }
-    }
-  }
-  DCHECK_EQ(visible_rect_in_content_space.IsEmpty(), eventually_rect.IsEmpty());
-
-  // Now we have an empty visible/eventually rect if it's not useful and a
-  // non-empty one if it is. We can compute the final eventually rect.
-  eventually_rect =
-      tiling_data_.ExpandRectIgnoringBordersToTileBounds(eventually_rect);
-
-  DCHECK(eventually_rect.IsEmpty() ||
-         gfx::Rect(tiling_size()).Contains(eventually_rect))
-      << "tiling_size: " << tiling_size().ToString()
-      << " eventually_rect: " << eventually_rect.ToString();
-
-  if (tiling_size().IsEmpty()) {
-    UpdateVisibleRectHistory(current_frame_time_in_seconds,
-                             visible_rect_in_content_space);
-    last_viewport_in_layer_space_ = viewport_in_layer_space;
-    return false;
-  }
-
-  // Calculate the skewport.
-  gfx::Rect skewport = ComputeSkewport(current_frame_time_in_seconds,
-                                       visible_rect_in_content_space);
-  DCHECK(skewport.Contains(visible_rect_in_content_space));
-
-  // Calculate the soon border rect.
-  gfx::Rect soon_border_rect = visible_rect_in_content_space;
-  float border = CalculateSoonBorderDistance(visible_rect_in_content_space,
-                                             content_to_screen_scale);
-  soon_border_rect.Inset(-border, -border, -border, -border);
-
-  UpdateVisibleRectHistory(current_frame_time_in_seconds,
-                           visible_rect_in_content_space);
-  last_viewport_in_layer_space_ = viewport_in_layer_space;
-
-  SetTilePriorityRects(content_to_screen_scale, visible_rect_in_content_space,
-                       skewport, soon_border_rect, eventually_rect,
+  SetTilePriorityRects(content_to_screen_scale, output_rects[0],
+                       output_rects[1], output_rects[2], output_rects[3],
                        occlusion_in_layer_space);
-  SetLiveTilesRect(eventually_rect);
-  return true;
+  SetLiveTilesRect(output_rects[3]);
 }
 
 void PictureLayerTiling::SetTilePriorityRects(
     float content_to_screen_scale,
     const gfx::Rect& visible_rect_in_content_space,
     const gfx::Rect& skewport,
     const gfx::Rect& soon_border_rect,
     const gfx::Rect& eventually_rect,
     const Occlusion& occlusion_in_layer_space) {
   current_visible_rect_ = visible_rect_in_content_space;
@@ skipping 299 matching lines @@
 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;
 }
 
 }  // namespace cc