cc: Add message passing mechanism to micro benchmarking.

cc/debug/micro_benchmark_controller.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/micro_benchmark_controller.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/values.h"
 #include "cc/debug/picture_record_benchmark.h"
 #include "cc/debug/rasterize_and_record_benchmark.h"
 #include "cc/debug/unittest_only_benchmark.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_impl.h"
 
 namespace cc {
 
 namespace {
 
 scoped_ptr<MicroBenchmark> CreateBenchmark(
     const std::string& name,
     scoped_ptr<base::Value> value,
-    const MicroBenchmark::DoneCallback& callback) {
+    const MicroBenchmark::DoneCallback& callback,
+    int id) {
   if (name == "picture_record_benchmark") {
     return scoped_ptr<MicroBenchmark>(
-        new PictureRecordBenchmark(value.Pass(), callback));
+        new PictureRecordBenchmark(value.Pass(), callback, id));
   } else if (name == "rasterize_and_record_benchmark") {
     return scoped_ptr<MicroBenchmark>(
-        new RasterizeAndRecordBenchmark(value.Pass(), callback));
+        new RasterizeAndRecordBenchmark(value.Pass(), callback, id));
   } else if (name == "unittest_only_benchmark") {
     return scoped_ptr<MicroBenchmark>(
-        new UnittestOnlyBenchmark(value.Pass(), callback));
+        new UnittestOnlyBenchmark(value.Pass(), callback, id));
   }
   return scoped_ptr<MicroBenchmark>();
 }
 
 class IsDonePredicate {
  public:
   typedef const MicroBenchmark* argument_type;
   typedef bool result_type;
 
   result_type operator()(argument_type benchmark) const {
     return benchmark->IsDone();
   }
 };
 
 }  // namespace
 
 MicroBenchmarkController::MicroBenchmarkController(LayerTreeHost* host)
     : host_(host),
+      next_id_(1),
       main_controller_message_loop_(base::MessageLoopProxy::current().get()) {
   DCHECK(host_);
 }
 
 MicroBenchmarkController::~MicroBenchmarkController() {}
 
-bool MicroBenchmarkController::ScheduleRun(
+int MicroBenchmarkController::ScheduleRun(
     const std::string& micro_benchmark_name,
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
+  int id = GetNextIdAndIncrement();
   scoped_ptr<MicroBenchmark> benchmark =
-      CreateBenchmark(micro_benchmark_name, value.Pass(), callback);
+      CreateBenchmark(micro_benchmark_name, value.Pass(), callback, id);
   if (benchmark.get()) {
     benchmarks_.push_back(benchmark.Pass());
     host_->SetNeedsCommit();
-    return true;
+    return id;
+  }
+  return 0;
+}
+
+int MicroBenchmarkController::GetNextIdAndIncrement() {
+  int id = next_id_++;
+  // Wrap around to 1 if we overflow (very unlikely).
+  if (next_id_ < 1)

[vmpstr, 2014/05/28 21:16:25]

signed int overflow is undefined... Maybe something like

if (next_id_ == std::numeric_limits<int>::max())
  next_id_ = 1;

[ernstm, 2014/05/28 21:51:55]

Done.

+    next_id_ = 1;
+  return id;
+}
+
+bool MicroBenchmarkController::SendMessage(int id,

[vmpstr, 2014/05/28 21:16:25]

I'm sorry to go back on what I said earlier, but... :P


Maybe we can have SendMessageToMicroBenchmark ->
MicroBenchmarkController::ProcessMessage -> MicroBenchmark::ProcessMessage?

It's kind of ambiguous what "SendMessage" means in the benchmark context... is
it that it's a request to send a message or is it a message being sent?

[ernstm, 2014/05/28 21:51:55]

As discussed offline, renamed the function to ProcessMessage on MicroBenchmark,
but I kept SendMessage on the controller, because this forwards the message to
the benchmark.

+                                           scoped_ptr<base::Value> value) {
+  for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
+       it != benchmarks_.end();
+       ++it) {
+    if ((*it)->id() == id)
+      return (*it)->SendMessage(value.Pass());
   }
   return false;
 }
 
 void MicroBenchmarkController::ScheduleImplBenchmarks(
     LayerTreeHostImpl* host_impl) {
   for (ScopedPtrVector<MicroBenchmark>::iterator it = benchmarks_.begin();
        it != benchmarks_.end();
        ++it) {
     scoped_ptr<MicroBenchmarkImpl> benchmark_impl;
@@ skipping 18 matching lines @@
   CleanUpFinishedBenchmarks();
 }
 
 void MicroBenchmarkController::CleanUpFinishedBenchmarks() {
   benchmarks_.erase(
       benchmarks_.partition(std::not1(IsDonePredicate())),
       benchmarks_.end());
 }
 
 }  // namespace cc