Plumb can_use_lcd_text, contents_opaque directly to ContentLayerClient.

cc/debug/rasterize_and_record_benchmark.cc

 // Copyright 2013 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/debug/rasterize_and_record_benchmark.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 83 matching lines @@
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
 void RasterizeAndRecordBenchmark::Run(Layer* layer) {
   layer->RunMicroBenchmark(this);
 }
 
 void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
   ContentLayerClient* painter = layer->client();
   gfx::Size content_bounds = layer->content_bounds();
+  bool can_use_lcd_text = layer->can_use_lcd_text();
+  bool contents_opaque = layer->contents_opaque();
 
   DCHECK(host_);
   gfx::Size tile_grid_size = host_->settings().default_tile_size;
 
   SkTileGridFactory::TileGridInfo tile_grid_info;
   PicturePileBase::ComputeTileGridInfo(tile_grid_size, &tile_grid_info);
 
   gfx::Rect visible_content_rect = gfx::ScaleToEnclosingRect(
       layer->visible_content_rect(), 1.f / layer->contents_scale_x());
   if (visible_content_rect.IsEmpty())
@@ skipping 10 matching lines @@
     const int kWarmupRuns = 0;
     const int kTimeCheckInterval = 1;
 
     for (int i = 0; i < record_repeat_count_; ++i) {
       // Run for a minimum amount of time to avoid problems with timer
       // quantization when the layer is very small.
       LapTimer timer(kWarmupRuns,
                      base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                      kTimeCheckInterval);
       do {
-        scoped_refptr<Picture> picture = Picture::Create(
-            visible_content_rect, painter, tile_grid_info, false, mode);
+        bool gather_pixels_refs = false;
+        scoped_refptr<Picture> picture = Picture::Create(visible_content_rect,
+                                                         painter,
+                                                         can_use_lcd_text,
+                                                         contents_opaque,
+                                                         tile_grid_info,
+                                                         gather_pixels_refs,
+                                                         mode);
         timer.NextLap();
       } while (!timer.HasTimeLimitExpired());
       base::TimeDelta duration =
           base::TimeDelta::FromMillisecondsD(timer.MsPerLap());
       if (duration < min_time)
         min_time = duration;
     }
 
     if (mode == Picture::RECORD_NORMALLY) {
       record_results_.pixels_recorded +=
           visible_content_rect.width() * visible_content_rect.height();
     }
     record_results_.total_best_time[mode_index] += min_time;
   }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
     : pixels_recorded(0) {}
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 
 }  // namespace cc