Update from https://crrev.com/308331

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_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)
-    : client_(client) {
+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() {
 }
 
-void PictureLayerTilingSet::SetClient(PictureLayerTilingClient* client) {
-  client_ = client;
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->SetClient(client_);
-}
+void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSource(
+    RasterSource* raster_source,
+    const PictureLayerTilingSet* twin_set,
+    const gfx::Size& layer_bounds,
+    const Region& layer_invalidation,
+    float minimum_contents_scale) {
+  RemoveTilingsBelowScale(minimum_contents_scale);
 
-void PictureLayerTilingSet::RemoveTilesInRegion(const Region& region) {
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->RemoveTilesInRegion(region);
+  // Copy over tilings that are shared with the |twin_set| tiling set (if it
+  // exists).
+  if (twin_set) {
+    for (PictureLayerTiling* twin_tiling : twin_set->tilings_) {
+      float contents_scale = twin_tiling->contents_scale();
+      DCHECK_GE(contents_scale, minimum_contents_scale);
+
+      PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
+      if (!this_tiling) {
+        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();
+      }
+      this_tiling->CloneTilesAndPropertiesFrom(*twin_tiling);
+    }
+  }
+
+  // For unshared tilings, invalidate tiles and update them to the new raster
+  // source.
+  for (PictureLayerTiling* tiling : tilings_) {
+    if (twin_set && twin_set->FindTilingWithScale(tiling->contents_scale()))
+      continue;
+
+    tiling->Resize(layer_bounds);
+    tiling->Invalidate(layer_invalidation);
+    tiling->SetRasterSource(raster_source);
+    // This is needed for cases where the live tiles rect didn't change but
+    // recordings exist in the raster source that did not exist on the last
+    // raster source.
+    tiling->CreateMissingTilesInLiveTilesRect();
+
+    // If |twin_set| is present, use the resolutions from there. Otherwise leave
+    // all resolutions as they are.
+    if (twin_set)
+      tiling->set_resolution(NON_IDEAL_RESOLUTION);
+  }
+
+  tilings_.sort(LargestToSmallestScaleFunctor());
+
+#if DCHECK_IS_ON
+  for (PictureLayerTiling* tiling : tilings_) {
+    DCHECK(tiling->tile_size() ==
+           client_->CalculateTileSize(tiling->tiling_size()))
+        << "tile_size: " << tiling->tile_size().ToString()
+        << " tiling_size: " << tiling->tiling_size().ToString()
+        << " CalculateTileSize: "
+        << client_->CalculateTileSize(tiling->tiling_size()).ToString();
+  }
+
+  if (!tilings_.empty()) {
+    size_t num_high_res = std::count_if(tilings_.begin(), tilings_.end(),
+                                        [](PictureLayerTiling* tiling) {
+      return tiling->resolution() == HIGH_RESOLUTION;
+    });
+    DCHECK_EQ(1u, num_high_res);
+  }
+#endif
 }
 
 void PictureLayerTilingSet::CleanUpTilings(
     float min_acceptable_high_res_scale,
     float max_acceptable_high_res_scale,
     const std::vector<PictureLayerTiling*>& needed_tilings,
     bool should_have_low_res,
     PictureLayerTilingSet* twin_set,
     PictureLayerTilingSet* recycled_twin_set) {
   float twin_low_res_scale = 0.f;
@@ skipping 22 matching lines @@
     // Don't remove tilings that are required.
     if (std::find(needed_tilings.begin(), needed_tilings.end(), tiling) !=
         needed_tilings.end()) {
       continue;
     }
 
     to_remove.push_back(tiling);
   }
 
   for (auto* tiling : to_remove) {
-    PictureLayerTiling* twin_tiling =
-        twin_set ? twin_set->FindTilingWithScale(tiling->contents_scale())
-                 : nullptr;
-    // Only remove tilings from the twin layer if they have
-    // NON_IDEAL_RESOLUTION.
-    if (twin_tiling && twin_tiling->resolution() == NON_IDEAL_RESOLUTION)
-      twin_set->Remove(twin_tiling);
-
     PictureLayerTiling* recycled_twin_tiling =
         recycled_twin_set
             ? recycled_twin_set->FindTilingWithScale(tiling->contents_scale())
             : nullptr;
     // Remove the tiling from the recycle tree. Note that we ignore resolution,
     // since we don't need to maintain high/low res on the recycle set.
     if (recycled_twin_tiling)
       recycled_twin_set->Remove(recycled_twin_tiling);
 
     DCHECK_NE(HIGH_RESOLUTION, tiling->resolution());
     Remove(tiling);
   }
 }
 
+void PictureLayerTilingSet::RemoveNonIdealTilings() {
+  auto to_remove = tilings_.remove_if([](PictureLayerTiling* t) {
+    return t->resolution() == NON_IDEAL_RESOLUTION;
+  });
+  tilings_.erase(to_remove, tilings_.end());
+}
+
 void PictureLayerTilingSet::MarkAllTilingsNonIdeal() {
   for (auto* tiling : tilings_)
     tiling->set_resolution(NON_IDEAL_RESOLUTION);
 }
 
-bool PictureLayerTilingSet::SyncTilings(const PictureLayerTilingSet& other,
-                                        const gfx::Size& new_layer_bounds,
-                                        const Region& layer_invalidation,
-                                        float minimum_contents_scale,
-                                        RasterSource* raster_source) {
+bool PictureLayerTilingSet::SyncTilingsForTesting(
+    const PictureLayerTilingSet& other,
+    const gfx::Size& new_layer_bounds,
+    const Region& layer_invalidation,
+    float minimum_contents_scale,
+    RasterSource* raster_source) {
   if (new_layer_bounds.IsEmpty()) {
     RemoveAllTilings();
     return false;
   }
 
   tilings_.reserve(other.tilings_.size());
 
   // Remove any tilings that aren't in |other| or don't meet the minimum.
   for (size_t i = 0; i < tilings_.size(); ++i) {
     float scale = tilings_[i]->contents_scale();
     if (scale >= minimum_contents_scale && !!other.FindTilingWithScale(scale))
       continue;
     // Swap with the last element and remove it.
     tilings_.swap(tilings_.begin() + i, tilings_.end() - 1);
     tilings_.pop_back();
     --i;
   }
 
   bool have_high_res_tiling = false;
 
   // Add any missing tilings from |other| that meet the minimum.
   for (size_t i = 0; i < other.tilings_.size(); ++i) {
     float contents_scale = other.tilings_[i]->contents_scale();
     if (contents_scale < minimum_contents_scale)
       continue;
     if (PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale)) {
       this_tiling->set_resolution(other.tilings_[i]->resolution());
 
-      this_tiling->UpdateTilesToCurrentRasterSource(
-          raster_source, layer_invalidation, new_layer_bounds);
+      this_tiling->Resize(new_layer_bounds);
+      this_tiling->Invalidate(layer_invalidation);
+      this_tiling->SetRasterSource(raster_source);
       this_tiling->CreateMissingTilesInLiveTilesRect();
       if (this_tiling->resolution() == HIGH_RESOLUTION)
         have_high_res_tiling = true;
 
       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 15 matching lines @@
     TileResolution resolution) const {
   auto iter = std::find_if(tilings_.begin(), tilings_.end(),
                            [resolution](const PictureLayerTiling* tiling) {
     return tiling->resolution() == resolution;
   });
   if (iter == tilings_.end())
     return NULL;
   return *iter;
 }
 
+void PictureLayerTilingSet::RemoveTilingsBelowScale(float minimum_scale) {
+  auto to_remove =
+      tilings_.remove_if([minimum_scale](PictureLayerTiling* tiling) {
+        return tiling->contents_scale() < minimum_scale;
+      });
+  tilings_.erase(to_remove, tilings_.end());
+}
+
 void PictureLayerTilingSet::RemoveAllTilings() {
   tilings_.clear();
 }
 
 void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) {
   ScopedPtrVector<PictureLayerTiling>::iterator iter =
     std::find(tilings_.begin(), tilings_.end(), tiling);
   if (iter == tilings_.end())
     return;
   tilings_.erase(iter);
@@ skipping 283 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