cc: Change preraster/predecode split to be half of max skewport extent.

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 16 matching lines @@
 #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,
     scoped_refptr<RasterSource> raster_source,
-    PictureLayerTilingClient* client)
+    PictureLayerTilingClient* client,
+    float min_preraster_distance,
+    float max_preraster_distance)
     : contents_scale_(contents_scale),
       client_(client),
       tree_(tree),
       raster_source_(raster_source),
+      min_preraster_distance_(min_preraster_distance),
+      max_preraster_distance_(max_preraster_distance),
       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),
+      max_skewport_extent_(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);
 
@@ skipping 525 matching lines @@
   current_eventually_rect_ = eventually_rect;
   current_occlusion_in_layer_space_ = occlusion_in_layer_space;
   current_content_to_screen_scale_ = content_to_screen_scale;
 
   gfx::Rect tiling_rect(tiling_size());
   has_visible_rect_tiles_ = tiling_rect.Intersects(current_visible_rect_);
   has_skewport_rect_tiles_ = tiling_rect.Intersects(current_skewport_rect_);
   has_soon_border_rect_tiles_ =
       tiling_rect.Intersects(current_soon_border_rect_);
   has_eventually_rect_tiles_ = tiling_rect.Intersects(current_eventually_rect_);
+
+  // Note that we use the largest skewport extent from the viewport as the
+  // "skewport extent". Also note that this math can't produce negative numbers,
+  // since skewport.Contains(visible_rect) is always true.
+  max_skewport_extent_ =
+      current_content_to_screen_scale_ *
+      std::max(std::max(current_visible_rect_.x() - current_skewport_rect_.x(),
+                        current_skewport_rect_.right() -
+                            current_visible_rect_.right()),
+               std::max(current_visible_rect_.y() - current_skewport_rect_.y(),
+                        current_skewport_rect_.bottom() -
+                            current_visible_rect_.bottom()));
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          gfx::Rect(tiling_size()).Contains(new_live_tiles_rect))
       << "tiling_size: " << tiling_size().ToString()
       << " new_live_tiles_rect: " << new_live_tiles_rect.ToString();
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
@@ skipping 169 matching lines @@
 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();
 
-  return PrioritizedTile(tile, this,
-                         ComputePriorityForTile(tile, priority_rect_type),
-                         IsTileOccluded(tile));
+  const auto& tile_priority = ComputePriorityForTile(tile, priority_rect_type);
+  // Note that TileManager will consider this flag but may rasterize the tile
+  // anyway (if tile is required for activation for example). We should process
+  // the tile for images only if it's further than half of the skewport extent.
+  bool process_for_images_only =
+      tile_priority.distance_to_visible > min_preraster_distance_ &&
+      (tile_priority.distance_to_visible > max_preraster_distance_ ||
+       tile_priority.distance_to_visible > 0.5f * max_skewport_extent_);

[enne (OOO), 2016/09/07 22:03:20]

distance_to_visible is in screen space, but max skewport extent is in...content
space? Am I mistaken?

[vmpstr, 2016/09/07 22:06:40]

max skewport extent is in screen space as well (it's multiplied by the scale).
I'll change the variable name to be more clear.

[enne (OOO), 2016/09/07 22:13:03]

Oh right, I see that now.  More descriptive variable names about spaces would be
super appreciated.  :)

[vmpstr, 2016/09/07 22:48:28]

Done.

+  return PrioritizedTile(tile, this, tile_priority, IsTileOccluded(tile),
+                         process_for_images_only);
 }
 
 std::map<const Tile*, PrioritizedTile>
 PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
     Tile* tile = key_tile_pair.second.get();
     UpdateRequiredStatesOnTile(tile);
     PrioritizedTile prioritized_tile =
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile));
@@ skipping 85 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