Add synthetic delay points for latency testing

cc/resources/raster_worker_pool.cc

Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 67c548f19df92fe1f0990475689a157718a7d392..820f44fd0ff8cd4989ac180b7b74ac60b97a7bf0 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -4,6 +4,7 @@
 
 #include "cc/resources/raster_worker_pool.h"
 
+#include "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
@@ -107,6 +108,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
         TracedValue::FromValue(DataAsValue().release()),
         "raster_mode",
         TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
+    TRACE_EVENT_SYNTHETIC_DELAY_ACTIVATE("cc.RasterRequiredForActivation");

[nduca, 2013/11/24 19:45:18]

so i'm worried about how many traces we've got on the raster workers at this
point. i think there are two already, this makes the third. is this basically
inevitable and I should quit whining? Is there a way to initialize the delay
object elsewhere and pass it in as an argument?

static initializers have a runtime penalty basically

[Sami, 2013/12/02 14:57:08]

Yeah, we should be careful with this stuff in tight places. I've now made this
delay a global that gets initialized when the raster worker pool gets
constructed. The remaining work on the critical path is now a pointer deref and
a 64-bit compare against zero (base::TimeDelta).

 
     devtools_instrumentation::ScopedLayerTask raster_task(
         devtools_instrumentation::kRasterTask, layer_id_);
@@ -290,14 +292,18 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
       Callback;
 
   RasterFinishedWorkerPoolTaskImpl(
-      const Callback& on_raster_finished_callback)
+      const Callback& on_raster_finished_callback,
+      bool required_for_activation)
       : origin_loop_(base::MessageLoopProxy::current().get()),
-        on_raster_finished_callback_(on_raster_finished_callback) {
+        on_raster_finished_callback_(on_raster_finished_callback),
+        required_for_activation_(required_for_activation) {
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread");
+    if (required_for_activation_)
+      TRACE_EVENT_SYNTHETIC_DELAY_APPLY("cc.RasterRequiredForActivation");

[brianderson, 2013/11/26 03:14:54]

I'm not up-to-date on the lates TileManager code. Does this apply the delay on
the last tile required for raterization, or does it apply the delay to the first
tile(s)?

[Sami, 2013/12/02 14:57:08]

The way it roughly works is that we first schedule a bunch of
RasterWorkerPoolTaskImpls to do the rasterization and then one (or more)
sentinel tasks -- RasterFinishedWorkerPoolTaskImpl -- at the end to detect when
the tasks that were required for activation have finished (see
PixelBufferRasterWorkerPool::ScheduleMoreTasks). Like this:

 [raster] [raster] [raster] [raster_finished]

The synthetic delay here applies to the sentinel task by delaying the
notification from it to the compositor thread. This means that the raster tasks
themselves run on time without delays, but the final activation signal is
postponed.

[brianderson, 2013/12/03 03:00:30]

Ah ok. I see now. I'm assuming the graph is set up such that the activation task
is only called after the last raster required for activation even when there are
multiple raster threads? If not, it'll be better to fix that as separate patch
anyway, so this patch lgtm.

     origin_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread,
@@ -314,6 +320,7 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
 
   scoped_refptr<base::MessageLoopProxy> origin_loop_;
   const Callback on_raster_finished_callback_;
+  const bool required_for_activation_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
 };
@@ -501,7 +508,8 @@ scoped_refptr<internal::WorkerPoolTask>
   return make_scoped_refptr(
       new RasterFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterFinished,
-                     weak_ptr_factory_.GetWeakPtr())));
+                     weak_ptr_factory_.GetWeakPtr()),
+          false));
 }
 
 scoped_refptr<internal::WorkerPoolTask>
@@ -509,7 +517,8 @@ scoped_refptr<internal::WorkerPoolTask>
   return make_scoped_refptr(
       new RasterFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished,
-                     weak_ptr_factory_.GetWeakPtr())));
+                     weak_ptr_factory_.GetWeakPtr()),
+          true));
 }
 
 void RasterWorkerPool::OnRasterFinished(