cc: Don't cleanup the pending twin's low res tiling.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 1203 matching lines @@
 void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
     std::vector<PictureLayerTiling*> used_tilings) {
   DCHECK(layer_tree_impl()->IsActiveTree());
   if (tilings_->num_tilings() == 0)
     return;
 
   float min_acceptable_high_res_scale = std::min(
       raster_contents_scale_, ideal_contents_scale_);
   float max_acceptable_high_res_scale = std::max(
       raster_contents_scale_, ideal_contents_scale_);
+  float twin_low_res_scale = 0.f;
 
   PictureLayerImpl* twin = twin_layer_;
   if (twin) {
     min_acceptable_high_res_scale = std::min(
         min_acceptable_high_res_scale,
         std::min(twin->raster_contents_scale_, twin->ideal_contents_scale_));
     max_acceptable_high_res_scale = std::max(
         max_acceptable_high_res_scale,
         std::max(twin->raster_contents_scale_, twin->ideal_contents_scale_));
+
+    for (size_t i = 0; i < twin->tilings_->num_tilings(); ++i) {
+      PictureLayerTiling* tiling = twin->tilings_->tiling_at(i);
+      if (tiling->resolution() == LOW_RESOLUTION)
+        twin_low_res_scale = tiling->contents_scale();
+    }
   }
 
   std::vector<PictureLayerTiling*> to_remove;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
     // Keep multiple high resolution tilings even if not used to help
     // activate earlier at non-ideal resolutions.
     if (tiling->contents_scale() >= min_acceptable_high_res_scale &&
         tiling->contents_scale() <= max_acceptable_high_res_scale)
       continue;
 
     // Keep low resolution tilings, if the layer should have them.
-    if (tiling->resolution() == LOW_RESOLUTION &&
-        layer_tree_impl()->create_low_res_tiling())
-      continue;
+    if (layer_tree_impl()->create_low_res_tiling()) {
+      if (tiling->resolution() == LOW_RESOLUTION ||
+          tiling->contents_scale() == twin_low_res_scale)
+        continue;
+    }
 
     // Don't remove tilings that are being used (and thus would cause a flash.)
     if (std::find(used_tilings.begin(), used_tilings.end(), tiling) !=
         used_tilings.end())
       continue;
 
     to_remove.push_back(tiling);
   }
 
   for (size_t i = 0; i < to_remove.size(); ++i) {
@@ skipping 380 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc