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 11 matching lines @@
     return true;
   }
  private:
   void* buffer_;
 };
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
+template <const char* delay_name>
+struct SyntheticDelayInitializer {
+  SyntheticDelayInitializer()
+      : delay(base::debug::TraceEventSyntheticDelay::Lookup(delay_name)) {}
+  base::debug::TraceEventSyntheticDelay* delay;
+};
+
+// Synthetic delay for raster tasks that are required for activation. Global to
+// avoid static initializer on critical path.
+const char kRasterRequiredForActivation[] = "cc.RasterRequiredForActivation";
+static base::LazyInstance<
+    SyntheticDelayInitializer<kRasterRequiredForActivation> >
+    g_raster_required_for_activation_delay = LAZY_INSTANCE_INITIALIZER;
+
 class DisableLCDTextFilter : public SkDrawFilter {
  public:
   // SkDrawFilter interface.
   virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
     if (type != SkDrawFilter::kText_Type)
       return true;
 
     paint->setLCDRenderText(false);
     return true;
   }
@@ skipping 236 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 tasks_pending_for_activation)
       : origin_loop_(base::MessageLoopProxy::current().get()),
-        on_raster_finished_callback_(on_raster_finished_callback) {
+        on_raster_finished_callback_(on_raster_finished_callback),
+        tasks_pending_for_activation_(tasks_pending_for_activation) {
+    if (tasks_pending_for_activation_) {
+      g_raster_required_for_activation_delay.Get().delay->BeginParallel(
+          &activation_delay_end_time_);
+    }
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread");
+    if (tasks_pending_for_activation_) {

[brianderson, 2013/12/17 21:59:16]

To verify my understanding, this only applies the delay if there was at least
one task required for activation?

[Sami, 2013/12/18 13:58:20]

That's correct. Without this condition we were applying the delay even when
there wasn't any actual raster work, which ended up taking up almost all of the
time.

+      g_raster_required_for_activation_delay.Get().delay->EndParallel(

[brianderson, 2013/12/17 21:59:16]

Which patch contains the EndParallel and BeginParallel implementations?

[Sami, 2013/12/18 13:58:20]

Ah, looks like I forgot to cc you; it's over here:
https://codereview.chromium.org/104613003/

+          activation_delay_end_time_);
+    }
     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 tasks_pending_for_activation_;
+  base::TimeTicks activation_delay_end_time_;
 
   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() {
+    RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
+       size_t num_tasks_pending_for_activation) {
   return make_scoped_refptr(
       new RasterFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterRequiredForActivationFinished,
-                     weak_ptr_factory_.GetWeakPtr())));
+                     weak_ptr_factory_.GetWeakPtr()),
+          num_tasks_pending_for_activation > 0u));
 }
 
 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