cc: Keep tilings texture size in sync

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 <cmath>
 #include <limits>
 #include <set>
@@ skipping 112 matching lines @@
   layer_impl->twin_layer_ = this;
 
   layer_impl->SetNearestNeighbor(nearest_neighbor_);
 
   // Solid color layers have no tilings.
   DCHECK_IMPLIES(raster_source_->IsSolidColor(), tilings_->num_tilings() == 0);
   // The pending tree should only have a high res (and possibly low res) tiling.
   DCHECK_LE(tilings_->num_tilings(),
             layer_tree_impl()->create_low_res_tiling() ? 2u : 1u);
 
-  layer_impl->UpdateRasterSource(raster_source_, &invalidation_,
-                                 tilings_.get());
+  layer_impl->UpdateRasterSource(raster_source_, &invalidation_, tilings_.get(),
+                                 gpu_raster_max_texture_size_);
   DCHECK(invalidation_.IsEmpty());
 
   // After syncing a solid color layer, the active layer has no tilings.
   DCHECK_IMPLIES(raster_source_->IsSolidColor(),
                  layer_impl->tilings_->num_tilings() == 0);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
@@ skipping 351 matching lines @@
 
 PictureLayerImpl* PictureLayerImpl::GetRecycledTwinLayer() const {
   if (!twin_layer_ || twin_layer_->IsOnActiveOrPendingTree())
     return nullptr;
   return twin_layer_;
 }
 
 void PictureLayerImpl::UpdateRasterSource(
     scoped_refptr<RasterSource> raster_source,
     Region* new_invalidation,
-    const PictureLayerTilingSet* pending_set) {
+    const PictureLayerTilingSet* pending_set,
+    gfx::Size gpu_raster_max_texture_size) {
+  gpu_raster_max_texture_size_ = gpu_raster_max_texture_size;

[vmpstr, 2015/03/19 23:14:39]

It kind of feels like this can be a separate function or maybe even just
settings the value directly like PushProps does it. Unless there has to be a
reason this is in here?

+
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
   DCHECK_IMPLIES(!raster_source->GetSize().IsEmpty(),
                  bounds() == raster_source->GetSize())
       << " bounds " << bounds().ToString() << " pile "
       << raster_source->GetSize().ToString();
 
   // The |raster_source_| is initially null, so have to check for that for the
   // first frame.
   bool could_have_tilings = raster_source_.get() && CanHaveTilings();
@@ skipping 38 matching lines @@
   if (can_use_lcd_text() == RasterSourceUsesLCDText())
     return;
 
   // Raster sources are considered const, so in order to update the state
   // a new one must be created and all tiles recreated.
   scoped_refptr<RasterSource> new_raster_source =
       raster_source_->CreateCloneWithoutLCDText();
   // Synthetically invalidate everything.
   gfx::Rect bounds_rect(bounds());
   Region invalidation(bounds_rect);
-  UpdateRasterSource(new_raster_source, &invalidation, nullptr);
+  UpdateRasterSource(new_raster_source, &invalidation, nullptr,
+                     gpu_raster_max_texture_size_);
   SetUpdateRect(bounds_rect);
 
   DCHECK(!RasterSourceUsesLCDText());
 }
 
 bool PictureLayerImpl::RasterSourceUsesLCDText() const {
   return raster_source_ ? raster_source_->CanUseLCDText()
                         : layer_tree_impl()->settings().can_use_lcd_text;
 }
 
@@ skipping 102 matching lines @@
     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()) {
     // 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();
+    int viewport_width = gpu_raster_max_texture_size_.width();
+    int viewport_height = gpu_raster_max_texture_size_.height();
     default_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 = RoundUp(viewport_height, divisor) / divisor;
     default_tile_height += 2 * PictureLayerTiling::kBorderTexels;
@@ skipping 528 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc