Update from https://crrev.com/304715

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 <set>
 
@@ skipping 627 matching lines @@
 }
 
 const PictureLayerTiling* PictureLayerImpl::GetPendingOrActiveTwinTiling(
     const PictureLayerTiling* tiling) const {
   PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
   if (!twin_layer)
     return nullptr;
   // TODO(danakj): Remove this when no longer swapping tilings.
   if (!twin_layer->tilings_)
     return nullptr;
-  return twin_layer->tilings_->TilingAtScale(tiling->contents_scale());
+  return twin_layer->tilings_->FindTilingWithScale(tiling->contents_scale());
 }
 
 PictureLayerTiling* PictureLayerImpl::GetRecycledTwinTiling(
     const PictureLayerTiling* tiling) {
   PictureLayerImpl* recycled_twin = GetRecycledTwinLayer();
   if (!recycled_twin || !recycled_twin->tilings_)
     return nullptr;
-  return recycled_twin->tilings_->TilingAtScale(tiling->contents_scale());
+  return recycled_twin->tilings_->FindTilingWithScale(tiling->contents_scale());
 }
 
 TilePriority::PriorityBin PictureLayerImpl::GetMaxTilePriorityBin() const {
   if (!HasValidTilePriorities())
     return TilePriority::EVENTUALLY;
   return TilePriority::NOW;
 }
 
 size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
   return layer_tree_impl()->settings().max_tiles_for_interest_area;
@@ skipping 215 matching lines @@
   if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
     twin_layer->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
   if (!tilings_ || tilings_->num_tilings() == 0)
     return;
 
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = tilings_->tiling_at(i);
-    if (tiling->contents_scale() == contents_scale) {
-      tilings_->Remove(tiling);
-      break;
-    }
-  }
+  tilings_->RemoveTilingWithScale(contents_scale);
   if (tilings_->num_tilings() == 0)
     ResetRasterScale();
   SanityCheckTilingState();
 }
 
 void PictureLayerImpl::RemoveAllTilings() {
   if (tilings_)
     tilings_->RemoveAllTilings();
   // If there are no tilings, then raster scales are no longer meaningful.
   ResetRasterScale();
 }
 
-namespace {
+void PictureLayerImpl::AddTilingsForRasterScale() {
+  // Reset all resolution enums on tilings, we'll be setting new values in this
+  // function.
+  tilings_->MarkAllTilingsNonIdeal();
 
-inline float PositiveRatio(float float1, float float2) {
-  DCHECK_GT(float1, 0);
-  DCHECK_GT(float2, 0);
-  return float1 > float2 ? float1 / float2 : float2 / float1;
-}
+  PictureLayerTiling* high_res =
+      tilings_->FindTilingWithScale(raster_contents_scale_);
+  // We always need a high res tiling, so create one if it doesn't exist.
+  if (!high_res)
+    high_res = AddTiling(raster_contents_scale_);
 
-}  // namespace
-
-void PictureLayerImpl::AddTilingsForRasterScale() {
-  PictureLayerTiling* high_res = nullptr;
+  // Try and find a low res tiling.
   PictureLayerTiling* low_res = nullptr;
-
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = tilings_->tiling_at(i);
-    if (tiling->contents_scale() == raster_contents_scale_)
-      high_res = tiling;
-    if (tiling->contents_scale() == low_res_raster_contents_scale_)
-      low_res = tiling;
-
-    // Reset all tilings to non-ideal until the end of this function.
-    tiling->set_resolution(NON_IDEAL_RESOLUTION);
-  }
-
-  if (!high_res) {
-    high_res = AddTiling(raster_contents_scale_);
-    if (raster_contents_scale_ == low_res_raster_contents_scale_)
-      low_res = high_res;
-  }
+  if (raster_contents_scale_ == low_res_raster_contents_scale_)
+    low_res = high_res;
+  else
+    low_res = tilings_->FindTilingWithScale(low_res_raster_contents_scale_);
 
   // Only create new low res tilings when the transform is static.  This
   // prevents wastefully creating a paired low res tiling for every new high res
   // tiling during a pinch or a CSS animation.
+  bool can_have_low_res = layer_tree_impl()->create_low_res_tiling();
+  bool needs_low_res = !low_res;
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
-  if (layer_tree_impl()->create_low_res_tiling() && !is_pinching &&
-      !draw_properties().screen_space_transform_is_animating && !low_res &&
-      low_res != high_res)
+  bool is_animating = draw_properties().screen_space_transform_is_animating;
+  if (can_have_low_res && needs_low_res && !is_pinching && !is_animating)
     low_res = AddTiling(low_res_raster_contents_scale_);
 
   // Set low-res if we have one.
   if (low_res && low_res != high_res)
     low_res->set_resolution(LOW_RESOLUTION);
 
   // Make sure we always have one high-res (even if high == low).
   high_res->set_resolution(HIGH_RESOLUTION);
 
   SanityCheckTilingState();
@@ skipping 33 matching lines @@
   // When the source scale changes we want to match it, but not when animating
   // or when we've fixed the scale in place.
   if (!draw_properties().screen_space_transform_is_animating &&
       !raster_source_scale_is_fixed_ &&
       raster_source_scale_ != ideal_source_scale_)
     return true;
 
   return false;
 }
 
-float PictureLayerImpl::SnappedContentsScale(float scale) {
-  // If a tiling exists within the max snapping ratio, snap to its scale.
-  float snapped_contents_scale = scale;
-  float snapped_ratio = kSnapToExistingTilingRatio;
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    float tiling_contents_scale = tilings_->tiling_at(i)->contents_scale();
-    float ratio = PositiveRatio(tiling_contents_scale, scale);
-    if (ratio < snapped_ratio) {
-      snapped_contents_scale = tiling_contents_scale;
-      snapped_ratio = ratio;
-    }
-  }
-  return snapped_contents_scale;
-}
-
 void PictureLayerImpl::RecalculateRasterScales() {
   float old_raster_contents_scale = raster_contents_scale_;
   float old_raster_page_scale = raster_page_scale_;
   float old_raster_source_scale = raster_source_scale_;
 
   raster_device_scale_ = ideal_device_scale_;
   raster_page_scale_ = ideal_page_scale_;
   raster_source_scale_ = ideal_source_scale_;
   raster_contents_scale_ = ideal_contents_scale_;
 
@@ skipping 24 matching lines @@
     // - When zooming in, approximate ideal using multiple of kMaxScaleRatio.
     bool zooming_out = old_raster_page_scale > ideal_page_scale_;
     float desired_contents_scale = old_raster_contents_scale;
     if (zooming_out) {
       while (desired_contents_scale > ideal_contents_scale_)
         desired_contents_scale /= kMaxScaleRatioDuringPinch;
     } else {
       while (desired_contents_scale < ideal_contents_scale_)
         desired_contents_scale *= kMaxScaleRatioDuringPinch;
     }
-    raster_contents_scale_ = SnappedContentsScale(desired_contents_scale);
+    raster_contents_scale_ = tilings_->GetSnappedContentsScale(
+        desired_contents_scale, kSnapToExistingTilingRatio);
     raster_page_scale_ =
         raster_contents_scale_ / raster_device_scale_ / raster_source_scale_;
   }
 
   // If we're not re-rasterizing during animation, rasterize at the maximum
   // scale that will occur during the animation, if the maximum scale is
   // known. However we want to avoid excessive memory use. If the scale is
   // smaller than what we would choose otherwise, then it's always better off
   // for us memory-wise. But otherwise, we don't choose a scale at which this
   // layer's rastered content would become larger than the viewport.
@@ skipping 63 matching lines @@
     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_));
 
     // TODO(danakj): Remove the tilings_ check when we create them in the
     // constructor.
     if (twin->tilings_) {
-      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();
-      }
+      PictureLayerTiling* tiling =
+          twin->tilings_->FindTilingWithResolution(LOW_RESOLUTION);
+      if (tiling)
+        twin_low_res_scale = tiling->contents_scale();
     }
   }
 
+  // TODO(vmpstr): Put this logic into PictureLayerTilingSet.
   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;
 
@@ skipping 99 matching lines @@
   // We should only have one high res tiling.
   DCHECK_EQ(1, tilings_->NumHighResTilings());
 #endif
 }
 
 bool PictureLayerImpl::ShouldAdjustRasterScaleDuringScaleAnimations() const {
   return layer_tree_impl()->use_gpu_rasterization();
 }
 
 float PictureLayerImpl::MaximumTilingContentsScale() const {
-  float max_contents_scale = MinimumContentsScale();
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    const PictureLayerTiling* tiling = tilings_->tiling_at(i);
-    max_contents_scale = std::max(max_contents_scale, tiling->contents_scale());
-  }
-  return max_contents_scale;
+  float max_contents_scale = tilings_->GetMaximumContentsScale();
+  return std::max(max_contents_scale, MinimumContentsScale());
 }
 
 void PictureLayerImpl::UpdateIdealScales() {
   DCHECK(CanHaveTilings());
 
   float min_contents_scale = MinimumContentsScale();
   DCHECK_GT(min_contents_scale, 0.f);
   float min_page_scale = layer_tree_impl()->min_page_scale_factor();
   DCHECK_GT(min_page_scale, 0.f);
   float min_device_scale = 1.f;
@@ skipping 15 matching lines @@
     SkColor* color,
     float* width) const {
   *color = DebugColors::TiledContentLayerBorderColor();
   *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
 }
 
 void PictureLayerImpl::GetAllTilesForTracing(
     std::set<const Tile*>* tiles) const {
   if (!tilings_)
     return;
-
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i)
-    tilings_->tiling_at(i)->GetAllTilesForTracing(tiles);
+  tilings_->GetAllTilesForTracing(tiles);
 }
 
 void PictureLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   LayerImpl::AsValueInto(state);
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->SetDouble("geometry_contents_scale", MaximumTilingContentsScale());
   state->BeginArray("tilings");
   tilings_->AsValueInto(state);
   state->EndArray();
@@ skipping 61 matching lines @@
 
   if (!tilings_)
     return true;
 
   if (visible_rect_for_tile_priority_.IsEmpty())
     return true;
 
   gfx::Rect rect = GetViewportForTilePriorityInContentSpace();
   rect.Intersect(visible_rect_for_tile_priority_);
 
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = tilings_->tiling_at(i);
-    if (tiling->resolution() != HIGH_RESOLUTION &&
-        tiling->resolution() != LOW_RESOLUTION)
+  // The high resolution tiling is the only tiling that can mark tiles as
+  // requiring either draw or activation. There is an explicit check in those
+  // callbacks to return false if they are not high resolution tilings. This
+  // check needs to remain since there are other callers of that function that
+  // rely on it. However, for the purposes of this function, we don't have to
+  // check other tilings.
+  PictureLayerTiling* tiling =
+      tilings_->FindTilingWithResolution(HIGH_RESOLUTION);
+  if (!tiling)
+    return true;
+
+  for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
+       ++iter) {
+    const Tile* tile = *iter;
+    // A null tile (i.e. missing recording) can just be skipped.
+    // TODO(vmpstr): Verify this is true if we create tiles in raster
+    // iterators.
+    if (!tile)
       continue;
 
-    for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
-         ++iter) {
-      const Tile* tile = *iter;
-      // A null tile (i.e. missing recording) can just be skipped.
-      // TODO(vmpstr): Verify this is true if we create tiles in raster
-      // iterators.
-      if (!tile)
-        continue;
-
-      // We can't check tile->required_for_activation, because that value might
-      // be out of date. It is updated in the raster/eviction iterators.
-      // TODO(vmpstr): Remove the comment once you can't access this information
-      // from the tile.
-      if ((tiling->*is_tile_required_callback)(tile) &&
-          !tile->IsReadyToDraw()) {
-        TRACE_EVENT_INSTANT0("cc", "Tile required, but not ready to draw.",
-                             TRACE_EVENT_SCOPE_THREAD);
-        return false;
-      }
+    // We can't check tile->required_for_activation, because that value might
+    // be out of date. It is updated in the raster/eviction iterators.
+    // TODO(vmpstr): Remove the comment once you can't access this information
+    // from the tile.
+    if ((tiling->*is_tile_required_callback)(tile) && !tile->IsReadyToDraw()) {
+      TRACE_EVENT_INSTANT0("cc", "Tile required, but not ready to draw.",
+                           TRACE_EVENT_SCOPE_THREAD);
+      return false;
     }
   }
 
   return true;
 }
 
 bool PictureLayerImpl::AllTilesRequiredForActivationAreReadyToDraw() const {
   if (!layer_tree_impl()->IsPendingTree())
     return true;
 
@@ skipping 276 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc