Update from https://crrev.com/312398

cc/resources/picture_pile.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/resources/picture_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "cc/base/region.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/tile_task_worker_pool.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 // Layout pixel buffer around the visible layer rect to record.  Any base
 // picture that intersects the visible layer rect expanded by this distance
 // will be recorded.
 const int kPixelDistanceToRecord = 8000;
 // We don't perform solid color analysis on images that have more than 10 skia
 // operations.
 const int kOpCountThatIsOkToAnalyze = 10;
 
 // Dimensions of the tiles in this picture pile as well as the dimensions of
 // the base picture in each tile.
 const int kBasePictureSize = 512;
-const int kTileGridBorderPixels = 1;
 
 // Invalidation frequency settings. kInvalidationFrequencyThreshold is a value
 // between 0 and 1 meaning invalidation frequency between 0% and 100% that
 // indicates when to stop invalidating offscreen regions.
 // kFrequentInvalidationDistanceThreshold defines what it means to be
 // "offscreen" in terms of distance to visible in css pixels.
 const float kInvalidationFrequencyThreshold = 0.75f;
 const int kFrequentInvalidationDistanceThreshold = 512;
 
 // TODO(humper): The density threshold here is somewhat arbitrary; need a
@@ skipping 121 matching lines @@
 PicturePile::PicturePile()
     : min_contents_scale_(0),
       slow_down_raster_scale_factor_for_debug_(0),
       can_use_lcd_text_(true),
       has_any_recordings_(false),
       is_solid_color_(false),
       solid_color_(SK_ColorTRANSPARENT),
       pixel_record_distance_(kPixelDistanceToRecord),
       is_suitable_for_gpu_rasterization_(true) {
   tiling_.SetMaxTextureSize(gfx::Size(kBasePictureSize, kBasePictureSize));
-  tile_grid_info_.fTileInterval.setEmpty();
-  tile_grid_info_.fMargin.setEmpty();
-  tile_grid_info_.fOffset.setZero();
 }
 
 PicturePile::~PicturePile() {
 }
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     bool can_use_lcd_text,
     const gfx::Size& layer_size,
@@ skipping 358 matching lines @@
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
     scoped_refptr<Picture> picture;
 
     // Note: Currently, gathering of pixel refs when using a single
     // raster thread doesn't provide any benefit. This might change
     // in the future but we avoid it for now to reduce the cost of
     // Picture::Create.
     bool gather_pixel_refs = TileTaskWorkerPool::GetNumWorkerThreads() > 1;
 
     for (int i = 0; i < repeat_count; i++) {
-      picture = Picture::Create(padded_record_rect, painter, tile_grid_info_,
+      picture = Picture::Create(padded_record_rect, painter, tile_grid_size_,
                                 gather_pixel_refs, recording_mode);
       // Note the '&&' with previous is-suitable state.
       // This means that once a picture-pile becomes unsuitable for gpu
       // rasterization due to some content, it will continue to be unsuitable
       // even if that content is replaced by gpu-friendly content.
       // This is an optimization to avoid iterating though all pictures in
       // the pile after each invalidation.
       if (is_suitable_for_gpu_rasterization_) {
         const char* reason = nullptr;
         is_suitable_for_gpu_rasterization_ &=
@@ skipping 59 matching lines @@
 }
 
 void PicturePile::SetSlowdownRasterScaleFactor(int factor) {
   slow_down_raster_scale_factor_for_debug_ = factor;
 }
 
 bool PicturePile::IsSuitableForGpuRasterization() const {
   return is_suitable_for_gpu_rasterization_;
 }
 
-// static
-void PicturePile::ComputeTileGridInfo(const gfx::Size& tile_grid_size,
-                                      SkTileGridFactory::TileGridInfo* info) {
-  DCHECK(info);
-  info->fTileInterval.set(tile_grid_size.width() - 2 * kTileGridBorderPixels,
-                          tile_grid_size.height() - 2 * kTileGridBorderPixels);
-  DCHECK_GT(info->fTileInterval.width(), 0);
-  DCHECK_GT(info->fTileInterval.height(), 0);
-  info->fMargin.set(kTileGridBorderPixels, kTileGridBorderPixels);
-  // 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.
-  info->fOffset.set(-kTileGridBorderPixels, -kTileGridBorderPixels);
-}
+void PicturePile::SetTileGridSize(const gfx::Size& tile_grid_size) {
+  DCHECK_GT(tile_grid_size.width(), 0);
+  DCHECK_GT(tile_grid_size.height(), 0);
 
-void PicturePile::SetTileGridSize(const gfx::Size& tile_grid_size) {
-  ComputeTileGridInfo(tile_grid_size, &tile_grid_info_);
+  tile_grid_size_ = tile_grid_size;
 }
 
 void PicturePile::SetUnsuitableForGpuRasterizationForTesting() {
   is_suitable_for_gpu_rasterization_ = false;
 }
 
-SkTileGridFactory::TileGridInfo PicturePile::GetTileGridInfoForTesting() const {
-  return tile_grid_info_;
+gfx::Size PicturePile::GetTileGridSizeForTesting() const {
+  return tile_grid_size_;
 }
 
 bool PicturePile::CanRasterSlowTileCheck(const gfx::Rect& layer_rect) const {
   bool include_borders = false;
   for (TilingData::Iterator tile_iter(&tiling_, layer_rect, include_borders);
        tile_iter; ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       return false;
     if (!map_iter->second.GetPicture())
@@ skipping 106 matching lines @@
 const Picture* PicturePile::PictureInfo::GetPicture() const {
   return picture_.get();
 }
 
 float PicturePile::PictureInfo::GetInvalidationFrequency() const {
   return invalidation_history_.count() /
          static_cast<float>(INVALIDATION_FRAMES_TRACKED);
 }
 
 }  // namespace cc