CC: Tile-size cleanup.

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 657 matching lines @@
   if (pile_->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();
     return content_bounds;
   }
 
   gfx::Size default_tile_size = layer_tree_impl()->settings().default_tile_size;
-  if (layer_tree_impl()->use_gpu_rasterization()) {
-    // TODO(ernstm) crbug.com/365877: We need a unified way to override the
-    // default-tile-size.
-    default_tile_size =
-        gfx::Size(layer_tree_impl()->device_viewport_size().width(),
-                  layer_tree_impl()->device_viewport_size().height() / 4);
-  }
-  default_tile_size.SetToMin(gfx::Size(max_texture_size, max_texture_size));
-
   gfx::Size max_untiled_content_size =
       layer_tree_impl()->settings().max_untiled_layer_size;
+
+  // For GPU rasterization, we pick an ideal tile size using the viewport,
+  // so we don't need the above settings.
+  bool use_gpu = layer_tree_impl()->use_gpu_rasterization();
+  if (use_gpu) {
+    int width = layer_tree_impl()->device_viewport_size().width();
+    int height = layer_tree_impl()->device_viewport_size().height() / 4;
+    height = std::max(height, 128);

[vmpstr, 2014/10/08 23:30:28]

nit: Consider making this a constant.

[epennerAtGoogle, 2014/10/09 00:29:43]

Done.

+    default_tile_size = gfx::Size(width, height);
+    // Since the width is already expanded to viewport width, we use
+    // double the height as our max untiled size.
+    max_untiled_content_size = gfx::Size(height * 2, height * 2);
+  }
+
+  default_tile_size.SetToMin(gfx::Size(max_texture_size, max_texture_size));
   max_untiled_content_size.SetToMin(
       gfx::Size(max_texture_size, max_texture_size));
 
   bool any_dimension_too_large =
       content_bounds.width() > max_untiled_content_size.width() ||
       content_bounds.height() > max_untiled_content_size.height();
 
   bool any_dimension_one_tile =
-      content_bounds.width() <= default_tile_size.width() ||
-      content_bounds.height() <= default_tile_size.height();
+      !use_gpu && (content_bounds.width() <= default_tile_size.width() ||

[vmpstr, 2014/10/08 23:30:28]

Can you make a comment here or something like that to explain why this isn't
appropriate for gpu? It took me way too long of a time staring at this to
convince myself that "yeah I think that's fine". I think maybe the
"any_dimension_too_large" should be "both_dimensions_are_small" instead, so the
if below is if (a || b) instead of if (a || !b)

[epennerAtGoogle, 2014/10/09 00:29:43]

Done.

While adding the comment, I realized this can be slightly better by still
expanding gpu-rastered tiles vertically if they are 'skinny' horizontally. But
we can't use the tile-width to determine that. So in the new patch I use the
tile-height, changed both names, and add a comment.

+                   content_bounds.height() <= default_tile_size.height());
 
   // If long and skinny, tile at the max untiled content size, and clamp
   // the smaller dimension to the content size, e.g. 1000x12 layer with
   // 500x500 max untiled size would get 500x12 tiles.  Also do this
   // if the layer is small.
   if (any_dimension_one_tile || !any_dimension_too_large) {
     int width = std::min(
         std::max(max_untiled_content_size.width(), default_tile_size.width()),
         content_bounds.width());
     int height = std::min(
@@ skipping 1078 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