cc: Don't swap PictureLayerTilingSet on activate.

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 22 matching lines @@
   return make_scoped_ptr(new PictureLayerTilingSet(client));
 }
 
 PictureLayerTilingSet::PictureLayerTilingSet(PictureLayerTilingClient* client)
     : 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_) {

[vmpstr, 2014/12/09 00:10:19]

I feel like we could do better in terms of speed.. Like compute all three sets
ahead of time (in both, in twin only, in this only) in one pass, and then
update/create/invalidate in the other pass. I also think this is fine to leave
for later :)

[danakj, 2014/12/09 18:20:23]

Writing something much faster here would be very complicated code in comparison
(like using the knowledge it's sorted by scale and then traversing both this and
other tiling lists kinda like a merge sort.. I'm not convinced it will matter
esp since the FindTilingWithScale is looking at <= 2 (or actually 1 on desktop)
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_);
+        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);
+    // TODO(danakj): Is this needed anymore? Won't they already exist?
+    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) -> bool {

[vmpstr, 2014/12/09 00:10:19]

-> bool is optional here? Or are we requiring it?

[danakj, 2014/12/09 18:20:23]

"However, if a lambda has one statement and that statement is a return statement
(and it returns an expression), the compiler can deduce the return type from the
type of that one returned expression. You have multiple statements in your
lambda, so it doesn't deduce the type."

Woa.

+    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();
@@ skipping 49 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) -> bool {
+        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