Update from https://crrev.com/317530

cc/resources/picture_pile_impl.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 <algorithm>
 #include <limits>
 #include <set>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/raster_source_helper.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 scoped_refptr<PicturePileImpl> PicturePileImpl::CreateFromPicturePile(
-    const PicturePile* other) {
-  return make_scoped_refptr(new PicturePileImpl(other));
+    const PicturePile* other,
+    bool can_use_lcd_text) {
+  return make_scoped_refptr(new PicturePileImpl(other, can_use_lcd_text));
 }
 
 PicturePileImpl::PicturePileImpl()
     : background_color_(SK_ColorTRANSPARENT),
       requires_clear_(true),
-      can_use_lcd_text_(false),
+      can_use_lcd_text_(true),
       is_solid_color_(false),
       solid_color_(SK_ColorTRANSPARENT),
       has_any_recordings_(false),
       clear_canvas_with_debug_color_(false),
       min_contents_scale_(0.f),
       slow_down_raster_scale_factor_for_debug_(0),
       should_attempt_to_use_distance_field_text_(false) {
 }
 
-PicturePileImpl::PicturePileImpl(const PicturePile* other)
+PicturePileImpl::PicturePileImpl(const PicturePile* other,
+                                 bool can_use_lcd_text)
     : picture_map_(other->picture_map_),
       tiling_(other->tiling_),
       background_color_(other->background_color_),
       requires_clear_(other->requires_clear_),
-      can_use_lcd_text_(other->can_use_lcd_text_),
+      can_use_lcd_text_(can_use_lcd_text),
       is_solid_color_(other->is_solid_color_),
       solid_color_(other->solid_color_),
       recorded_viewport_(other->recorded_viewport_),
       has_any_recordings_(other->has_any_recordings_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       min_contents_scale_(other->min_contents_scale_),
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
       should_attempt_to_use_distance_field_text_(false) {
 }
 
+PicturePileImpl::PicturePileImpl(const PicturePileImpl* other,
+                                 bool can_use_lcd_text)
+    : picture_map_(other->picture_map_),
+      tiling_(other->tiling_),
+      background_color_(other->background_color_),
+      requires_clear_(other->requires_clear_),
+      can_use_lcd_text_(can_use_lcd_text),
+      is_solid_color_(other->is_solid_color_),
+      solid_color_(other->solid_color_),
+      recorded_viewport_(other->recorded_viewport_),
+      has_any_recordings_(other->has_any_recordings_),
+      clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
+      min_contents_scale_(other->min_contents_scale_),
+      slow_down_raster_scale_factor_for_debug_(
+          other->slow_down_raster_scale_factor_for_debug_),
+      should_attempt_to_use_distance_field_text_(
+          other->should_attempt_to_use_distance_field_text_) {
+}
+
 PicturePileImpl::~PicturePileImpl() {
 }
 
 void PicturePileImpl::PlaybackToSharedCanvas(SkCanvas* canvas,
                                              const gfx::Rect& canvas_rect,
                                              float contents_scale) const {
   RasterCommon(canvas,
                NULL,
                canvas_rect,
                contents_scale,
@@ skipping 310 matching lines @@
       appended_pictures.insert(picture);
       TracedValue::AppendIDRef(picture, pictures);
     }
   }
 }
 
 bool PicturePileImpl::CanUseLCDText() const {
   return can_use_lcd_text_;
 }
 
+scoped_refptr<RasterSource> PicturePileImpl::CreateCloneWithoutLCDText() const {
+  DCHECK(CanUseLCDText());
+  bool can_use_lcd_text = false;
+  return scoped_refptr<RasterSource>(
+      new PicturePileImpl(this, can_use_lcd_text));
+}
+
 PicturePileImpl::PixelRefIterator::PixelRefIterator(
     const gfx::Rect& content_rect,
     float contents_scale,
     const PicturePileImpl* picture_pile)
     : picture_pile_(picture_pile),
       layer_rect_(
           gfx::ScaleToEnclosingRect(content_rect, 1.f / contents_scale)),
       tile_iterator_(&picture_pile_->tiling_,
                      layer_rect_,
                      false /* include_borders */) {
@@ skipping 42 matching lines @@
   for (const auto& map_pair : picture_map_) {
     const Picture* picture = map_pair.second.GetPicture();
     if (picture && (processed_pictures.count(picture) == 0)) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc