cc: Toggle LCD text at raster time instead of record time.

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 175 matching lines @@
 
 PicturePile::~PicturePile() {
 }
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     SkColor background_color,
     bool contents_opaque,
     bool contents_fill_bounds_completely,
+    bool can_use_lcd_text,
     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 can_use_lcd_text_changed = can_use_lcd_text_ != can_use_lcd_text;
+  can_use_lcd_text_ = can_use_lcd_text;
 
   bool updated = false;
 
-  Region resize_invalidation;
+  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 = visible_layer_rect;
   interest_rect.Inset(-pixel_record_distance_, -pixel_record_distance_);
   recorded_viewport_ = interest_rect;
   recorded_viewport_.Intersect(gfx::Rect(GetSize()));
 
   gfx::Rect interest_rect_over_tiles =
       tiling_.ExpandRectToTileBounds(interest_rect);
 
   gfx::Size min_tiling_size(
@@ skipping 143 matching lines @@
 
       gfx::Rect left_rect(left, top, left_until - left, bottom - top);
       gfx::Rect right_rect(right_until, top, right - right_until, bottom - top);
       gfx::Rect top_rect(left, top, right - left, top_until - top);
       gfx::Rect bottom_rect(
           left, bottom_until, right - left, bottom - bottom_until);
       gfx::Rect exposed_rect(exposed_left,
                              exposed_top,
                              exposed_left_until - exposed_left,
                              exposed_bottom - exposed_top);
-      resize_invalidation.Union(left_rect);
-      resize_invalidation.Union(right_rect);
-      resize_invalidation.Union(top_rect);
-      resize_invalidation.Union(bottom_rect);
-      resize_invalidation.Union(exposed_rect);
+      synthetic_invalidation.Union(left_rect);
+      synthetic_invalidation.Union(right_rect);
+      synthetic_invalidation.Union(top_rect);
+      synthetic_invalidation.Union(bottom_rect);
+      synthetic_invalidation.Union(exposed_rect);
     }
     if (min_toss_y < tiling_.num_tiles_y()) {
       // The same thing occurs here as in the case above, but the invalidation
       // rect is the bounding box around the bottom row of tiles in the min
       // pile. This would be tiles {o,r,u,x,a,d,g,j} in the above picture.
 
       int top = tiling_.TilePositionY(min_toss_y);
       int bottom = top + tiling_.TileSizeY(min_toss_y);
       int left = min_tiling_rect_over_tiles.x();
       int right = min_tiling_rect_over_tiles.right();
@@ skipping 11 matching lines @@
 
       gfx::Rect left_rect(left, top, left_until - left, bottom - top);
       gfx::Rect right_rect(right_until, top, right - right_until, bottom - top);
       gfx::Rect top_rect(left, top, right - left, top_until - top);
       gfx::Rect bottom_rect(
           left, bottom_until, right - left, bottom - bottom_until);
       gfx::Rect exposed_rect(exposed_left,
                              exposed_top,
                              exposed_right - exposed_left,
                              exposed_top_until - exposed_top);
-      resize_invalidation.Union(left_rect);
-      resize_invalidation.Union(right_rect);
-      resize_invalidation.Union(top_rect);
-      resize_invalidation.Union(bottom_rect);
-      resize_invalidation.Union(exposed_rect);
+      synthetic_invalidation.Union(left_rect);
+      synthetic_invalidation.Union(right_rect);
+      synthetic_invalidation.Union(top_rect);
+      synthetic_invalidation.Union(bottom_rect);
+      synthetic_invalidation.Union(exposed_rect);
     }
   }
 
   // Detect cases where the full pile is invalidated, in this situation we
   // can just drop/invalidate everything.
   if (invalidation->Contains(gfx::Rect(old_tiling_size)) ||
       invalidation->Contains(gfx::Rect(GetSize()))) {
     for (auto& it : picture_map_)
       updated = it.second.Invalidate(frame_number) || updated;
   } else {
@@ skipping 41 matching lines @@
         // if it won't be re-recorded below.
         DCHECK_IMPLIES(!tiling_.TileBounds(key.first, key.second)
                             .Intersects(interest_rect_over_tiles),
                        invalidation_expanded_to_full_tiles.Contains(
                            tiling_.TileBounds(key.first, key.second)));
       }
     }
     invalidation->Union(invalidation_expanded_to_full_tiles);
   }
 
-  invalidation->Union(resize_invalidation);
+  invalidation->Union(synthetic_invalidation);
 
   // Make a list of all invalid tiles; we will attempt to
   // cluster these into multiple invalidation regions.
   std::vector<gfx::Rect> invalid_tiles;
   bool include_borders = true;
   for (TilingData::Iterator it(&tiling_, interest_rect, include_borders); it;
        ++it) {
     const PictureMapKey& key = it.index();
     PictureInfo& info = picture_map_[key];
 
@@ skipping 271 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