Record SkPicture with correct LCD text setting.

cc/layers/picture_layer.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/layers/picture_layer.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 scoped_refptr<PictureLayer> PictureLayer::Create(ContentLayerClient* client) {
   return make_scoped_refptr(new PictureLayer(client));
 }
 
 PictureLayer::PictureLayer(ContentLayerClient* client)
     : client_(client),
       pile_(make_scoped_refptr(new PicturePile())),
       instrumentation_object_tracker_(id()),
       is_mask_(false),
-      update_source_frame_number_(-1) {}
+      use_lcd_text_(true),
+      update_source_frame_number_(-1) {
+}
 
 PictureLayer::~PictureLayer() {
 }
 
 bool PictureLayer::DrawsContent() const {
   return Layer::DrawsContent() && client_;
 }
 
 scoped_ptr<LayerImpl> PictureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return PictureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
@@ skipping 46 matching lines @@
     pending_invalidation_.Union(rect);
   }
   Layer::SetNeedsDisplayRect(layer_rect);
 }
 
 bool PictureLayer::Update(ResourceUpdateQueue* queue,
                           const OcclusionTracker<Layer>* occlusion) {
   update_source_frame_number_ = layer_tree_host()->source_frame_number();
   bool updated = Layer::Update(queue, occlusion);
 
+  UpdateUseLCDText();
+
   gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
       visible_content_rect(), 1.f / contents_scale_x());
 
   gfx::Rect layer_rect = gfx::Rect(paint_properties().bounds);
 
   if (last_updated_visible_content_rect_ == visible_content_rect() &&
       pile_->tiling_rect() == layer_rect && pending_invalidation_.IsEmpty()) {
     // Only early out if the visible content rect of this layer hasn't changed.
     return updated;
   }
@@ skipping 12 matching lines @@
   if (layer_tree_host()->settings().using_synchronous_renderer_compositor) {
     // Workaround for http://crbug.com/235910 - to retain backwards compat
     // the full page content must always be provided in the picture layer.
     visible_layer_rect = gfx::Rect(bounds());
   }
   DCHECK(client_);
   updated |= pile_->Update(client_,
                            SafeOpaqueBackgroundColor(),
                            contents_opaque(),
                            client_->FillsBoundsCompletely(),
+                           use_lcd_text_,
                            pile_invalidation_,
                            visible_layer_rect,
                            update_source_frame_number_,
                            RecordingMode(),
                            rendering_stats_instrumentation());
   last_updated_visible_content_rect_ = visible_content_rect();
 
   if (updated) {
     SetNeedsPushProperties();
   } else {
@@ skipping 32 matching lines @@
     return skia::RefPtr<SkPicture>();
 
   int width = bounds().width();
   int height = bounds().height();
   gfx::RectF opaque;
 
   SkPictureRecorder recorder;
   SkCanvas* canvas = recorder.beginRecording(width, height, NULL, 0);
   client_->PaintContents(canvas,
                          gfx::Rect(width, height),
+                         use_lcd_text_,
                          &opaque,
                          ContentLayerClient::GRAPHICS_CONTEXT_ENABLED);
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
   return picture;
 }
 
 bool PictureLayer::IsSuitableForGpuRasterization() const {
   return pile_->is_suitable_for_gpu_rasterization();
 }
 
 void PictureLayer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
+void PictureLayer::UpdateUseLCDText() {
+  if (use_lcd_text_ == can_use_lcd_text())
+    return;
+
+  // LCD text starts out enabled and can only be disabled.
+  if (!use_lcd_text_)
+    return;
+
+  use_lcd_text_ = can_use_lcd_text();
+  if (client_->PaintsLCDText())
+    SetNeedsDisplay();

[enne (OOO), 2014/06/10 18:46:09]

Re: "The ui::layer will still not be invalidated"

The ui layer could get invalidated right here.  In the past, it could ignore the
callback and not do an invalidation.

[alokp, 2014/06/10 20:54:43]

Not if PaintsLCDText returns false.

+}
+
 }  // namespace cc