cc/debug/micro_benchmark_controller.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/debug/micro_benchmark_controller.h"
   6
   7 #include <string>
   8
   9 #include "base/callback.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11 #include "base/values.h"
  12 #include "cc/debug/picture_record_benchmark.h"
  13 #include "cc/debug/rasterize_and_record_benchmark.h"
  14 #include "cc/debug/unittest_only_benchmark.h"
  15 #include "cc/trees/layer_tree_host.h"
  16 #include "cc/trees/layer_tree_host_impl.h"
  17
  18 namespace cc {
  19
  20 namespace {
  21
  22 scoped_ptr<MicroBenchmark> CreateBenchmark(
  23     const std::string& name,
  24     scoped_ptr<base::Value> value,
  25     const MicroBenchmark::DoneCallback& callback) {
  26   if (name == "picture_record_benchmark") {
  27     return scoped_ptr<MicroBenchmark>(
  28         new PictureRecordBenchmark(value.Pass(), callback));
  29   } else if (name == "rasterize_and_record_benchmark") {
  30     return scoped_ptr<MicroBenchmark>(
  31         new RasterizeAndRecordBenchmark(value.Pass(), callback));
  32   } else if (name == "unittest_only_benchmark") {
  33     return scoped_ptr<MicroBenchmark>(
  34         new UnittestOnlyBenchmark(value.Pass(), callback));
  35   }
  36   return scoped_ptr<MicroBenchmark>();
  37 }
  38
  39 class IsDonePredicate {
  40  public:
  41   typedef const MicroBenchmark* argument_type;
  42   typedef bool result_type;
  43
  44   result_type operator()(argument_type benchmark) const {
  45     return benchmark->IsDone();
  46   }
  47 };
  48
  49 }  // namespace
  50
  51 MicroBenchmarkController::MicroBenchmarkController(LayerTreeHost* host)
  52     : host_(host),
  53       main_controller_message_loop_(base::MessageLoopProxy::current().get()) {
  54   DCHECK(host_);
  55 }
  56
  57 MicroBenchmarkController::~MicroBenchmarkController() {}
  58
  59 bool MicroBenchmarkController::ScheduleRun(
  60     const std::string& micro_benchmark_name,
  61     scoped_ptr<base::Value> value,
  62     const MicroBenchmark::DoneCallback& callback) {
  63   scoped_ptr<MicroBenchmark> benchmark =
  64       CreateBenchmark(micro_benchmark_name, value.Pass(), callback);
  65   if (benchmark.get()) {
  66     benchmarks_.push_back(benchmark.Pass());
  67     host_->SetNeedsCommit();
  68     return true;
  69   }
  70   return false;
  71 }
  72
  73 void MicroBenchmarkController::ScheduleImplBenchmarks(
  74     LayerTreeHostImpl* host_impl) {
  75   for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
  76        it != benchmarks_.end();
  77        ++it) {
  78     scoped_ptr<MicroBenchmarkImpl> benchmark_impl;
  79     if (!(*it)->ProcessedForBenchmarkImpl()) {
  80       benchmark_impl =
  81           (*it)->GetBenchmarkImpl(main_controller_message_loop_);
  82     }
  83
  84     if (benchmark_impl.get())
  85       host_impl->ScheduleMicroBenchmark(benchmark_impl.Pass());
  86   }
  87 }
  88
  89 void MicroBenchmarkController::DidUpdateLayers() {
  90   for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
  91        it != benchmarks_.end();
  92        ++it) {
  93     if (!(*it)->IsDone())
  94       (*it)->DidUpdateLayers(host_);
  95   }
  96
  97   CleanUpFinishedBenchmarks();
  98 }
  99
 100 void MicroBenchmarkController::CleanUpFinishedBenchmarks() {
 101   benchmarks_.erase(
 102       benchmarks_.partition(std::not1(IsDonePredicate())),
 103       benchmarks_.end());
 104 }
 105
 106 }  // namespace cc