cc: Plumbing for impl thread micro benchmarks

cc/debug/micro_benchmark_impl.cc

Index: cc/debug/micro_benchmark_impl.cc
diff --git a/cc/debug/micro_benchmark_impl.cc b/cc/debug/micro_benchmark_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7ec58c8de0be3c8afe1b2fcf7ec35a3dfd16973c
--- /dev/null
+++ b/cc/debug/micro_benchmark_impl.cc
@@ -0,0 +1,48 @@
+// 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_impl.h"
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/values.h"
+
+namespace cc {
+
+namespace {
+
+void RunCallback(const MicroBenchmarkImpl::DoneCallback& callback,

[enne (OOO), 2013/11/12 01:09:36]

Do you expect other MicroBenchmarkImpl to do something else in this callback?
What about just making MicroBenchmarkImpl provide this common  callback and call
some virtual MicroBenchmark::DidFinishMicroBenchmarkImpl function?

[vmpstr, 2013/11/12 17:51:38]

I'm not sure I understand what you mean... You mean do something different in
the RunCallback or in |callback|? As it stands now, |callback| is the only link
between the original MicroBenchmark and the Impl part. That is, the original
micro benchmark after creating the impl part doesn't keep track of it, it just
gives it a callback to call when it's done. I could change it so that impl
benchmark has a pointer to the benchmark that created it and then post a
particular function call on the main thread. Is that kind of what you are
suggesting or am I misunderstanding?

[enne (OOO), 2013/11/12 19:22:56]

Ah, fair enough.

+                 scoped_ptr<base::Value> result) {
+  callback.Run(result.Pass());
+}
+
+}
+
+MicroBenchmarkImpl::MicroBenchmarkImpl(
+    const DoneCallback& callback,
+    scoped_refptr<base::MessageLoopProxy> origin_loop)

[enne (OOO), 2013/11/12 01:09:36]

What about making MicroBenchmarkImpl provide a virtual scoped_ptr<base::Value>
result() const function and have
MicroBenchmarkControllerImpl::CleanUpFinishedBenchmarks() post all the tasks via
host_impl_->proxy()->MainThreadTaskRunner()?

That'd clean up a lot of APIs where you have to ferry around the main thread
message loop (although you lose the NotifyDone symmetry).

[vmpstr, 2013/11/12 17:51:38]

I do like the NotifyDone style thing, since it makes MicroBenchmarkImpl derived
implementations look very similar to MicroBenchmark derived implementations. I
will try the approach you're suggesting though.

+    : callback_(callback), is_done_(false), origin_loop_(origin_loop) {}
+
+MicroBenchmarkImpl::~MicroBenchmarkImpl() {}
+
+bool MicroBenchmarkImpl::IsDone() const {
+  return is_done_;
+}
+
+void MicroBenchmarkImpl::DidCompleteCommit(LayerTreeHostImpl* host) {}
+
+void MicroBenchmarkImpl::NotifyDone(scoped_ptr<base::Value> result) {
+  origin_loop_->PostTask(
+    FROM_HERE,
+    base::Bind(RunCallback, callback_, base::Passed(&result)));
+  is_done_ = true;
+}
+
+void MicroBenchmarkImpl::RunOnLayer(LayerImpl* layer) {}
+
+void MicroBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {}
+
+}  // namespace cc