Update from chromium https://crrev.com/304586

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/raster_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;
-#ifdef NDEBUG
-const bool kDefaultClearCanvasSetting = false;
-#else
-const bool kDefaultClearCanvasSetting = true;
-#endif
 
 // 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 118 matching lines @@
   return vertical_density;
 }
 
 }  // namespace
 
 namespace cc {
 
 PicturePile::PicturePile()
     : min_contents_scale_(0),
       slow_down_raster_scale_factor_for_debug_(0),
-      contents_opaque_(false),
-      contents_fill_bounds_completely_(false),
-      clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
       has_any_recordings_(false),
-      is_mask_(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,
-    SkColor background_color,
-    bool contents_opaque,
-    bool contents_fill_bounds_completely,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
     Picture::RecordingMode recording_mode) {
-  background_color_ = background_color;
-  contents_opaque_ = contents_opaque;
-  contents_fill_bounds_completely_ = contents_fill_bounds_completely;
-
   bool updated = false;
 
   Region resize_invalidation;
   gfx::Size old_tiling_size = GetSize();
   if (old_tiling_size != layer_size) {
     tiling_.SetTilingSize(layer_size);
     updated = true;
   }
 
   gfx::Rect interest_rect = visible_layer_rect;
@@ skipping 348 matching lines @@
     }
     DetermineIfSolidColor();
     DCHECK(found_tile_for_recorded_picture);
   }
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
+scoped_refptr<RasterSource> PicturePile::CreateRasterSource() const {
+  return scoped_refptr<RasterSource>(
+      PicturePileImpl::CreateFromPicturePile(this));
+}
+
 gfx::Size PicturePile::GetSize() const {
   return tiling_.tiling_size();
 }
 
 void PicturePile::SetEmptyBounds() {
   tiling_.SetTilingSize(gfx::Size());
   Clear();
 }
 
 void PicturePile::SetMinContentsScale(float min_contents_scale) {
@@ skipping 10 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 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) {
   ComputeTileGridInfo(tile_grid_size, &tile_grid_info_);
 }
 
-void PicturePile::SetSlowdownRasterScaleFactor(int factor) {
-  slow_down_raster_scale_factor_for_debug_ = factor;
-}
-
-void PicturePile::SetIsMask(bool is_mask) {
-  is_mask_ = is_mask;
-}
-
 void PicturePile::SetUnsuitableForGpuRasterizationForTesting() {
   is_suitable_for_gpu_rasterization_ = false;
 }
 
-bool PicturePile::IsSuitableForGpuRasterization() const {
-  return is_suitable_for_gpu_rasterization_;
-}
-
-scoped_refptr<RasterSource> PicturePile::CreateRasterSource() const {
-  return scoped_refptr<RasterSource>(
-      PicturePileImpl::CreateFromPicturePile(this));
-}
-
 SkTileGridFactory::TileGridInfo PicturePile::GetTileGridInfoForTesting() const {
   return tile_grid_info_;
 }
 
 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())
@@ skipping 107 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