Home | History | Annotate | Download | only in debug 
      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
    107