Update from https://crrev.com/316786

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>
 
@@ skipping 134 matching lines @@
       PerformClustering(invalid_tiles_horizontal, &horizontal_clustering);
 
   if (vertical_density < horizontal_density) {
     *record_rects = horizontal_clustering;
     return;
   }
 
   *record_rects = vertical_clustering;
 }
 
+#ifdef NDEBUG
+const bool kDefaultClearCanvasSetting = false;
+#else
+const bool kDefaultClearCanvasSetting = true;
+#endif
+
 }  // namespace
 
 namespace cc {
 
 PicturePile::PicturePile(float min_contents_scale,
                          const gfx::Size& tile_grid_size)
     : min_contents_scale_(0),
       slow_down_raster_scale_factor_for_debug_(0),
       can_use_lcd_text_(true),
       has_any_recordings_(false),
+      clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
+      requires_clear_(true),
       is_solid_color_(false),
       solid_color_(SK_ColorTRANSPARENT),
+      background_color_(SK_ColorTRANSPARENT),
       pixel_record_distance_(kPixelDistanceToRecord),
       is_suitable_for_gpu_rasterization_(true) {
   tiling_.SetMaxTextureSize(gfx::Size(kBasePictureSize, kBasePictureSize));
   SetMinContentsScale(min_contents_scale);
   SetTileGridSize(tile_grid_size);
 }
 
 PicturePile::~PicturePile() {
 }
 
@@ skipping 439 matching lines @@
   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;
 }
 
+void PicturePile::SetBackgroundColor(SkColor background_color) {
+  background_color_ = background_color;
+}
+
+void PicturePile::SetRequiresClear(bool requires_clear) {
+  requires_clear_ = requires_clear;
+}
+
 bool PicturePile::IsSuitableForGpuRasterization() const {
   return is_suitable_for_gpu_rasterization_;
 }
 
 void PicturePile::SetTileGridSize(const gfx::Size& tile_grid_size) {
   DCHECK_GT(tile_grid_size.width(), 0);
   DCHECK_GT(tile_grid_size.height(), 0);
 
   tile_grid_size_ = tile_grid_size;
 }
@@ skipping 123 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