cc benchmark: minor code cleanup.

. Use OnceCallback for the 'benchmark done' callback.
. Remove an unncessary callback-runner function.

BUG=none

Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel
Change-Id: Ib990293e05960755844fd1e5156e459b187c2e1c
Reviewed-on: https://chromium-review.googlesource.com/887163
Commit-Queue: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532083}

cc/benchmarks/invalidation_benchmark.cc

@@ -29,8 +29,8 @@ const char* kDefaultInvalidationMode = "viewport";
 
 InvalidationBenchmark::InvalidationBenchmark(
     std::unique_ptr<base::Value> value,
-    const MicroBenchmark::DoneCallback& callback)
-    : MicroBenchmark(callback), seed_(0) {
+    MicroBenchmark::DoneCallback callback)
+    : MicroBenchmark(std::move(callback)), seed_(0) {
   base::DictionaryValue* settings = nullptr;
   value->GetAsDictionary(&settings);
   if (!settings)

cc/benchmarks/invalidation_benchmark.h

@@ -22,7 +22,7 @@ class LayerTreeHost;
 class CC_EXPORT InvalidationBenchmark : public MicroBenchmark {
  public:
   explicit InvalidationBenchmark(std::unique_ptr<base::Value> value,
-                                 const MicroBenchmark::DoneCallback& callback);
+                                 MicroBenchmark::DoneCallback callback);
   ~InvalidationBenchmark() override;
 
   // Implements MicroBenchmark interface.

cc/benchmarks/micro_benchmark.cc

@@ -15,8 +15,8 @@
 
 namespace cc {
 
-MicroBenchmark::MicroBenchmark(const DoneCallback& callback)
-    : callback_(callback),
+MicroBenchmark::MicroBenchmark(DoneCallback callback)
+    : callback_(std::move(callback)),
       is_done_(false),
       processed_for_benchmark_impl_(false),
       id_(0) {}
@@ -30,7 +30,7 @@ bool MicroBenchmark::IsDone() const {
 void MicroBenchmark::DidUpdateLayers(LayerTreeHost* layer_tree_host) {}
 
 void MicroBenchmark::NotifyDone(std::unique_ptr<base::Value> result) {
-  callback_.Run(std::move(result));
+  std::move(callback_).Run(std::move(result));
   is_done_ = true;
 }
 

cc/benchmarks/micro_benchmark.h

@@ -23,9 +23,9 @@ class PictureLayer;
 class MicroBenchmarkImpl;
 class CC_EXPORT MicroBenchmark {
  public:
-  typedef base::Callback<void(std::unique_ptr<base::Value>)> DoneCallback;
+  using DoneCallback = base::OnceCallback<void(std::unique_ptr<base::Value>)>;
 
-  explicit MicroBenchmark(const DoneCallback& callback);
+  explicit MicroBenchmark(DoneCallback callback);
   virtual ~MicroBenchmark();
 
   bool IsDone() const;

cc/benchmarks/micro_benchmark_controller.cc

@@ -27,14 +27,16 @@ namespace {
 std::unique_ptr<MicroBenchmark> CreateBenchmark(
     const std::string& name,
     std::unique_ptr<base::Value> value,
-    const MicroBenchmark::DoneCallback& callback) {
+    MicroBenchmark::DoneCallback callback) {
   if (name == "invalidation_benchmark") {
-    return std::make_unique<InvalidationBenchmark>(std::move(value), callback);
+    return std::make_unique<InvalidationBenchmark>(std::move(value),
+                                                   std::move(callback));
   } else if (name == "rasterize_and_record_benchmark") {
     return std::make_unique<RasterizeAndRecordBenchmark>(std::move(value),
-                                                         callback);
+                                                         std::move(callback));
   } else if (name == "unittest_only_benchmark") {
-    return std::make_unique<UnittestOnlyBenchmark>(std::move(value), callback);
+    return std::make_unique<UnittestOnlyBenchmark>(std::move(value),
+                                                   std::move(callback));
   }
   return nullptr;
 }
@@ -54,9 +56,9 @@ MicroBenchmarkController::~MicroBenchmarkController() = default;
 int MicroBenchmarkController::ScheduleRun(
     const std::string& micro_benchmark_name,
     std::unique_ptr<base::Value> value,
-    const MicroBenchmark::DoneCallback& callback) {
-  std::unique_ptr<MicroBenchmark> benchmark =
-      CreateBenchmark(micro_benchmark_name, std::move(value), callback);
+    MicroBenchmark::DoneCallback callback) {
+  std::unique_ptr<MicroBenchmark> benchmark = CreateBenchmark(
+      micro_benchmark_name, std::move(value), std::move(callback));
   if (benchmark.get()) {
     int id = GetNextIdAndIncrement();
     benchmark->set_id(id);

cc/benchmarks/micro_benchmark_controller.h

@@ -31,7 +31,7 @@ class CC_EXPORT MicroBenchmarkController {
   // Returns the id of the benchmark on success, 0 otherwise.
   int ScheduleRun(const std::string& micro_benchmark_name,
                   std::unique_ptr<base::Value> value,
-                  const MicroBenchmark::DoneCallback& callback);
+                  MicroBenchmark::DoneCallback callback);
   // Returns true if the message was successfully delivered and handled.
   bool SendMessage(int id, std::unique_ptr<base::Value> value);
 

cc/benchmarks/micro_benchmark_impl.cc

@@ -14,18 +14,10 @@
 
 namespace cc {
 
-namespace {
-
-void RunCallback(const MicroBenchmarkImpl::DoneCallback& callback,
-                 std::unique_ptr<base::Value> result) {
-  callback.Run(std::move(result));
-}
-}
-
 MicroBenchmarkImpl::MicroBenchmarkImpl(
-    const DoneCallback& callback,
+    DoneCallback callback,
     scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner)
-    : callback_(callback),
+    : callback_(std::move(callback)),
       is_done_(false),
       origin_task_runner_(origin_task_runner) {}
 
@@ -39,7 +31,7 @@ void MicroBenchmarkImpl::DidCompleteCommit(LayerTreeHostImpl* host) {}
 
 void MicroBenchmarkImpl::NotifyDone(std::unique_ptr<base::Value> result) {
   origin_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(RunCallback, callback_, base::Passed(&result)));
+      FROM_HERE, base::BindOnce(std::move(callback_), base::Passed(&result)));
   is_done_ = true;
 }
 

cc/benchmarks/micro_benchmark_impl.h

@@ -22,10 +22,10 @@ class LayerImpl;
 class PictureLayerImpl;
 class CC_EXPORT MicroBenchmarkImpl {
  public:
-  typedef base::Callback<void(std::unique_ptr<base::Value>)> DoneCallback;
+  using DoneCallback = base::OnceCallback<void(std::unique_ptr<base::Value>)>;
 
   explicit MicroBenchmarkImpl(
-      const DoneCallback& callback,
+      DoneCallback callback,
       scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner);
   virtual ~MicroBenchmarkImpl();
 

cc/benchmarks/rasterize_and_record_benchmark.cc

@@ -68,8 +68,8 @@ RecordingModeToPaintingControlSetting(RecordingSource::RecordingMode mode) {
 
 RasterizeAndRecordBenchmark::RasterizeAndRecordBenchmark(
     std::unique_ptr<base::Value> value,
-    const MicroBenchmark::DoneCallback& callback)
-    : MicroBenchmark(callback),
+    MicroBenchmark::DoneCallback callback)
+    : MicroBenchmark(std::move(callback)),
       record_repeat_count_(kDefaultRecordRepeatCount),
       settings_(std::move(value)),
       main_thread_benchmark_done_(false),

cc/benchmarks/rasterize_and_record_benchmark.h

@@ -27,9 +27,8 @@ class LayerTreeHost;
 
 class RasterizeAndRecordBenchmark : public MicroBenchmark {
  public:
-  explicit RasterizeAndRecordBenchmark(
-      std::unique_ptr<base::Value> value,
-      const MicroBenchmark::DoneCallback& callback);
+  explicit RasterizeAndRecordBenchmark(std::unique_ptr<base::Value> value,
+                                       MicroBenchmark::DoneCallback callback);
   ~RasterizeAndRecordBenchmark() override;
 
   // Implements MicroBenchmark interface.

cc/benchmarks/rasterize_and_record_benchmark_impl.cc

@@ -126,8 +126,8 @@ class FixedInvalidationPictureLayerTilingClient
 RasterizeAndRecordBenchmarkImpl::RasterizeAndRecordBenchmarkImpl(
     scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner,
     base::Value* value,
-    const MicroBenchmarkImpl::DoneCallback& callback)
-    : MicroBenchmarkImpl(callback, origin_task_runner),
+    MicroBenchmarkImpl::DoneCallback callback)
+    : MicroBenchmarkImpl(std::move(callback), origin_task_runner),
       rasterize_repeat_count_(kDefaultRasterizeRepeatCount) {
   base::DictionaryValue* settings = nullptr;
   value->GetAsDictionary(&settings);

cc/benchmarks/rasterize_and_record_benchmark_impl.h

@@ -26,7 +26,7 @@ class RasterizeAndRecordBenchmarkImpl : public MicroBenchmarkImpl {
   explicit RasterizeAndRecordBenchmarkImpl(
       scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner,
       base::Value* value,
-      const MicroBenchmarkImpl::DoneCallback& callback);
+      MicroBenchmarkImpl::DoneCallback callback);
   ~RasterizeAndRecordBenchmarkImpl() override;
 
   // Implements MicroBenchmark interface.

cc/benchmarks/unittest_only_benchmark.cc

@@ -13,8 +13,8 @@
 namespace cc {
 
 UnittestOnlyBenchmark::UnittestOnlyBenchmark(std::unique_ptr<base::Value> value,
-                                             const DoneCallback& callback)
-    : MicroBenchmark(callback),
+                                             DoneCallback callback)
+    : MicroBenchmark(std::move(callback)),
       create_impl_benchmark_(false),
       weak_ptr_factory_(this) {
   if (!value)

cc/benchmarks/unittest_only_benchmark.h

@@ -14,7 +14,7 @@ namespace cc {
 class CC_EXPORT UnittestOnlyBenchmark : public MicroBenchmark {
  public:
   UnittestOnlyBenchmark(std::unique_ptr<base::Value> value,
-                        const DoneCallback& callback);
+                        DoneCallback callback);
   ~UnittestOnlyBenchmark() override;
 
   void DidUpdateLayers(LayerTreeHost* layer_tree_host) override;

cc/benchmarks/unittest_only_benchmark_impl.cc

@@ -12,8 +12,8 @@ namespace cc {
 UnittestOnlyBenchmarkImpl::UnittestOnlyBenchmarkImpl(
     scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner,
     base::Value* settings,
-    const DoneCallback& callback)
-    : MicroBenchmarkImpl(callback, origin_task_runner) {}
+    DoneCallback callback)
+    : MicroBenchmarkImpl(std::move(callback), origin_task_runner) {}
 
 UnittestOnlyBenchmarkImpl::~UnittestOnlyBenchmarkImpl() = default;
 

cc/benchmarks/unittest_only_benchmark_impl.h

@@ -21,7 +21,7 @@ class CC_EXPORT UnittestOnlyBenchmarkImpl : public MicroBenchmarkImpl {
   UnittestOnlyBenchmarkImpl(
       scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner,
       base::Value* settings,
-      const DoneCallback& callback);
+      DoneCallback callback);
   ~UnittestOnlyBenchmarkImpl() override;
 
   void DidCompleteCommit(LayerTreeHostImpl* host) override;

cc/trees/layer_tree_host.cc

@@ -929,9 +929,9 @@ void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
 int LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     std::unique_ptr<base::Value> value,
-    const MicroBenchmark::DoneCallback& callback) {
-  return micro_benchmark_controller_.ScheduleRun(benchmark_name,
-                                                 std::move(value), callback);
+    MicroBenchmark::DoneCallback callback) {
+  return micro_benchmark_controller_.ScheduleRun(
+      benchmark_name, std::move(value), std::move(callback));
 }
 
 bool LayerTreeHost::SendMessageToMicroBenchmark(

cc/trees/layer_tree_host.h

@@ -222,7 +222,7 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient {
   // Returns the id of the benchmark on success, 0 otherwise.
   int ScheduleMicroBenchmark(const std::string& benchmark_name,
                              std::unique_ptr<base::Value> value,
-                             const MicroBenchmark::DoneCallback& callback);
+                             MicroBenchmark::DoneCallback callback);
 
   // Returns true if the message was successfully delivered and handled.
   bool SendMessageToMicroBenchmark(int id, std::unique_ptr<base::Value> value);