Fixing tile grid size used by cc:Picture to make it respect current tile configuration

cc/picture_layer.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/picture_layer.h"
 
 #include "cc/layer_tree_impl.h"
 #include "cc/picture_layer_impl.h"
 #include "ui/gfx/rect_conversions.h"
 
@@ skipping 28 matching lines @@
   layer_impl->CreateTilingSet();
   layer_impl->invalidation_.Clear();
   layer_impl->invalidation_.Swap(pile_invalidation_);
   pile_->PushPropertiesTo(layer_impl->pile_);
 
   layer_impl->SyncFromActiveLayer();
 }
 
 void PictureLayer::setLayerTreeHost(LayerTreeHost* host) {
   Layer::setLayerTreeHost(host);
-  if (host)
-      pile_->SetMinContentsScale(host->settings().minimumContentsScale);
+  if (host) {
+    pile_->SetMinContentsScale(host->settings().minimumContentsScale);
+    gfx::Size tile_size = host->settings().defaultTileSize;
+    float scale = host->deviceScaleFactor();
+    gfx::Size tile_grid_size(
+        static_cast<int>(ceil(tile_size.width() / scale)),
+        static_cast<int>(ceil(tile_size.height() / scale)));
+    int border_pixels = static_cast<int>(ceil(1.0f / scale));

[enne (OOO), 2013/02/21 18:23:13]

I agree that the border pixels are scaled as well, but I don't think the ceil is
applied to each separately.  Like, a 254 pixel tile with 1 border texel at a
device scale of 2 has a 128 css pixel stride per tile (i.e. (254 + 2 * 1)/2),
but this math would round 254 to 127 and border_pixels to 1, so it seems like
you'd have a stride of 129.

How important is this to match exactly for the 1:1 case? What sorts of gains are
you seeing when the default tile size is 512x512?

Is there any way to test that what you're intending to do here (i.e. match
rastering tile size at 1:1) is actually happening? I could lgtⅿ this, but
without tests it's hard to be convinced that this is doing the right thing.

+    pile_->SetTileGridSize(tile_grid_size, border_pixels);
+  }
 }
 
 void PictureLayer::setNeedsDisplayRect(const gfx::RectF& layer_rect) {
   gfx::Rect rect = gfx::ToEnclosedRect(layer_rect);
   if (!rect.IsEmpty()) {
     // Clamp invalidation to the layer bounds.
     rect.Intersect(gfx::Rect(bounds()));
     pending_invalidation_.Union(rect);
   }
   Layer::setNeedsDisplayRect(layer_rect);
@@ skipping 14 matching lines @@
   gfx::Rect visible_layer_rect = gfx::ToEnclosingRect(
       gfx::ScaleRect(visibleContentRect(), 1.f / contentsScaleX()));
   pile_->Update(client_, pile_invalidation_, visible_layer_rect, stats);
 }
 
 void PictureLayer::setIsMask(bool is_mask) {
   is_mask_ = is_mask;
 }
 
 }  // namespace cc