cc: use viewport-wide tiles for GPU rasterization.

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 "base/time/time.h"
@@ skipping 555 matching lines @@
     int max_size = layer_tree_impl()->MaxTextureSize();
     return gfx::Size(
         std::min(max_size, content_bounds.width()),
         std::min(max_size, content_bounds.height()));
   }
 
   int max_texture_size =
       layer_tree_impl()->resource_provider()->max_texture_size();
 
   gfx::Size default_tile_size = layer_tree_impl()->settings().default_tile_size;
+  if (ShouldUseGpuRasterization()) {
+    // 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;
   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();
 
   // 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(max_untiled_content_size.width(), content_bounds.width());
-    int height =
-        std::min(max_untiled_content_size.height(), content_bounds.height());
+    int width = std::min(
+        std::max(max_untiled_content_size.width(), default_tile_size.width()),
+        content_bounds.width());
+    int height = std::min(
+        std::max(max_untiled_content_size.height(), default_tile_size.height()),
+        content_bounds.height());
     // Round width and height up to the closest multiple of 64, or 56 if
     // we should avoid power-of-two textures. This helps reduce the number
     // of different textures sizes to help recycling, and also keeps all
     // textures multiple-of-eight, which is preferred on some drivers (IMG).
     bool avoid_pow2 =
         layer_tree_impl()->GetRendererCapabilities().avoid_pow2_textures;
     int round_up_to = avoid_pow2 ? 56 : 64;
     width = RoundUp(width, round_up_to);
     height = RoundUp(height, round_up_to);
     return gfx::Size(width, height);
@@ skipping 898 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc