Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

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 148 matching lines @@
 #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() {
 }
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
+    bool can_use_lcd_text,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
     RecordingSource::RecordingMode recording_mode) {
+  bool can_use_lcd_text_changed = can_use_lcd_text_ != can_use_lcd_text;
+  can_use_lcd_text_ = can_use_lcd_text;
+
   gfx::Rect interest_rect = visible_layer_rect;
   interest_rect.Inset(-pixel_record_distance_, -pixel_record_distance_);
   recorded_viewport_ = interest_rect;
   recorded_viewport_.Intersect(gfx::Rect(layer_size));
 
-  bool updated = ApplyInvalidationAndResize(interest_rect, invalidation,
-                                            layer_size, frame_number);
+  bool updated =
+      ApplyInvalidationAndResize(interest_rect, invalidation, layer_size,
+                                 frame_number, can_use_lcd_text_changed);
   std::vector<gfx::Rect> invalid_tiles;
   GetInvalidTileRects(interest_rect, invalidation, visible_layer_rect,
                       frame_number, &invalid_tiles);
   std::vector<gfx::Rect> record_rects;
   ClusterTiles(invalid_tiles, &record_rects);
 
   if (record_rects.empty())
     return updated;
 
   CreatePictures(painter, recording_mode, record_rects);
 
   DetermineIfSolidColor();
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
 bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
                                              Region* invalidation,
                                              const gfx::Size& layer_size,
-                                             int frame_number) {
+                                             int frame_number,
+                                             bool can_use_lcd_text_changed) {
   bool updated = false;
 
   Region synthetic_invalidation;
   gfx::Size old_tiling_size = GetSize();
   if (old_tiling_size != layer_size) {
     tiling_.SetTilingSize(layer_size);
     updated = true;
   }
+  if (can_use_lcd_text_changed) {
+    // When LCD text is enabled/disabled, we must drop any raster tiles for
+    // the pile, so they can be recreated in a manner consistent with the new
+    // setting. We do this with |synthetic_invalidation| since we don't need to
+    // do a new recording, just invalidate rastered content.
+    synthetic_invalidation.Union(gfx::Rect(GetSize()));
+    updated = true;
+  }
 
   gfx::Rect interest_rect_over_tiles =
       tiling_.ExpandRectToTileBounds(interest_rect);
 
   if (old_tiling_size != layer_size) {
     gfx::Size min_tiling_size(
         std::min(GetSize().width(), old_tiling_size.width()),
         std::min(GetSize().height(), old_tiling_size.height()));
     gfx::Size max_tiling_size(
         std::max(GetSize().width(), old_tiling_size.width()),
@@ skipping 332 matching lines @@
       if (padded_record_rect.Contains(tile)) {
         PictureInfo& info = picture_map_[key];
         info.SetPicture(picture);
         found_tile_for_recorded_picture = true;
       }
     }
     DCHECK(found_tile_for_recorded_picture);
   }
 }
 
-scoped_refptr<RasterSource> PicturePile::CreateRasterSource(
-    bool can_use_lcd_text) const {
+scoped_refptr<RasterSource> PicturePile::CreateRasterSource() const {
   return scoped_refptr<RasterSource>(
-      PicturePileImpl::CreateFromPicturePile(this, can_use_lcd_text));
+      PicturePileImpl::CreateFromPicturePile(this));
 }
 
 gfx::Size PicturePile::GetSize() const {
   return tiling_.tiling_size();
 }
 
 void PicturePile::SetEmptyBounds() {
   tiling_.SetTilingSize(gfx::Size());
   Clear();
 }
@@ skipping 167 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