Update from https://crrev.com/309415

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 <cmath>
 #include <limits>
 #include <set>
 
 #include "base/debug/trace_event_argument.h"
 #include "base/time/time.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/micro_benchmark_impl.h"
 #include "cc/debug/traced_value.h"
@@ skipping 229 matching lines @@
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(),
              max_contents_scale,
              scaled_visible_content_rect,
              ideal_contents_scale_);
          iter;
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->IsReadyToDraw()) {
-        ManagedTileState::DrawInfo::Mode mode = iter->draw_info().mode();
-        if (mode == ManagedTileState::DrawInfo::SOLID_COLOR_MODE) {
+        TileDrawInfo::Mode mode = iter->draw_info().mode();
+        if (mode == TileDrawInfo::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
-        } else if (mode == ManagedTileState::DrawInfo::PICTURE_PILE_MODE) {
+        } else if (mode == TileDrawInfo::PICTURE_PILE_MODE) {
           color = DebugColors::PictureTileBorderColor();
           width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         } else if (iter.resolution() == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
         } else if (iter->contents_scale() > max_contents_scale) {
           color = DebugColors::ExtraHighResTileBorderColor();
@@ skipping 43 matching lines @@
     gfx::Rect visible_geometry_rect =
         scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
     if (visible_geometry_rect.IsEmpty())
       continue;
 
     append_quads_data->visible_content_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
     bool has_draw_quad = false;
     if (*iter && iter->IsReadyToDraw()) {
-      const ManagedTileState::DrawInfo& draw_info = iter->draw_info();
+      const TileDrawInfo& draw_info = iter->draw_info();
       switch (draw_info.mode()) {
-        case ManagedTileState::DrawInfo::RESOURCE_MODE: {
+        case TileDrawInfo::RESOURCE_MODE: {
           gfx::RectF texture_rect = iter.texture_rect();
 
           // The raster_contents_scale_ is the best scale that the layer is
           // trying to produce, even though it may not be ideal. Since that's
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
           // scale.
           if (iter->contents_scale() != raster_contents_scale_ &&
               iter->contents_scale() != ideal_contents_scale_ &&
               geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
             append_quads_data->num_incomplete_tiles++;
           }
 
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        opaque_rect,
                        visible_geometry_rect,
                        draw_info.get_resource_id(),
                        texture_rect,
                        iter.texture_size(),
                        draw_info.contents_swizzled(),
                        nearest_neighbor_);
           has_draw_quad = true;
           break;
         }
-        case ManagedTileState::DrawInfo::PICTURE_PILE_MODE: {
+        case TileDrawInfo::PICTURE_PILE_MODE: {
           if (!layer_tree_impl()
                    ->GetRendererCapabilities()
                    .allow_rasterize_on_demand) {
             ++on_demand_missing_tile_count;
             break;
           }
 
           gfx::RectF texture_rect = iter.texture_rect();
 
           ResourceProvider* resource_provider =
               layer_tree_impl()->resource_provider();
           ResourceFormat format =
               resource_provider->memory_efficient_texture_format();
           PictureDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                        visible_geometry_rect, texture_rect, iter.texture_size(),
                        nearest_neighbor_, format, iter->content_rect(),
                        iter->contents_scale(), raster_source_);
           has_draw_quad = true;
           break;
         }
-        case ManagedTileState::DrawInfo::SOLID_COLOR_MODE: {
+        case TileDrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        visible_geometry_rect,
                        draw_info.get_solid_color(),
                        false);
           has_draw_quad = true;
           break;
         }
@@ skipping 201 matching lines @@
 
   if (!can_have_tilings) {
     RemoveAllTilings();
     return;
   }
 
   // We could do this after doing UpdateTiles, which would avoid doing this for
   // tilings that are going to disappear on the pending tree (if scale changed).
   // But that would also be more complicated, so we just do it here for now.
   tilings_->UpdateTilingsToCurrentRasterSource(
-      raster_source_.get(), pending_set, invalidation_, MinimumContentsScale());
+      raster_source_, pending_set, invalidation_, MinimumContentsScale(),
+      MaximumContentsScale());
 }
 
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
   if (layer_tree_impl()->IsActiveTree()) {
     gfx::RectF layer_damage_rect =
         gfx::ScaleRect(tile->content_rect(), 1.f / tile->contents_scale());
     AddDamageRect(layer_damage_rect);
   }
 }
 
@@ skipping 17 matching lines @@
   // To avoid an edge case after lost context where the tree is up to date but
   // the tilings have not been managed, request an update draw properties
   // to force tilings to get managed.
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return raster_source_->GetFlattenedPicture();
 }
 
-scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
-                                               const gfx::Rect& content_rect) {
-  DCHECK(!raster_source_->IsSolidColor());
-  if (!raster_source_->CoversRect(content_rect, tiling->contents_scale()))
-    return scoped_refptr<Tile>();
-
+scoped_refptr<Tile> PictureLayerImpl::CreateTile(
+    float contents_scale,
+    const gfx::Rect& content_rect) {
   int flags = 0;
 
   // We don't handle solid color masks, so we shouldn't bother analyzing those.
   // Otherwise, always analyze to maximize memory savings.
   if (!is_mask_)
     flags = Tile::USE_PICTURE_ANALYSIS;
 
   return layer_tree_impl()->tile_manager()->CreateTile(
-      raster_source_.get(), content_rect.size(), content_rect,
-      tiling->contents_scale(), id(), layer_tree_impl()->source_frame_number(),
-      flags);
+      raster_source_.get(), content_rect.size(), content_rect, contents_scale,
+      id(), layer_tree_impl()->source_frame_number(), flags);
 }
 
 const Region* PictureLayerImpl::GetPendingInvalidation() {
   if (layer_tree_impl()->IsPendingTree())
     return &invalidation_;
   if (layer_tree_impl()->IsRecycleTree())
     return nullptr;
   DCHECK(layer_tree_impl()->IsActiveTree());
   if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
     return &twin_layer->invalidation_;
@@ skipping 26 matching lines @@
   return layer_tree_impl()->RequiresHighResToDraw();
 }
 
 gfx::Size PictureLayerImpl::CalculateTileSize(
     const gfx::Size& content_bounds) const {
   int max_texture_size =
       layer_tree_impl()->resource_provider()->max_texture_size();
 
   if (is_mask_) {
     // Masks are not tiled, so if we can't cover the whole mask with one tile,
-    // don't make any tiles at all. Returning an empty size signals this.
-    if (content_bounds.width() > max_texture_size ||
-        content_bounds.height() > max_texture_size)
-      return gfx::Size();
+    // we shouldn't have such a tiling at all.
+    DCHECK_LE(content_bounds.width(), max_texture_size);
+    DCHECK_LE(content_bounds.height(), max_texture_size);
     return content_bounds;
   }
 
   int default_tile_width = 0;
   int default_tile_height = 0;
   if (layer_tree_impl()->use_gpu_rasterization()) {
     // For GPU rasterization, we pick an ideal tile size using the viewport
     // so we don't need any settings. The current approach uses 4 tiles
     // to cover the viewport vertically.
     int viewport_width = layer_tree_impl()->device_viewport_size().width();
@@ skipping 70 matching lines @@
   if (!iter || !*iter) {
     *resource_id = 0;
     return;
   }
 
   // Masks only supported if they fit on exactly one tile.
   DCHECK(iter.geometry_rect() == content_rect)
       << "iter rect " << iter.geometry_rect().ToString() << " content rect "
       << content_rect.ToString();
 
-  const ManagedTileState::DrawInfo& draw_info = iter->draw_info();
+  const TileDrawInfo& draw_info = iter->draw_info();
   if (!draw_info.IsReadyToDraw() ||
-      draw_info.mode() != ManagedTileState::DrawInfo::RESOURCE_MODE) {
+      draw_info.mode() != TileDrawInfo::RESOURCE_MODE) {
     *resource_id = 0;
     return;
   }
 
   *resource_id = draw_info.get_resource_id();
   *resource_size = iter.texture_size();
 }
 
 void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) {
   if (nearest_neighbor_ == nearest_neighbor)
     return;
 
   nearest_neighbor_ = nearest_neighbor;
   NoteLayerPropertyChanged();
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
-  DCHECK(CanHaveTilingWithScale(contents_scale)) <<
-      "contents_scale: " << contents_scale;
-
-  PictureLayerTiling* tiling =
-      tilings_->AddTiling(contents_scale, raster_source_->GetSize());
-
+  DCHECK(CanHaveTilings());
+  DCHECK_GE(contents_scale, MinimumContentsScale());
+  DCHECK_LE(contents_scale, MaximumContentsScale());
   DCHECK(raster_source_->HasRecordings());
-
-  return tiling;
+  return tilings_->AddTiling(contents_scale, raster_source_);
 }
 
 void PictureLayerImpl::RemoveAllTilings() {
   if (tilings_)
     tilings_->RemoveAllTilings();
   // If there are no tilings, then raster scales are no longer meaningful.
   ResetRasterScale();
 }
 
 void PictureLayerImpl::AddTilingsForRasterScale() {
@@ skipping 71 matching lines @@
   if (raster_device_scale_ != ideal_device_scale_)
     return true;
 
   // 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;
 
+  if (raster_contents_scale_ > MaximumContentsScale())
+    return true;
+  if (raster_contents_scale_ < MinimumContentsScale())
+    return true;
+
   return false;
 }
 
 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_;
@@ skipping 70 matching lines @@
     // the ideal scale here. The current ideal scale may be way too large in the
     // case of an animation with scale, and will be constantly changing.
     if (can_raster_at_maximum_scale)
       raster_contents_scale_ = maximum_scale;
     else
       raster_contents_scale_ = 1.f * ideal_page_scale_ * ideal_device_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
+  raster_contents_scale_ =
+      std::min(raster_contents_scale_, MaximumContentsScale());
+  DCHECK_GE(raster_contents_scale_, MinimumContentsScale());
+  DCHECK_LE(raster_contents_scale_, MaximumContentsScale());
 
   // If this layer would create zero or one tiles at this content scale,
   // don't create a low res tiling.
   gfx::Size raster_bounds = gfx::ToCeiledSize(
       gfx::ScaleSize(raster_source_->GetSize(), raster_contents_scale_));
   gfx::Size tile_size = CalculateTileSize(raster_bounds);
   bool tile_covers_bounds = tile_size.width() >= raster_bounds.width() &&
                             tile_size.height() >= raster_bounds.height();
   if (tile_size.IsEmpty() || tile_covers_bounds) {
     low_res_raster_contents_scale_ = raster_contents_scale_;
     return;
   }
 
   float low_res_factor =
       layer_tree_impl()->settings().low_res_contents_scale_factor;
-  low_res_raster_contents_scale_ = std::max(
-      raster_contents_scale_ * low_res_factor,
-      MinimumContentsScale());
+  low_res_raster_contents_scale_ =
+      std::max(raster_contents_scale_ * low_res_factor, MinimumContentsScale());
   DCHECK_LE(low_res_raster_contents_scale_, raster_contents_scale_);
   DCHECK_GE(low_res_raster_contents_scale_, MinimumContentsScale());
+  DCHECK_LE(low_res_raster_contents_scale_, MaximumContentsScale());
 }
 
 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_);
@@ skipping 35 matching lines @@
   // dimension.  Bump the minimum contents scale up in this case to prevent
   // this from happening.
   int min_dimension = std::min(raster_source_->GetSize().width(),
                                raster_source_->GetSize().height());
   if (!min_dimension)
     return setting_min;
 
   return std::max(1.f / min_dimension, setting_min);
 }
 
+float PictureLayerImpl::MaximumContentsScale() const {
+  // Masks can not have tilings that would become larger than the
+  // max_texture_size since they use a single tile for the entire
+  // tiling. Other layers can have tilings of any scale.
+  if (!is_mask_)
+    return std::numeric_limits<float>::max();
+
+  int max_texture_size =
+      layer_tree_impl()->resource_provider()->max_texture_size();
+  float max_scale_width =
+      static_cast<float>(max_texture_size) / bounds().width();
+  float max_scale_height =
+      static_cast<float>(max_texture_size) / bounds().height();
+  float max_scale = std::min(max_scale_width, max_scale_height);
+  // We require that multiplying the layer size by the contents scale and
+  // ceiling produces a value <= |max_texture_size|. Because for large layer
+  // sizes floating point ambiguity may crop up, making the result larger or
+  // smaller than expected, we use a slightly smaller floating point value for
+  // the scale, to help ensure that the resulting content bounds will never end
+  // up larger than |max_texture_size|.
+  return nextafterf(max_scale, 0.f);
+}
+
 void PictureLayerImpl::ResetRasterScale() {
   raster_page_scale_ = 0.f;
   raster_device_scale_ = 0.f;
   raster_source_scale_ = 0.f;
   raster_contents_scale_ = 0.f;
   low_res_raster_contents_scale_ = 0.f;
   raster_source_scale_is_fixed_ = false;
 
   // When raster scales aren't valid, don't update tile priorities until
   // this layer has been updated via UpdateDrawProperties.
   should_update_tile_priorities_ = false;
 }
 
 bool PictureLayerImpl::CanHaveTilings() const {
   if (raster_source_->IsSolidColor())
     return false;
   if (!DrawsContent())
     return false;
   if (!raster_source_->HasRecordings())
     return false;
   // If the |raster_source_| has a recording it should have non-empty bounds.
   DCHECK(!raster_source_->GetSize().IsEmpty());
-  return true;
-}
-
-bool PictureLayerImpl::CanHaveTilingWithScale(float contents_scale) const {
-  if (!CanHaveTilings())
-    return false;
-  if (contents_scale < MinimumContentsScale())
+  if (MaximumContentsScale() < MinimumContentsScale())
     return false;
   return true;
 }
 
 void PictureLayerImpl::SanityCheckTilingState() const {
 #if DCHECK_IS_ON
   // Recycle tree doesn't have any restrictions.
   if (layer_tree_impl()->IsRecycleTree())
     return;
 
@@ skipping 186 matching lines @@
 
 bool PictureLayerImpl::AllTilesRequiredForDrawAreReadyToDraw() const {
   if (!layer_tree_impl()->IsActiveTree())
     return true;
 
   return AllTilesRequiredAreReadyToDraw(
       &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
 }
 
 }  // namespace cc