cc: Merge LayerTree into the LayerTreeHost.

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 <stddef.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/debug/rasterize_and_record_benchmark_impl.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/recording_source.h"
-#include "cc/trees/layer_tree.h"
+#include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
 
 namespace {
 
 const int kDefaultRecordRepeatCount = 100;
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 RasterizeAndRecordBenchmark::RasterizeAndRecordBenchmark(
     std::unique_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback)
     : MicroBenchmark(callback),
       record_repeat_count_(kDefaultRecordRepeatCount),
       settings_(std::move(value)),
       main_thread_benchmark_done_(false),
-      layer_tree_(nullptr),
+      layer_tree_host_(nullptr),
       weak_ptr_factory_(this) {
   base::DictionaryValue* settings = nullptr;
   settings_->GetAsDictionary(&settings);
   if (!settings)
     return;
 
   if (settings->HasKey("record_repeat_count"))
     settings->GetInteger("record_repeat_count", &record_repeat_count_);
 }
 
 RasterizeAndRecordBenchmark::~RasterizeAndRecordBenchmark() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
-void RasterizeAndRecordBenchmark::DidUpdateLayers(LayerTree* layer_tree) {
-  layer_tree_ = layer_tree;
+void RasterizeAndRecordBenchmark::DidUpdateLayers(
+    LayerTreeHost* layer_tree_host) {
+  layer_tree_host_ = layer_tree_host;
   LayerTreeHostCommon::CallFunctionForEveryLayer(
-      layer_tree, [this](Layer* layer) { layer->RunMicroBenchmark(this); });
+      layer_tree_host_,
+      [this](Layer* layer) { layer->RunMicroBenchmark(this); });
 
   DCHECK(!results_.get());
   results_ = base::WrapUnique(new base::DictionaryValue);
   results_->SetInteger("pixels_recorded", record_results_.pixels_recorded);
   results_->SetInteger("picture_memory_usage",
                        static_cast<int>(record_results_.bytes_used));
 
   for (int i = 0; i < RecordingSource::RECORDING_MODE_COUNT; i++) {
     std::string name = base::StringPrintf("record_time%s_ms", kModeSuffixes[i]);
     results_->SetDouble(name,
@@ skipping 18 matching lines @@
 std::unique_ptr<MicroBenchmarkImpl>
 RasterizeAndRecordBenchmark::CreateBenchmarkImpl(
     scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner) {
   return base::WrapUnique(new RasterizeAndRecordBenchmarkImpl(
       origin_task_runner, settings_.get(),
       base::Bind(&RasterizeAndRecordBenchmark::RecordRasterResults,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
 void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
-  DCHECK(layer_tree_);
+  DCHECK(layer_tree_host_);
 
   if (!layer->DrawsContent())
     return;
 
   ContentLayerClient* painter = layer->client();
 
   for (int mode_index = 0; mode_index < RecordingSource::RECORDING_MODE_COUNT;
        mode_index++) {
     ContentLayerClient::PaintingControlSetting painting_control =
         RecordingModeToPaintingControlSetting(
@@ skipping 42 matching lines @@
   }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
     : pixels_recorded(0), bytes_used(0) {
 }
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 
 }  // namespace cc