Add synthetic delay points for latency testing

gpu/command_buffer/service/async_pixel_transfer_manager_idle.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 "gpu/command_buffer/service/async_pixel_transfer_manager_idle.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
+#include "base/debug/trace_event_synthetic_delay.h"
 #include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
 #include "gpu/command_buffer/service/safe_shared_memory_pool.h"
 #include "ui/gl/scoped_binders.h"
 
 namespace gpu {
 
 namespace {
 
 base::LazyInstance<SafeSharedMemoryPool> g_safe_shared_memory_pool =
@@ skipping 72 matching lines @@
       transfer_in_progress_(false),
       define_params_(define_params),
       shared_state_(shared_state) {}
 
 AsyncPixelTransferDelegateIdle::~AsyncPixelTransferDelegateIdle() {}
 
 void AsyncPixelTransferDelegateIdle::AsyncTexImage2D(
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
+  TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
       id_,
       base::Bind(
           &AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D,
           AsWeakPtr(),
           tex_params,
           mem_params,
           bind_callback,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)))));
 
   transfer_in_progress_ = true;
 }
 
 void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D(
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
+  TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
       id_,
       base::Bind(
           &AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D,
           AsWeakPtr(),
@@ skipping 47 matching lines @@
         tex_params.level,
         tex_params.internal_format,
         tex_params.width,
         tex_params.height,
         tex_params.border,
         tex_params.format,
         tex_params.type,
         data);
   }
 
+  TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
   transfer_in_progress_ = false;
   shared_state_->texture_upload_count++;
   shared_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time;
 
   // The texture is already fully bound so just call it now.
   bind_callback.Run();
 }
 
 void AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D(
@@ skipping 35 matching lines @@
         tex_params.level,
         tex_params.xoffset,
         tex_params.yoffset,
         tex_params.width,
         tex_params.height,
         tex_params.format,
         tex_params.type,
         data);
   }
 
+  TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
   transfer_in_progress_ = false;
   shared_state_->texture_upload_count++;
   shared_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time;
 }
 
 AsyncPixelTransferManagerIdle::Task::Task(
     uint64 transfer_id, const base::Closure& task)
     : transfer_id(transfer_id),
       task(task) {
@@ skipping 73 matching lines @@
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateIdle(&shared_state_,
                                             ref->service_id(),
                                             define_params);
 }
 
 }  // namespace gpu