CC: Have GPU-raster tiles exactly match the viewport.

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 27 matching lines @@
 const float kSnapToExistingTilingRatio = 1.2f;
 
 // Estimate skewport 60 frames ahead for pre-rasterization on the CPU.
 const float kCpuSkewportTargetTimeInFrames = 60.0f;
 
 // Don't pre-rasterize on the GPU (except for kBackflingGuardDistancePixels in
 // TileManager::BinFromTilePriority).
 const float kGpuSkewportTargetTimeInFrames = 0.0f;
 
 // Even for really wide viewports, at some point GPU raster should use
-// less than 4 tiles to fill the viewport. This is set to 128 as a
-// sane minimum for now, but we might want to increase with tuning.
-const int kMinHeightForGpuRasteredTile = 128;
+// 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;
 
 }  // namespace
 
 namespace cc {
 
 PictureLayerImpl::Pair::Pair() : active(NULL), pending(NULL) {
@@ skipping 624 matching lines @@
 
   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();
     int viewport_height = layer_tree_impl()->device_viewport_size().height();
     default_tile_width = viewport_width;
-    default_tile_height = viewport_height / 4;
+    // 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 = RoundUp(viewport_height, divisor) / divisor;
+    default_tile_height += 2 * PictureLayerTiling::kBorderTexels;
     default_tile_height =
         std::max(default_tile_height, kMinHeightForGpuRasteredTile);
-
-    // Increase the tile-height proportionally when the content width
-    // drops below half the viewport width.
-    if (content_bounds.width() <= viewport_width / 2)
-      default_tile_height *= 2;
   } else {
     // For CPU rasterization we use tile-size settings.
     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();
 
     // If the content width is small, increase tile size vertically.
     // If the content height is small, increase tile size horizontally.
@@ skipping 1099 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