Add synthetic delay points for latency testing

gpu/command_buffer/service/async_pixel_transfer_manager_share_group.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_share_group.h"
 
 #include <list>
 
 #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/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
@@ skipping 223 matching lines @@
     if (pending_upload_task_.get())
       pending_upload_task_->Cancel();
     pending_upload_task_ = NULL;
   }
 
   void ScheduleAsyncTexImage2D(
       const AsyncTexImage2DParams tex_params,
       const AsyncMemoryParams mem_params,
       scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats,
       const base::Closure& bind_callback) {
+    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
     pending_upload_task_ = new PendingTask(base::Bind(
         &TransferStateInternal::PerformAsyncTexImage2D,
         this,
         tex_params,
         mem_params,
         // Duplicate the shared memory so there is no way we can get
         // a use-after-free of the raw pixels.
         base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                mem_params.shared_memory,
                                                mem_params.shm_size)),
         texture_upload_stats));
     transfer_message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
             &PendingTask::BindAndRun, pending_upload_task_, texture_id_));
 
     // Save the late bind callback, so we can notify the client when it is
     // bound.
     bind_callback_ = bind_callback;
   }
 
   void ScheduleAsyncTexSubImage2D(
       AsyncTexSubImage2DParams tex_params,
       AsyncMemoryParams mem_params,
       scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
+    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
     pending_upload_task_ = new PendingTask(base::Bind(
         &TransferStateInternal::PerformAsyncTexSubImage2D,
         this,
         tex_params,
         mem_params,
         base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                mem_params.shared_memory,
                                                mem_params.shm_size)),
         texture_upload_stats));
     transfer_message_loop_proxy()->PostTask(
@@ skipping 32 matching lines @@
       TRACE_EVENT0("gpu", "glTexImage2D");
       glTexImage2D(GL_TEXTURE_2D,
                    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");
     }
 
     if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
   void PerformAsyncTexSubImage2D(
       AsyncTexSubImage2DParams tex_params,
@@ skipping 19 matching lines @@
       TRACE_EVENT0("gpu", "glTexSubImage2D");
       glTexSubImage2D(GL_TEXTURE_2D,
                       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");
     }
 
     if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
   scoped_refptr<PendingTask> pending_upload_task_;
 
@@ skipping 190 matching lines @@
 
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerShareGroup::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateShareGroup(
       &shared_state_, ref->service_id(), define_params);
 }
 
 }  // namespace gpu