cc: Remove max tiles and skewport constants from tiling client.

This patch removes some more client functionality from picture layer
tiling. These values don't typically change (aside from going from
gpu to cpu rasterization), but are frequently accessed. By eliminating
these calls makes the code more direct (ie it's obvious where these
settings are set).

Also, it potentially makes the code quicker since it eliminates several
virtual calls, although this is only called once per frame.

BUG=433048
R=danakj, enne

Review URL: https://codereview.chromium.org/775483002

Cr-Commit-Position: refs/heads/master@{#307963}

cc/debug/rasterize_and_record_benchmark_impl.cc

@@ -15,6 +15,7 @@
 #include "cc/resources/tile_task_worker_pool.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
+#include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
@@ -121,18 +122,6 @@ class FixedInvalidationPictureLayerTilingClient
     return base_client_->GetMaxTilePriorityBin();
   }
 
-  size_t GetMaxTilesForInterestArea() const override {
-    return base_client_->GetMaxTilesForInterestArea();
-  }
-
-  float GetSkewportTargetTimeInSeconds() const override {
-    return base_client_->GetSkewportTargetTimeInSeconds();
-  }
-
-  int GetSkewportExtrapolationLimitInContentPixels() const override {
-    return base_client_->GetSkewportExtrapolationLimitInContentPixels();
-  }
-
   WhichTree GetTree() const override { return base_client_->GetTree(); }
 
   bool RequiresHighResToDraw() const override {
@@ -215,7 +204,15 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
 
   FixedInvalidationPictureLayerTilingClient client(
       layer, gfx::Rect(layer->content_bounds()));
-  auto tiling_set = PictureLayerTilingSet::Create(&client);
+
+  // In this benchmark, we will create a local tiling set and measure how long
+  // it takes to rasterize content. As such, the actual settings used here don't
+  // really matter.
+  const LayerTreeSettings& settings = layer->layer_tree_impl()->settings();
+  auto tiling_set = PictureLayerTilingSet::Create(
+      &client, settings.max_tiles_for_interest_area,
+      settings.skewport_target_time_in_seconds,
+      settings.skewport_extrapolation_limit_in_content_pixels);
 
   PictureLayerTiling* tiling =
       tiling_set->AddTiling(layer->contents_scale_x(), layer->bounds());

cc/layers/picture_layer_impl.cc

@@ -68,7 +68,7 @@ PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl,
                                    bool is_mask)
     : LayerImpl(tree_impl, id),
       twin_layer_(nullptr),
-      tilings_(PictureLayerTilingSet::Create(this)),
+      tilings_(CreatePictureLayerTilingSet()),
       // TODO(danakj): Can this be null to start?
       raster_source_(PicturePileImpl::Create()),
       ideal_page_scale_(0.f),
@@ -624,9 +624,10 @@ void PictureLayerImpl::DidBeginTracing() {
 }
 
 void PictureLayerImpl::ReleaseResources() {
+  // Recreate tilings with new settings, since some of those might change when
+  // we release resources. If tilings_ is null, then leave it as null.
   if (tilings_)
-    RemoveAllTilings();
-
+    tilings_ = CreatePictureLayerTilingSet();
   ResetRasterScale();
 
   // To avoid an edge case after lost context where the tree is up to date but
@@ -689,22 +690,6 @@ TilePriority::PriorityBin PictureLayerImpl::GetMaxTilePriorityBin() const {
   return TilePriority::NOW;
 }
 
-size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
-  return layer_tree_impl()->settings().max_tiles_for_interest_area;
-}
-
-float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
-  return layer_tree_impl()->use_gpu_rasterization()
-             ? 0.f
-             : layer_tree_impl()->settings().skewport_target_time_in_seconds;
-}
-
-int PictureLayerImpl::GetSkewportExtrapolationLimitInContentPixels() const {
-  return layer_tree_impl()
-      ->settings()
-      .skewport_extrapolation_limit_in_content_pixels;
-}
-
 bool PictureLayerImpl::RequiresHighResToDraw() const {
   return layer_tree_impl()->RequiresHighResToDraw();
 }
@@ -1154,6 +1139,17 @@ float PictureLayerImpl::MaximumTilingContentsScale() const {
   return std::max(max_contents_scale, MinimumContentsScale());
 }
 
+scoped_ptr<PictureLayerTilingSet>
+PictureLayerImpl::CreatePictureLayerTilingSet() {
+  const LayerTreeSettings& settings = layer_tree_impl()->settings();
+  return PictureLayerTilingSet::Create(
+      this, settings.max_tiles_for_interest_area,
+      layer_tree_impl()->use_gpu_rasterization()
+          ? 0.f
+          : settings.skewport_target_time_in_seconds,
+      settings.skewport_extrapolation_limit_in_content_pixels);
+}
+
 void PictureLayerImpl::UpdateIdealScales() {
   DCHECK(CanHaveTilings());
 

cc/layers/picture_layer_impl.h

@@ -75,9 +75,6 @@ class CC_EXPORT PictureLayerImpl
   PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) override;
   TilePriority::PriorityBin GetMaxTilePriorityBin() const override;
-  size_t GetMaxTilesForInterestArea() const override;
-  float GetSkewportTargetTimeInSeconds() const override;
-  int GetSkewportExtrapolationLimitInContentPixels() const override;
   WhichTree GetTree() const override;
   bool RequiresHighResToDraw() const override;
 
@@ -148,6 +145,7 @@ class CC_EXPORT PictureLayerImpl
 
   virtual void UpdateIdealScales();
   float MaximumTilingContentsScale() const;
+  scoped_ptr<PictureLayerTilingSet> CreatePictureLayerTilingSet();
 
   PictureLayerImpl* twin_layer_;
 

cc/resources/picture_layer_tiling.cc

@@ -59,16 +59,28 @@ class TileEvictionOrder {
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     const gfx::Size& layer_bounds,
-    PictureLayerTilingClient* client) {
-  return make_scoped_ptr(new PictureLayerTiling(contents_scale,
-                                                layer_bounds,
-                                                client));
+    PictureLayerTilingClient* client,
+    size_t max_tiles_for_interest_area,
+    float skewport_target_time_in_seconds,
+    int skewport_extrapolation_limit_in_content_pixels) {
+  return make_scoped_ptr(new PictureLayerTiling(
+      contents_scale, layer_bounds, client, max_tiles_for_interest_area,
+      skewport_target_time_in_seconds,
+      skewport_extrapolation_limit_in_content_pixels));
 }
 
-PictureLayerTiling::PictureLayerTiling(float contents_scale,
-                                       const gfx::Size& layer_bounds,
-                                       PictureLayerTilingClient* client)
-    : contents_scale_(contents_scale),
+PictureLayerTiling::PictureLayerTiling(
+    float contents_scale,
+    const gfx::Size& layer_bounds,
+    PictureLayerTilingClient* client,
+    size_t max_tiles_for_interest_area,
+    float skewport_target_time_in_seconds,
+    int skewport_extrapolation_limit_in_content_pixels)
+    : max_tiles_for_interest_area_(max_tiles_for_interest_area),
+      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),
       layer_bounds_(layer_bounds),
       resolution_(NON_IDEAL_RESOLUTION),
       client_(client),
@@ -541,10 +553,8 @@ gfx::Rect PictureLayerTiling::ComputeSkewport(
   if (time_delta == 0.0)
     return skewport;
 
-  float skewport_target_time_in_seconds =
-      client_->GetSkewportTargetTimeInSeconds();
   double extrapolation_multiplier =
-      skewport_target_time_in_seconds / time_delta;
+      skewport_target_time_in_seconds_ / time_delta;
 
   int old_x = last_visible_rect_in_content_space_.x();
   int old_y = last_visible_rect_in_content_space_.y();
@@ -556,12 +566,11 @@ gfx::Rect PictureLayerTiling::ComputeSkewport(
   int new_right = visible_rect_in_content_space.right();
   int new_bottom = visible_rect_in_content_space.bottom();
 
-  int skewport_limit = client_->GetSkewportExtrapolationLimitInContentPixels();
-
-  // Compute the maximum skewport based on |skewport_limit|.
+  // Compute the maximum skewport based on
+  // |skewport_extrapolation_limit_in_content_pixels_|.
   gfx::Rect max_skewport = skewport;
-  max_skewport.Inset(
-      -skewport_limit, -skewport_limit, -skewport_limit, -skewport_limit);
+  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),
@@ -605,11 +614,9 @@ void PictureLayerTiling::ComputeTilePriorityRects(
   DCHECK(skewport.Contains(visible_rect_in_content_space));
 
   // Calculate the eventually/live tiles rect.
-  size_t max_tiles_for_interest_area = client_->GetMaxTilesForInterestArea();
-
   gfx::Size tile_size = tiling_data_.max_texture_size();
   int64 eventually_rect_area =
-      max_tiles_for_interest_area * tile_size.width() * tile_size.height();
+      max_tiles_for_interest_area_ * tile_size.width() * tile_size.height();
 
   gfx::Rect eventually_rect =
       ExpandRectEquallyToAreaBoundedBy(visible_rect_in_content_space,

cc/resources/picture_layer_tiling.h

@@ -48,9 +48,6 @@ class CC_EXPORT PictureLayerTilingClient {
   virtual PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) = 0;
   virtual TilePriority::PriorityBin GetMaxTilePriorityBin() const = 0;
-  virtual size_t GetMaxTilesForInterestArea() const = 0;
-  virtual float GetSkewportTargetTimeInSeconds() const = 0;
-  virtual int GetSkewportExtrapolationLimitInContentPixels() const = 0;
   virtual WhichTree GetTree() const = 0;
   virtual bool RequiresHighResToDraw() const = 0;
 
@@ -126,7 +123,11 @@ class CC_EXPORT PictureLayerTiling {
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
-      PictureLayerTilingClient* client);
+      PictureLayerTilingClient* client,
+      size_t max_tiles_for_interest_area,
+      float skewport_target_time_in_seconds,
+      int skewport_extrapolation_limit_in_content_pixels);
+
   gfx::Size layer_bounds() const { return layer_bounds_; }
   void Resize(const gfx::Size& new_layer_bounds);
   void Invalidate(const Region& layer_invalidation);
@@ -290,7 +291,10 @@ class CC_EXPORT PictureLayerTiling {
 
   PictureLayerTiling(float contents_scale,
                      const gfx::Size& layer_bounds,
-                     PictureLayerTilingClient* client);
+                     PictureLayerTilingClient* client,
+                     size_t max_tiles_for_interest_area,
+                     float skewport_target_time_in_seconds,
+                     int skewport_extrapolation_limit_in_content_pixels);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void VerifyLiveTilesRect();
   Tile* CreateTile(int i, int j, const PictureLayerTiling* twin_tiling);
@@ -320,6 +324,10 @@ class CC_EXPORT PictureLayerTiling {
   void UpdateTileAndTwinPriority(Tile* tile) const;
   void UpdateTilePriority(Tile* tile) const;
 
+  const size_t max_tiles_for_interest_area_;
+  const float skewport_target_time_in_seconds_;
+  const int skewport_extrapolation_limit_in_content_pixels_;
+
   // Given properties.
   float contents_scale_;
   gfx::Size layer_bounds_;

cc/resources/picture_layer_tiling_perftest.cc

@@ -44,11 +44,14 @@ class PictureLayerTilingPerfTest : public testing::Test {
   }
 
   void SetUp() override {
+    LayerTreeSettings defaults;
     picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
-    picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
     picture_layer_tiling_client_.set_tree(PENDING_TREE);
     picture_layer_tiling_ = PictureLayerTiling::Create(
-        1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
+        1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_,
+        defaults.max_tiles_for_interest_area,
+        defaults.skewport_target_time_in_seconds,
+        defaults.skewport_extrapolation_limit_in_content_pixels);
     picture_layer_tiling_->CreateAllTilesForTesting();
   }
 
@@ -124,8 +127,12 @@ class PictureLayerTilingPerfTest : public testing::Test {
   void RunRasterIteratorConstructTest(const std::string& test_name,
                                       const gfx::Rect& viewport) {
     gfx::Size bounds(viewport.size());
-    picture_layer_tiling_ =
-        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    LayerTreeSettings defaults;
+    picture_layer_tiling_ = PictureLayerTiling::Create(
+        1, bounds, &picture_layer_tiling_client_,
+        defaults.max_tiles_for_interest_area,
+        defaults.skewport_target_time_in_seconds,
+        defaults.skewport_extrapolation_limit_in_content_pixels);
     picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
     picture_layer_tiling_->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                     Occlusion());
@@ -149,8 +156,12 @@ class PictureLayerTilingPerfTest : public testing::Test {
                                                 int num_tiles,
                                                 const gfx::Rect& viewport) {
     gfx::Size bounds(10000, 10000);
-    picture_layer_tiling_ =
-        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    LayerTreeSettings defaults;
+    picture_layer_tiling_ = PictureLayerTiling::Create(
+        1, bounds, &picture_layer_tiling_client_,
+        defaults.max_tiles_for_interest_area,
+        defaults.skewport_target_time_in_seconds,
+        defaults.skewport_extrapolation_limit_in_content_pixels);
     picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
     picture_layer_tiling_->ComputeTilePriorityRects(viewport, 1.0f, 1.0,
                                                     Occlusion());

cc/resources/picture_layer_tiling_set.cc

@@ -29,12 +29,25 @@ inline float LargerRatio(float float1, float float2) {
 
 // static
 scoped_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
-    PictureLayerTilingClient* client) {
-  return make_scoped_ptr(new PictureLayerTilingSet(client));
-}
-
-PictureLayerTilingSet::PictureLayerTilingSet(PictureLayerTilingClient* client)
-    : client_(client) {
+    PictureLayerTilingClient* client,
+    size_t max_tiles_for_interest_area,
+    float skewport_target_time_in_seconds,
+    int skewport_extrapolation_limit_in_content_pixels) {
+  return make_scoped_ptr(new PictureLayerTilingSet(
+      client, max_tiles_for_interest_area, skewport_target_time_in_seconds,
+      skewport_extrapolation_limit_in_content_pixels));
+}
+
+PictureLayerTilingSet::PictureLayerTilingSet(
+    PictureLayerTilingClient* client,
+    size_t max_tiles_for_interest_area,
+    float skewport_target_time_in_seconds,
+    int skewport_extrapolation_limit_in_content_pixels)
+    : max_tiles_for_interest_area_(max_tiles_for_interest_area),
+      skewport_target_time_in_seconds_(skewport_target_time_in_seconds),
+      skewport_extrapolation_limit_in_content_pixels_(
+          skewport_extrapolation_limit_in_content_pixels),
+      client_(client) {
 }
 
 PictureLayerTilingSet::~PictureLayerTilingSet() {
@@ -57,8 +70,10 @@ void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSource(
 
       PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
       if (!this_tiling) {
-        scoped_ptr<PictureLayerTiling> new_tiling =
-            PictureLayerTiling::Create(contents_scale, layer_bounds, client_);
+        scoped_ptr<PictureLayerTiling> new_tiling = PictureLayerTiling::Create(
+            contents_scale, layer_bounds, client_, max_tiles_for_interest_area_,
+            skewport_target_time_in_seconds_,
+            skewport_extrapolation_limit_in_content_pixels_);
         tilings_.push_back(new_tiling.Pass());
         this_tiling = tilings_.back();
       }
@@ -222,9 +237,9 @@ bool PictureLayerTilingSet::SyncTilingsForTesting(
       continue;
     }
     scoped_ptr<PictureLayerTiling> new_tiling = PictureLayerTiling::Create(
-        contents_scale,
-        new_layer_bounds,
-        client_);
+        contents_scale, new_layer_bounds, client_, max_tiles_for_interest_area_,
+        skewport_target_time_in_seconds_,
+        skewport_extrapolation_limit_in_content_pixels_);
     new_tiling->set_resolution(other.tilings_[i]->resolution());
     if (new_tiling->resolution() == HIGH_RESOLUTION)
       have_high_res_tiling = true;
@@ -241,8 +256,10 @@ PictureLayerTiling* PictureLayerTilingSet::AddTiling(
   for (size_t i = 0; i < tilings_.size(); ++i)
     DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
 
-  tilings_.push_back(
-      PictureLayerTiling::Create(contents_scale, layer_bounds, client_));
+  tilings_.push_back(PictureLayerTiling::Create(
+      contents_scale, layer_bounds, client_, max_tiles_for_interest_area_,
+      skewport_target_time_in_seconds_,
+      skewport_extrapolation_limit_in_content_pixels_));
   PictureLayerTiling* appended = tilings_.back();
 
   tilings_.sort(LargestToSmallestScaleFunctor());