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"
 
 namespace cc {
 
 namespace {
 
+// Synthetic delay for raster tasks that are required for activation. Global to
+// avoid static initializer on critical path.
+base::debug::TraceEventSyntheticDelay* g_raster_required_for_activation_delay;
+
 // Subclass of Allocator that takes a suitably allocated pointer and uses
 // it as the pixel memory for the bitmap.
 class IdentityAllocator : public SkBitmap::Allocator {
  public:
   explicit IdentityAllocator(void* buffer) : buffer_(buffer) {}
   virtual bool allocPixelRef(SkBitmap* dst, SkColorTable*) OVERRIDE {
     dst->setPixels(buffer_);
     return true;
   }
  private:
@@ skipping 153 matching lines @@
           rendering_stats_->impl_thread_rendering_stats().rasterize_time;
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           100000,
           100);
     }
 
     ChangeBitmapConfigIfNeeded(bitmap, buffer);
+    g_raster_required_for_activation_delay->End();
 
     return true;
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
                                  int stride)
       OVERRIDE {
@@ skipping 255 matching lines @@
                                                 stats_instrumentation,
                                                 reply));
 }
 
 RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
                                    size_t num_threads)
     : WorkerPool(num_threads, kWorkerThreadNamePrefix),
       client_(NULL),
       resource_provider_(resource_provider),
       weak_ptr_factory_(this) {
+  g_raster_required_for_activation_delay =
+      base::debug::TraceEventSyntheticDelay::Lookup(
+          "cc.RasterRequiredForActivation");

[reveman, 2013/12/12 19:29:43]

what if this is done on two threads at the same time? can we use a LazyInstance
to make this thread safe?

 }
 
 RasterWorkerPool::~RasterWorkerPool() {
 }
 
 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
   client_ = client;
 }
 
 void RasterWorkerPool::Shutdown() {
   raster_tasks_.clear();
   TaskGraph empty;
   SetTaskGraph(&empty);
   WorkerPool::Shutdown();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void RasterWorkerPool::SetRasterTasks(RasterTask::Queue* queue) {
   raster_tasks_.swap(queue->tasks_);
   raster_tasks_required_for_activation_.swap(
       queue->tasks_required_for_activation_);
+  // Note: a raster task from the previous task set may call End() even after
+  // this reset. When this happens, the synthetic delay will get activated
+  // early, increasing the total activation delay the length of one raster
+  // task. Because tasks from the old set may still be needed to activate the
+  // new tree, we can't entirely discount them. This is therefore a compromise
+  // to ensure the activation delay is always at least as long as configured.
+  g_raster_required_for_activation_delay->ResetAndBeginMultiple(
+      raster_tasks_required_for_activation_.size());

[reveman, 2013/12/12 19:29:43]

This seems a bit too flaky to me. Could we do this as part of the
RasterFinishedWorkerPoolTaskImpl task instead and never reset it?

 }
 
 bool RasterWorkerPool::IsRasterTaskRequiredForActivation(
     internal::RasterWorkerPoolTask* task) const {
   return
       raster_tasks_required_for_activation_.find(task) !=
       raster_tasks_required_for_activation_.end();
 }
 
 scoped_refptr<internal::WorkerPoolTask>
@@ skipping 86 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc