cc: Introduce a max ideal contents scale constant.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 38 matching lines @@
 const int kMinHeightForGpuRasteredTile = 256;
 
 // When making odd-sized tiles, round them up to increase the chances
 // of using the same tile size.
 const int kTileRoundUp = 64;
 
 // For performance reasons and to support compressed tile textures, tile
 // width and height should be an even multiple of 4 in size.
 const int kTileMinimalAlignment = 4;
 
+// Large contents scale can cause overflow issues. Cap the ideal contents scale
+// by this constant, since scales larger than this are usually not correct or
+// their scale doesn't matter as long as it's large. See
+// Renderer4.IdealContentsScale UMA for distribution of existing contents
+// scales.
+const float kMaxIdealContentsScale = 10000.f;
+
 // Intersect rects which may have right() and bottom() that overflow integer
 // boundaries. This code is similar to gfx::Rect::Intersect with the exception
 // that the types are promoted to int64_t when there is a chance of overflow.
 gfx::Rect SafeIntersectRects(const gfx::Rect& one, const gfx::Rect& two) {
   if (one.IsEmpty() || two.IsEmpty())
     return gfx::Rect();
 
   int rx = std::max(one.x(), two.x());
   int ry = std::max(one.y(), two.y());
   int64_t rr = std::min(static_cast<int64_t>(one.x()) + one.width(),
@@ skipping 1171 matching lines @@
 void PictureLayerImpl::UpdateIdealScales() {
   DCHECK(CanHaveTilings());
 
   float min_contents_scale = MinimumContentsScale();
   DCHECK_GT(min_contents_scale, 0.f);
 
   ideal_page_scale_ = IsAffectedByPageScale()
                           ? layer_tree_impl()->current_page_scale_factor()
                           : 1.f;
   ideal_device_scale_ = layer_tree_impl()->device_scale_factor();
-  ideal_contents_scale_ = std::max(GetIdealContentsScale(), min_contents_scale);
+  ideal_contents_scale_ =
+      std::min(kMaxIdealContentsScale,
+               std::max(GetIdealContentsScale(), min_contents_scale));
   ideal_source_scale_ =
       ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.IdealContentsScale",
                               ideal_contents_scale_, 0, 10000, 50);
 }
 
 void PictureLayerImpl::GetDebugBorderProperties(
     SkColor* color,
     float* width) const {
   if (is_directly_composited_image_) {
@@ skipping 66 matching lines @@
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() &&
          is_drawn_render_surface_layer_list_member();
 }
 
 }  // namespace cc