cc: Add flag to disable future mask 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 674 matching lines @@
   // cleared once the invalidation is drawn, which is useful for debugging
   // visualizations. This method intersects the two to give a more exact
   // representation of what was invalidated that is cleared after drawing.
   return IntersectRegions(invalidation_, update_rect());
 }
 
 std::unique_ptr<Tile> PictureLayerImpl::CreateTile(
     const Tile::CreateInfo& info) {
   int flags = 0;
 
-  // We don't handle solid color masks, so we shouldn't bother analyzing those.
+  // We don't handle solid color masks if mask tiling is disabled, we also don't
+  // handle solid color single texture masks if the flag is enabled, so we
+  // shouldn't bother analyzing those.
   // Otherwise, always analyze to maximize memory savings.
-  // TODO(sunxd): the condition should be (mask_type_ ==
-  // Layer::LayerMaskType::NOT_MASK
-  // || (layer_tree_impl()->settings().enable_mask_tiling && mask_type ==
-  // Layer::LayerMaskType::MULTI_TEXTURE_MASK)).
-  if (mask_type_ == Layer::LayerMaskType::NOT_MASK)
+  if (mask_type_ != Layer::LayerMaskType::SINGLE_TEXTURE_MASK)
     flags = Tile::USE_PICTURE_ANALYSIS;
 
   if (contents_opaque())
     flags |= Tile::IS_OPAQUE;
 
   return layer_tree_impl()->tile_manager()->CreateTile(
       info, id(), layer_tree_impl()->source_frame_number(), flags);
 }
 
 const Region* PictureLayerImpl::GetPendingInvalidation() {
@@ skipping 21 matching lines @@
 
 gfx::Rect PictureLayerImpl::GetEnclosingRectInTargetSpace() const {
   return GetScaledEnclosingRectInTargetSpace(MaximumTilingContentsScale());
 }
 
 gfx::Size PictureLayerImpl::CalculateTileSize(
     const gfx::Size& content_bounds) const {
   int max_texture_size =
       layer_tree_impl()->resource_provider()->max_texture_size();
 
-  // TODO(sunxd): the condition should be mask_type_ == Layer::LayerMaskType::
-  // SINGLE_TEXTURE_MASK || (mask_type_ ==
-  // Layer::LayerMaskType::MULTI_TEXTURE_MASK &&
-  // !layer_tree_impl()->settings().enable_mask_tiling)
-  if (mask_type_ != Layer::LayerMaskType::NOT_MASK) {
+  if (mask_type_ == Layer::LayerMaskType::SINGLE_TEXTURE_MASK) {
     // Masks are not tiled, so if we can't cover the whole mask with one tile,
     // 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()) {
@@ skipping 413 matching lines @@
   // 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 such that dimension * scale
-  // does not overflow.
-  // TODO(sunxd): the condition should be:
-  // mask_type_ == Layer::LayerMaskType::SINGLE_TEXTURE_MASK || (mask_type_ ==
-  // Layer::LayerMaskType::MULTI_TEXTURE_MASK && !layer_tree_impl()->settings().
-  // enable_mask_tiling)
+  // When mask tiling is disabled or the mask is single textured, 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 such
+  // that dimension * scale does not overflow.
   float max_dimension = static_cast<float>(
-      mask_type_ != Layer::LayerMaskType::NOT_MASK
+      mask_type_ == Layer::LayerMaskType::SINGLE_TEXTURE_MASK
           ? layer_tree_impl()->resource_provider()->max_texture_size()
           : std::numeric_limits<int>::max());
   float max_scale_width = max_dimension / bounds().width();
   float max_scale_height = max_dimension / 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_dimension|. 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
@@ skipping 196 matching lines @@
   }
 
   invalidation_.Union(invalidation);
   tilings_->UpdateTilingsForImplSideInvalidation(invalidation);
   SetNeedsPushProperties();
   TRACE_EVENT_END1("cc", "PictureLayerImpl::InvalidateRegionForImages",
                    "Invalidation", invalidation.ToString());
 }
 
 }  // namespace cc