Make tile size a function of the device scale factor.

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 33 matching lines @@
 
 // Even for really wide viewports, at some point GPU raster should use
 // less than 4 tiles to fill the viewport. This is set to 256 as a
 // sane minimum for now, but we might want to tune this for low-end.
 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;
 
+// When sizing tiles relative to the viewport, we keep them as a multiple of
+// this.
+// TODO(crbug.com/622885) But why not just use kTileMinimalAlignment.
+const int kTileViewportAlignment = 32;
+
 // 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;
 
 }  // namespace
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl,
                                    int id,
@@ skipping 644 matching lines @@
       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,
     // 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;
+  int tile_width = 0;
+  int 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 = gpu_raster_max_texture_size_.width();
     int viewport_height = gpu_raster_max_texture_size_.height();
-    default_tile_width = viewport_width;
+    tile_width = viewport_width;
 
     // Also, increase the height proportionally as the width decreases, and
     // pad by our border texels to make the tiles exactly match the viewport.
     int divisor = 4;
     if (content_bounds.width() <= viewport_width / 2)
       divisor = 2;
     if (content_bounds.width() <= viewport_width / 4)
       divisor = 1;
-    default_tile_height =
+    tile_height =
         MathUtil::UncheckedRoundUp(viewport_height, divisor) / divisor;
 
     // Grow default sizes to account for overlapping border texels.
-    default_tile_width += 2 * PictureLayerTiling::kBorderTexels;
-    default_tile_height += 2 * PictureLayerTiling::kBorderTexels;
+    tile_width += 2 * PictureLayerTiling::kBorderTexels;
+    tile_height += 2 * PictureLayerTiling::kBorderTexels;
 
-    default_tile_height =
-        std::max(default_tile_height, kMinHeightForGpuRasteredTile);
+    tile_height = std::max(tile_height, kMinHeightForGpuRasteredTile);
   } else {
-    // For CPU rasterization we use tile-size settings.
+    // For CPU rasterization we use stuff.
+    int tile_size;
     const LayerTreeSettings& settings = layer_tree_impl()->settings();
-    int max_untiled_content_width = settings.max_untiled_layer_size.width();
-    int max_untiled_content_height = settings.max_untiled_layer_size.height();
-    default_tile_width = settings.default_tile_size.width();
-    default_tile_height = settings.default_tile_size.height();
+    // TODO(crbug.com/622885): Supply the physical device size along with the
+    // device scale factor to layer tree host. Use that instead of the viewport.
+    // Then we should have use_viewport_for_tile_size always be true, and use it
+    // for ganesh also (maybe with different |num_tiles| for it).
+    if (settings.use_viewport_for_tile_size) {
+      int min_tile_size = 256;
+      int max_tile_size = 512;
 
-    // If the content width is small, increase tile size vertically.
-    // If the content height is small, increase tile size horizontally.
-    // If both are less than the untiled-size, use a single tile.
-    if (content_bounds.width() < default_tile_width)
-      default_tile_height = max_untiled_content_height;
-    if (content_bounds.height() < default_tile_height)
-      default_tile_width = max_untiled_content_width;
-    if (content_bounds.width() < max_untiled_content_width &&
-        content_bounds.height() < max_untiled_content_height) {
-      default_tile_height = max_untiled_content_height;
-      default_tile_width = max_untiled_content_width;
+      int display_width = layer_tree_impl()->device_viewport_size().width();
+      // TODO(crbug.com/622885): Make this independent of the top controls, but
+      // large enough to not have small tiles at the bottom.
+      int display_height = layer_tree_impl()->device_viewport_size().height();
+
+      int portrait_num_tiles = 3;
+      int landscape_num_tiles = 5;
+
+      int num_tiles = display_width < display_height ? portrait_num_tiles
+                                                     : landscape_num_tiles;
+
+      // Tiles overlap by a border, so make the display seem that many pixels
+      // larger.
+      display_width += (num_tiles - 1) * PictureLayerTiling::kBorderTexels;
+
+      // These are the ideal tile size to put |num_tiles| across the screen at a
+      // time, rounded up to a multiple of kTileViewportAlignment, so the last
+      // tile will end up usually entending past the right edge of the screen a
+      // bit.
+      tile_size = MathUtil::UncheckedRoundUp(
+          (display_width + num_tiles - 1) / num_tiles, kTileViewportAlignment);
+      tile_size = std::max(tile_size, min_tile_size);
+      tile_size = std::min(tile_size, max_tile_size);
+    } else {
+      tile_size = 256;
+      if (layer_tree_impl()->device_scale_factor() >= 2.f)
+        tile_size = 512;
+    }
+    DCHECK_GT(tile_size, 0);
+
+    tile_width = tile_height = tile_size;
+
+    if (content_bounds.width() < kMaxUntiledContentSize &&
+        content_bounds.height() < kMaxUntiledContentSize) {
+      // Small layers should not be tiled.
+      tile_width = tile_height = kMaxUntiledContentSize;
+    } else if (content_bounds.width() < tile_width) {
+      // If the content width is small, increase tile size vertically.
+      tile_height *= 2;
+    } else if (content_bounds.height() < tile_height) {
+      // If the content height is small, increase tile size horizontally.
+      tile_width *= 2;
     }
   }
+  DCHECK_GT(tile_width, 0);
+  DCHECK_GT(tile_height, 0);
 
-  int tile_width = default_tile_width;
-  int tile_height = default_tile_height;
-
-  // Clamp the tile width/height to the content width/height to save space.
-  if (content_bounds.width() < default_tile_width) {
-    tile_width = std::min(tile_width, content_bounds.width());
-    tile_width = MathUtil::UncheckedRoundUp(tile_width, kTileRoundUp);
-    tile_width = std::min(tile_width, default_tile_width);
+  // Shrink the tile width/height to be closer content width/height to save
+  // space, if there's a smaller multiple of kTileRoundUp.
+  if (content_bounds.width() < tile_width) {
+    int before_tile_width = tile_width;
+    tile_width =
+        MathUtil::UncheckedRoundUp(content_bounds.width(), kTileRoundUp);
+    tile_width = std::min(tile_width, before_tile_width);
   }
-  if (content_bounds.height() < default_tile_height) {
-    tile_height = std::min(tile_height, content_bounds.height());
-    tile_height = MathUtil::UncheckedRoundUp(tile_height, kTileRoundUp);
-    tile_height = std::min(tile_height, default_tile_height);
+  if (content_bounds.height() < tile_height) {
+    int before_tile_height = tile_height;
+    tile_height =
+        MathUtil::UncheckedRoundUp(content_bounds.height(), kTileRoundUp);
+    tile_height = std::min(tile_height, before_tile_height);
   }
 
   // Ensure that tile width and height are properly aligned.
   tile_width = MathUtil::UncheckedRoundUp(tile_width, kTileMinimalAlignment);
   tile_height = MathUtil::UncheckedRoundUp(tile_height, kTileMinimalAlignment);
 
   // Under no circumstance should we be larger than the max texture size.
   tile_width = std::min(tile_width, max_texture_size);
   tile_height = std::min(tile_height, max_texture_size);
   return gfx::Size(tile_width, tile_height);
@@ skipping 502 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