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::NOT_MASK ||
+      (layer_tree_impl()->settings().enable_mask_tiling &&
+       mask_type_ == Layer::LayerMaskType::MULTI_TEXTURE_MASK))

[enne (OOO), 2017/02/10 22:24:34]

Maybe setting the mask type should just ignore this and set SINGLE_TEXTURE_MASK
when not supported and then you don't have to check it everywhere? 
Alternatively the caller of set mask type should do this?

I guess this is feedback for the last patch, but seeing these conditionals make
me wonder if that woudl be cleaner.

[trchen, 2017/02/11 00:21:16]

+1 to enne@

I think it is cleaner to change layer.cc:422
< if (inputs_.filters.IsEmpty()) {
The null check is needed because the layer could be detached at the time. We
need to double check when it's actually attached.

void PictureLayer::SetLayerTreeHost(LayerTreeHost* host) {
  if (host && !host->settings().enable_mask_tiling && mask_type_ ==
LayerMaskType::MULTI_TEXTURE_MASK)
    mask_type_ = LayerMaskType::SINGLE_TEXTURE_MASK;
}

It's still gross, but grossness is more contained this way IMO. :/

[sunxd, 2017/02/13 18:13:42]

Yeah I think it looks better, if mask tiling is disabled, it makes sense as all
masks are single texture masks.

     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 ||
+      (mask_type_ == Layer::LayerMaskType::MULTI_TEXTURE_MASK &&
+       !layer_tree_impl()->settings().enable_mask_tiling)) {
     // 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 ||
+              (mask_type_ == Layer::LayerMaskType::MULTI_TEXTURE_MASK &&
+               !layer_tree_impl()->settings().enable_mask_tiling)
           ? 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 173 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