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

cc/tiles/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/tiles/picture_layer_tiling_set.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <set>
@@ skipping 25 matching lines @@
 const float kMaxSoonBorderDistanceInScreenPixels = 312.f;
 
 }  // namespace
 
 // static
 std::unique_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
     WhichTree tree,
     PictureLayerTilingClient* client,
     int tiling_interest_area_padding,
     float skewport_target_time_in_seconds,
-    int skewport_extrapolation_limit_in_screen_pixels) {
-  return base::WrapUnique(
-      new PictureLayerTilingSet(tree, client, tiling_interest_area_padding,
-                                skewport_target_time_in_seconds,
-                                skewport_extrapolation_limit_in_screen_pixels));
+    int skewport_extrapolation_limit_in_screen_pixels,
+    float max_preraster_distance) {
+  return base::WrapUnique(new PictureLayerTilingSet(
+      tree, client, tiling_interest_area_padding,
+      skewport_target_time_in_seconds,
+      skewport_extrapolation_limit_in_screen_pixels, max_preraster_distance));
 }
 
 PictureLayerTilingSet::PictureLayerTilingSet(
     WhichTree tree,
     PictureLayerTilingClient* client,
     int tiling_interest_area_padding,
     float skewport_target_time_in_seconds,
-    int skewport_extrapolation_limit_in_screen_pixels)
+    int skewport_extrapolation_limit_in_screen_pixels,
+    float max_preraster_distance)
     : tiling_interest_area_padding_(tiling_interest_area_padding),
       skewport_target_time_in_seconds_(skewport_target_time_in_seconds),
       skewport_extrapolation_limit_in_screen_pixels_(
           skewport_extrapolation_limit_in_screen_pixels),
       tree_(tree),
-      client_(client) {}
+      client_(client),
+      max_preraster_distance_(max_preraster_distance) {}
 
 PictureLayerTilingSet::~PictureLayerTilingSet() {
 }
 
 void PictureLayerTilingSet::CopyTilingsAndPropertiesFromPendingTwin(
     const PictureLayerTilingSet* pending_twin_set,
     scoped_refptr<RasterSource> raster_source,
     const Region& layer_invalidation) {
   if (pending_twin_set->tilings_.empty()) {
     // If the twin (pending) tiling set is empty, it was not updated for the
     // current frame. So we drop tilings from our set as well, instead of
     // leaving behind unshared tilings that are all non-ideal.
     RemoveAllTilings();
     return;
   }
 
   bool tiling_sort_required = false;
   for (const auto& pending_twin_tiling : pending_twin_set->tilings_) {
     float contents_scale = pending_twin_tiling->contents_scale();
     PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
     if (!this_tiling) {
       std::unique_ptr<PictureLayerTiling> new_tiling(new PictureLayerTiling(
-          tree_, contents_scale, raster_source_, client_));
+          tree_, contents_scale, raster_source_, client_,
+          kMaxSoonBorderDistanceInScreenPixels, max_preraster_distance_));
       tilings_.push_back(std::move(new_tiling));
       this_tiling = tilings_.back().get();
       tiling_sort_required = true;
       state_since_last_tile_priority_update_.added_tilings = true;
     }
     this_tiling->TakeTilesAndPropertiesFrom(pending_twin_tiling.get(),
                                             layer_invalidation);
   }
 
   if (tiling_sort_required) {
@@ skipping 167 matching lines @@
     scoped_refptr<RasterSource> raster_source) {
   if (!raster_source_)
     raster_source_ = raster_source;
 
   for (size_t i = 0; i < tilings_.size(); ++i) {
     DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
     DCHECK_EQ(tilings_[i]->raster_source(), raster_source.get());
   }
 
   tilings_.push_back(base::MakeUnique<PictureLayerTiling>(
-      tree_, contents_scale, raster_source, client_));
+      tree_, contents_scale, raster_source, client_,
+      kMaxSoonBorderDistanceInScreenPixels, max_preraster_distance_));
   PictureLayerTiling* appended = tilings_.back().get();
   state_since_last_tile_priority_update_.added_tilings = true;
 
   std::sort(tilings_.begin(), tilings_.end(), LargestToSmallestScaleFunctor());
   return appended;
 }
 
 int PictureLayerTilingSet::NumHighResTilings() const {
   return std::count_if(tilings_.begin(), tilings_.end(),
                        [](const std::unique_ptr<PictureLayerTiling>& tiling) {
@@ skipping 462 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