Add synthetic delay points for latency testing

cc/resources/raster_worker_pool.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/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"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "skia/ext/lazy_pixel_ref.h"
 #include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
@@ skipping 83 matching lines @@
   bool RunRasterOnThread(unsigned thread_index,
                          void* buffer,
                          gfx::Size size,
                          int stride) {
     TRACE_EVENT2(
         "cc", "RasterWorkerPoolTaskImpl::RunRasterOnThread",
         "data",
         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_);
 
     DCHECK(picture_pile_.get());
     DCHECK(buffer);
 
     if (analysis_.is_solid_color)
       return false;
 
@@ skipping 163 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl);
 };
 
 class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   typedef base::Callback<void(const internal::WorkerPoolTask* source)>
       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,
                    this));
   }
   virtual void CompleteOnOriginThread() OVERRIDE {}
 
  private:
   virtual ~RasterFinishedWorkerPoolTaskImpl() {}
 
   void RunOnOriginThread() const {
     on_raster_finished_callback_.Run(this);
   }
 
   scoped_refptr<base::MessageLoopProxy> origin_loop_;
   const Callback on_raster_finished_callback_;
+  const bool required_for_activation_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
 };
 
 const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 }  // namespace
 
 namespace internal {
 
@@ skipping 167 matching lines @@
   return
       raster_tasks_required_for_activation_.find(task) !=
       raster_tasks_required_for_activation_.end();
 }
 
 scoped_refptr<internal::WorkerPoolTask>
     RasterWorkerPool::CreateRasterFinishedTask() {
   return make_scoped_refptr(
       new RasterFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterFinished,
-                     weak_ptr_factory_.GetWeakPtr())));
+                     weak_ptr_factory_.GetWeakPtr()),
+          false));
 }
 
 scoped_refptr<internal::WorkerPoolTask>
     RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask() {
   return make_scoped_refptr(
       new RasterFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished,
-                     weak_ptr_factory_.GetWeakPtr())));
+                     weak_ptr_factory_.GetWeakPtr()),
+          true));
 }
 
 void RasterWorkerPool::OnRasterFinished(
     const internal::WorkerPoolTask* source) {
   TRACE_EVENT0("cc", "RasterWorkerPool::OnRasterFinished");
 
   // Early out if current |raster_finished_task_| is not the source.
   if (source != raster_finished_task_.get())
     return;
 
@@ skipping 63 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc