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

cc/picture_pile_base.cc

 // Copyright 2013 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_pile_base.h"
 
 #include "base/logging.h"
+#include "cc/layer_tree_host.h"
+#include "cc/layer_tree_host_impl.h"
 
 namespace {
 // Dimensions of the tiles in this picture pile as well as the dimensions of
 // the base picture in each tile.
 const int kBasePictureSize = 3000;
+const int kDefaultTileGridInterval = 254;

[enne (OOO), 2013/02/25 23:59:15]

This should never get used, right? If possible, I'd prefer to not have this
constant, since it might make somebody think that this value is real and gets
used.

+const int kDefaultTileGridBorderPixels = 1;
 }
 
 namespace cc {
 
 PicturePileBase::PicturePileBase()
     : min_contents_scale_(0) {
   tiling_.SetMaxTextureSize(gfx::Size(kBasePictureSize, kBasePictureSize));
+  tile_grid_info_.fTileInterval.set(kDefaultTileGridInterval,
+      kDefaultTileGridInterval);
+  tile_grid_info_.fMargin.set(kDefaultTileGridBorderPixels,
+      kDefaultTileGridBorderPixels);
+  tile_grid_info_.fOffset.set(-kDefaultTileGridBorderPixels,
+      -kDefaultTileGridBorderPixels);
 }
 
 PicturePileBase::~PicturePileBase() {
 }
 
 void PicturePileBase::Resize(gfx::Size new_size) {
   if (size() == new_size)
     return;
 
   gfx::Size old_size = size();
@@ skipping 30 matching lines @@
   //
   // For example, if a 1/4 contents scale is used, then that would be 3 buffer
   // pixels, since that's the minimum number of pixels to add so that resulting
   // content can be snapped to a four pixel aligned grid.
   int buffer_pixels = static_cast<int>(ceil(1 / min_contents_scale) - 1);
   buffer_pixels = std::max(0, buffer_pixels);
   SetBufferPixels(buffer_pixels);
   min_contents_scale_ = min_contents_scale;
 }
 
+void PicturePileBase::ApplyLayerTreeSettings(LayerTreeHost* host) {
+  ApplyLayerTreeSettings(host->settings(), host->deviceScaleFactor());
+}
+
+void PicturePileBase::ApplyLayerTreeSettings(LayerTreeHostImpl* host_impl) {
+  ApplyLayerTreeSettings(host_impl->settings(),
+      host_impl->deviceScaleFactor());
+}
+
+void PicturePileBase::ApplyLayerTreeSettings(
+  const LayerTreeSettings& settings, float deviceScaleFactor) {
+  SetMinContentsScale(settings.minimumContentsScale);
+  tile_grid_info_.fTileInterval.set(
+      settings.defaultTileSize.width() - 2 * kDefaultTileGridBorderPixels,
+      settings.defaultTileSize.height() - 2 * kDefaultTileGridBorderPixels);
+  DCHECK_GT(tile_grid_info_.fTileInterval.width(), 0);
+  DCHECK_GT(tile_grid_info_.fTileInterval.height(), 0);
+  tile_grid_info_.fMargin.set(kDefaultTileGridBorderPixels,
+      kDefaultTileGridBorderPixels);
+  // Offset the tile grid coordinate space to take into account the fact
+  // that the top-most and left-most tiles do not have top and left borders
+  // respectively.
+  tile_grid_info_.fOffset.set(-kDefaultTileGridBorderPixels,
+      -kDefaultTileGridBorderPixels);
+}
+
 void PicturePileBase::SetBufferPixels(int new_buffer_pixels) {
   if (new_buffer_pixels == buffer_pixels())
     return;
 
   Clear();
   tiling_.SetBorderTexels(new_buffer_pixels);
 }
 
 void PicturePileBase::Clear() {
   picture_list_map_.clear();
 }
 
 void PicturePileBase::PushPropertiesTo(PicturePileBase* other) {
   other->picture_list_map_ = picture_list_map_;
   other->tiling_ = tiling_;
   other->recorded_region_ = recorded_region_;
   other->min_contents_scale_ = min_contents_scale_;
+  other->tile_grid_info_ = tile_grid_info_;
 }
 
 void PicturePileBase::UpdateRecordedRegion() {
   recorded_region_.Clear();
   for (int x = 0; x < num_tiles_x(); ++x) {
     for (int y = 0; y < num_tiles_y(); ++y) {
       if (!HasRecordingAt(x, y))
         continue;
       recorded_region_.Union(tile_bounds(x, y));
     }
   }
 }
 
 bool PicturePileBase::HasRecordingAt(int x, int y) {
   PictureListMap::iterator found =
       picture_list_map_.find(PictureListMapKey(x, y));
   if (found == picture_list_map_.end())
     return false;
   DCHECK(!found->second.empty());
   return true;
 }
 
 }  // namespace cc