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

cc/resources/picture_layer_tiling_set.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/resources/picture_layer_tiling_set.h"
 
 #include <limits>
 #include <set>
 #include <vector>
 
@@ skipping 11 matching lines @@
 inline float LargerRatio(float float1, float float2) {
   DCHECK_GT(float1, 0.f);
   DCHECK_GT(float2, 0.f);
   return float1 > float2 ? float1 / float2 : float2 / float1;
 }
 
 }  // namespace
 
 // static
 scoped_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
-    PictureLayerTilingClient* client) {
-  return make_scoped_ptr(new PictureLayerTilingSet(client));
+    PictureLayerTilingClient* client,
+    size_t max_tiles_for_interest_area,
+    float skewport_target_time_in_seconds,
+    int skewport_extrapolation_limit_in_content) {
+  auto set = make_scoped_ptr(new PictureLayerTilingSet(client));
+  set->SetMaxTilesForInterestArea(max_tiles_for_interest_area);
+  set->SetSkewportTargetTimeInSeconds(skewport_target_time_in_seconds);
+  set->SetSkewportExtrapolationLimitInContentPixels(
+      skewport_extrapolation_limit_in_content);
+  return set;
 }
 
 PictureLayerTilingSet::PictureLayerTilingSet(PictureLayerTilingClient* client)
-    : client_(client) {
+    : max_tiles_for_interest_area_(0u),
+      skewport_target_time_in_seconds_(0.f),
+      skewport_extrapolation_limit_in_content_pixels_(0),
+      client_(client) {
 }
 
 PictureLayerTilingSet::~PictureLayerTilingSet() {
 }
 
 void PictureLayerTilingSet::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->SetClient(client_);
 }
@@ skipping 111 matching lines @@
 
       DCHECK(this_tiling->tile_size() ==
              client_->CalculateTileSize(this_tiling->tiling_size()))
           << "tile_size: " << this_tiling->tile_size().ToString()
           << " tiling_size: " << this_tiling->tiling_size().ToString()
           << " CalculateTileSize: "
           << client_->CalculateTileSize(this_tiling->tiling_size()).ToString();
       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;
     tilings_.push_back(new_tiling.Pass());
   }
   tilings_.sort(LargestToSmallestScaleFunctor());
 
   return have_high_res_tiling;
 }
 
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(
     float contents_scale,
     const gfx::Size& layer_bounds) {
   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());
   return appended;
 }
 
 int PictureLayerTilingSet::NumHighResTilings() const {
   int num_high_res = 0;
   for (size_t i = 0; i < tilings_.size(); ++i) {
     if (tilings_[i]->resolution() == HIGH_RESOLUTION)
@@ skipping 318 matching lines @@
     case LOWER_THAN_LOW_RES:
       range = TilingRange(low_res_range.end, tilings_.size());
       break;
   }
 
   DCHECK_LE(range.start, range.end);
   return range;
 }
 
 }  // namespace cc