Add synthetic delay points for latency testing

gpu/command_buffer/service/async_pixel_transfer_manager_egl.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_egl.h"
 
 #include <list>
 #include <string>
 
 #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/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
 #include "gpu/command_buffer/service/safe_shared_memory_pool.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 208 matching lines @@
     if (wait_for_uploads_) {
       TRACE_EVENT0("gpu", "glFinish");
       glFinish();
     }
   }
 
   void MarkAsTransferIsInProgress() {
     transfer_completion_.Reset();
   }
 
-  void MarkAsCompleted() {
+  void MarkAsCompleted(base::AtomicRefCount* pending_uploads) {
+    if (!base::AtomicRefCountDec(pending_uploads))
+      TRACE_EVENT_SYNTHETIC_DELAY_APPLY("gpu.AsyncTexImage");
     transfer_completion_.Signal();
   }
 
   void WaitForTransferCompletion() {
     TRACE_EVENT0("gpu", "WaitForTransferCompletion");
     // TODO(backer): Deschedule the channel rather than blocking the main GPU
     // thread (crbug.com/240265).
     transfer_completion_.Wait();
   }
 
   void PerformAsyncTexImage2D(
       AsyncTexImage2DParams tex_params,
       AsyncMemoryParams mem_params,
       ScopedSafeSharedMemory* safe_shared_memory,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
+      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats,
+      base::AtomicRefCount* pending_uploads) {
     TRACE_EVENT2("gpu",
                  "PerformAsyncTexImage",
                  "width",
                  tex_params.width,
                  "height",
                  tex_params.height);
+    TRACE_EVENT_SYNTHETIC_DELAY_ACTIVATE("gpu.AsyncTexImage");
     DCHECK(!thread_texture_id_);
     DCHECK_EQ(0, tex_params.level);
     if (EGL_NO_IMAGE_KHR != egl_image_) {
-      MarkAsCompleted();
+      MarkAsCompleted(pending_uploads);
       return;
     }
 
     void* data =
         AsyncPixelTransferDelegate::GetAddress(safe_shared_memory, mem_params);
 
     base::TimeTicks begin_time;
     if (texture_upload_stats.get())
       begin_time = base::TimeTicks::HighResNow();
 
@@ skipping 19 matching lines @@
     {
       TRACE_EVENT0("gpu", "glTexSubImage2D with data");
 
       // If we didn't use image_preserved, we haven't uploaded
       // the data yet, so we do this with a full texSubImage.
       if (!use_image_preserved_)
         DoFullTexSubImage2D(tex_params, data);
     }
 
     WaitForLastUpload();
-    MarkAsCompleted();
+    MarkAsCompleted(pending_uploads);
 
     DCHECK(CHECK_GL());
     if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
   void PerformAsyncTexSubImage2D(
       AsyncTexSubImage2DParams tex_params,
       AsyncMemoryParams mem_params,
       ScopedSafeSharedMemory* safe_shared_memory,
-      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
+      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats,
+      base::AtomicRefCount* pending_uploads ) {
     TRACE_EVENT2("gpu",
                  "PerformAsyncTexSubImage2D",
                  "width",
                  tex_params.width,
                  "height",
                  tex_params.height);
+    TRACE_EVENT_SYNTHETIC_DELAY_ACTIVATE("gpu.AsyncTexImage");
 
     DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
     DCHECK_EQ(0, tex_params.level);
 
     void* data =
         AsyncPixelTransferDelegate::GetAddress(safe_shared_memory, mem_params);
 
     base::TimeTicks begin_time;
     if (texture_upload_stats.get())
       begin_time = base::TimeTicks::HighResNow();
 
     if (!thread_texture_id_) {
       TRACE_EVENT0("gpu", "glEGLImageTargetTexture2DOES");
       glGenTextures(1, &thread_texture_id_);
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
       glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image_);
     } else {
       glActiveTexture(GL_TEXTURE0);
       glBindTexture(GL_TEXTURE_2D, thread_texture_id_);
     }
     {
       TRACE_EVENT0("gpu", "glTexSubImage2D");
       DoTexSubImage2D(tex_params, data);
     }
     WaitForLastUpload();
-    MarkAsCompleted();
+    MarkAsCompleted(pending_uploads);
 
     DCHECK(CHECK_GL());
     if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
  protected:
   friend class base::RefCountedThreadSafe<TransferStateInternal>;
@@ skipping 151 matching lines @@
   DCHECK_EQ(state_->egl_image_, EGL_NO_IMAGE_KHR);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK_EQ(tex_params.level, 0);
 
   // Mark the transfer in progress and save the late bind
   // callback, so we can notify the client when it is bound.
   shared_state_->pending_allocations.push_back(AsWeakPtr());
   state_->bind_callback_ = bind_callback;
 
   // Mark the transfer in progress.
+  base::AtomicRefCountInc(&shared_state_->pending_uploads);
   state_->MarkAsTransferIsInProgress();
 
   // Duplicate the shared memory so there is no way we can get
   // a use-after-free of the raw pixels.
   transfer_message_loop_proxy()->PostTask(FROM_HERE,
       base::Bind(
           &TransferStateInternal::PerformAsyncTexImage2D,
           state_,
           tex_params,
           mem_params,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)),
-          shared_state_->texture_upload_stats));
+          shared_state_->texture_upload_stats,
+          &shared_state_->pending_uploads));
 
   DCHECK(CHECK_GL());
 }
 
 void AsyncPixelTransferDelegateEGL::AsyncTexSubImage2D(
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   TRACE_EVENT2("gpu", "AsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
   if (WorkAroundAsyncTexSubImage2D(tex_params, mem_params))
     return;
   DCHECK(!state_->TransferIsInProgress());
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK_EQ(tex_params.level, 0);
 
   // Mark the transfer in progress.
+  base::AtomicRefCountInc(&shared_state_->pending_uploads);
   state_->MarkAsTransferIsInProgress();
 
   // If this wasn't async allocated, we don't have an EGLImage yet.
   // Create the EGLImage if it hasn't already been created.
   state_->CreateEglImageOnMainThreadIfNeeded();
 
   // Duplicate the shared memory so there are no way we can get
   // a use-after-free of the raw pixels.
   transfer_message_loop_proxy()->PostTask(FROM_HERE,
       base::Bind(
           &TransferStateInternal::PerformAsyncTexSubImage2D,
           state_,
           tex_params,
           mem_params,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)),
-          shared_state_->texture_upload_stats));
+          shared_state_->texture_upload_stats,
+          &shared_state_->pending_uploads));
 
   DCHECK(CHECK_GL());
 }
 
 namespace {
 bool IsPowerOfTwo (unsigned int x) {
   return ((x != 0) && !(x & (x - 1)));
 }
 
 bool IsMultipleOfEight(unsigned int x) {
@@ skipping 98 matching lines @@
     shared_state_->texture_upload_stats
         ->AddUpload(base::TimeTicks::HighResNow() - begin_time);
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 AsyncPixelTransferManagerEGL::SharedState::SharedState()
     // TODO(reveman): Skip this if --enable-gpu-benchmarking is not present.
-    : texture_upload_stats(new AsyncPixelTransferUploadStats) {
+    : texture_upload_stats(new AsyncPixelTransferUploadStats),
+      pending_uploads(0) {
   std::string vendor;
   vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
   is_imagination = vendor.find("Imagination") != std::string::npos;
   is_qualcomm = vendor.find("Qualcomm") != std::string::npos;
 }
 
 AsyncPixelTransferManagerEGL::SharedState::~SharedState() {}
 
 AsyncPixelTransferManagerEGL::AsyncPixelTransferManagerEGL() {}
 
@@ skipping 61 matching lines @@
 
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerEGL::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateEGL(
       &shared_state_, ref->service_id(), define_params);
 }
 
 }  // namespace gpu