Re-land: Mark async texture uploads as completed from the upload thread.

ui/gl/async_pixel_transfer_delegate_android.cc

 // Copyright (c) 2012 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 "ui/gl/async_pixel_transfer_delegate_android.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 130 matching lines @@
 SafeSharedMemoryPool* safe_shared_memory_pool() {
   return g_transfer_thread.Pointer()->safe_shared_memory_pool();
 }
 
 
 } // namespace
 
 // Class which holds async pixel transfers state (EGLImage).
 // The EGLImage is accessed by either thread, but everything
 // else accessed only on the main thread.
-class TransferStateInternal
-    : public base::RefCountedThreadSafe<TransferStateInternal> {
+class TransferStateInternal : public base::RefCounted<TransferStateInternal> {
  public:
   explicit TransferStateInternal(GLuint texture_id,
                                  bool wait_for_uploads,
                                  bool use_image_preserved)
       : texture_id_(texture_id),
         thread_texture_id_(0),
         needs_late_bind_(false),
         transfer_in_progress_(false),
         egl_image_(EGL_NO_IMAGE_KHR),
         wait_for_uploads_(wait_for_uploads),
@@ skipping 69 matching lines @@
     // GPU action that needs to occur. We could use fences and try
     // to do this less often. However, on older drivers fences are
     // not always reliable (eg. Mali-400 just blocks forever).
     if (wait_for_uploads_) {
       TRACE_EVENT0("gpu", "glFinish");
       glFinish();
     }
   }
 
  protected:
-  friend class base::RefCountedThreadSafe<TransferStateInternal>;
+  friend class base::RefCounted<TransferStateInternal>;
   friend class AsyncPixelTransferDelegateAndroid;
 
   static void DeleteTexture(GLuint id) {
     glDeleteTextures(1, &id);
   }
 
   virtual ~TransferStateInternal() {
     if (egl_image_ != EGL_NO_IMAGE_KHR) {
       EGLDisplay display = eglGetCurrentDisplay();
       eglDestroyImageKHR(display, egl_image_);
@@ skipping 58 matching lines @@
 // EGLImageKHR and another upload thread)
 class AsyncPixelTransferDelegateAndroid
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateAndroid> {
  public:
   AsyncPixelTransferDelegateAndroid();
   virtual ~AsyncPixelTransferDelegateAndroid();
 
   // implement AsyncPixelTransferDelegate:
   virtual void AsyncNotifyCompletion(
-      const base::Closure& task) OVERRIDE;
+      const AsyncMemoryParams& mem_params,
+      const CompletionCallback& callback) OVERRIDE;
   virtual void AsyncTexImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual void AsyncTexSubImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
 
  private:
   // implement AsyncPixelTransferDelegate:
   virtual AsyncPixelTransferState*
       CreateRawPixelTransferState(GLuint texture_id) OVERRIDE;
 
   void AsyncTexImage2DCompleted(scoped_refptr<TransferStateInternal> state);
   void AsyncTexSubImage2DCompleted(scoped_refptr<TransferStateInternal> state);
 
+  static void PerformNotifyCompletion(
+      AsyncMemoryParams mem_params,
+      ScopedSafeSharedMemory* safe_shared_memory,
+      const CompletionCallback& callback);
   static void PerformAsyncTexImage2D(
       TransferStateInternal* state,
       AsyncTexImage2DParams tex_params,
       AsyncMemoryParams mem_params,
       ScopedSafeSharedMemory* safe_shared_memory);
   static void PerformAsyncTexSubImage2D(
       TransferStateInternal* state,
       AsyncTexSubImage2DParams tex_params,
       AsyncMemoryParams mem_params,
       ScopedSafeSharedMemory* safe_shared_memory);
@@ skipping 48 matching lines @@
 }
 
 AsyncPixelTransferDelegateAndroid::~AsyncPixelTransferDelegateAndroid() {
 }
 
 AsyncPixelTransferState*
     AsyncPixelTransferDelegateAndroid::
         CreateRawPixelTransferState(GLuint texture_id) {
 
   // We can't wait on uploads on imagination (it can take 200ms+).
-  // In practice, they are complete when the CPU glSubTexImage2D completes.
+  // In practice, they are complete when the CPU glTexSubImage2D completes.
   bool wait_for_uploads = !is_imagination_;
 
   // Qualcomm has a race when using image_preserved=FALSE,
   // which can result in black textures even after the first upload.
   // Since using FALSE is mainly for performance (to avoid layout changes),
   // but Qualcomm itself doesn't seem to get any performance benefit,
   // we just using image_preservedd=TRUE on Qualcomm as a work-around.
   bool use_image_preserved = is_qualcomm_ || is_imagination_;
 
   return static_cast<AsyncPixelTransferState*>(
       new AsyncTransferStateAndroid(texture_id,
                                     wait_for_uploads,
                                     use_image_preserved));
 }
 
-namespace {
-// Dummy function to measure completion on
-// the upload thread.
-void NoOp() {}
-} // namespace
-
 void AsyncPixelTransferDelegateAndroid::AsyncNotifyCompletion(
-      const base::Closure& task) {
-  // Post a no-op task to the upload thread followed
-  // by a reply to the callback. The reply will then occur after
-  // all async transfers are complete.
-  transfer_message_loop_proxy()->PostTaskAndReply(FROM_HERE,
-      base::Bind(&NoOp), task);
+    const AsyncMemoryParams& mem_params,
+    const CompletionCallback& callback) {
+  DCHECK(mem_params.shared_memory);
+  DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
+            mem_params.shm_size);
+  // Post a PerformNotifyCompletion task to the upload thread. This task
+  // will run after all async transfers are complete.
+  transfer_message_loop_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&AsyncPixelTransferDelegateAndroid::PerformNotifyCompletion,
+                 mem_params,
+                 base::Owned(
+                     new ScopedSafeSharedMemory(safe_shared_memory_pool(),
+                                                mem_params.shared_memory,
+                                                mem_params.shm_size)),
+                 callback));
 }
 
 void AsyncPixelTransferDelegateAndroid::AsyncTexImage2D(
     AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateAndroid*>(transfer_state)->internal_.get();
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
@@ skipping 103 matching lines @@
 void SetGlParametersForEglImageTexture() {
   // These params are needed for EGLImage creation to succeed on several
   // Android devices. I couldn't find this requirement in the EGLImage
   // extension spec, but several devices fail without it.
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 }
 } // namespace
 
+void AsyncPixelTransferDelegateAndroid::PerformNotifyCompletion(
+    AsyncMemoryParams mem_params,
+    ScopedSafeSharedMemory* safe_shared_memory,
+    const CompletionCallback& callback) {
+  TRACE_EVENT0("gpu", "PerformNotifyCompletion");
+  gfx::AsyncMemoryParams safe_mem_params = mem_params;
+  safe_mem_params.shared_memory = safe_shared_memory->shared_memory();
+  callback.Run(safe_mem_params);
+}
+
 void AsyncPixelTransferDelegateAndroid::PerformAsyncTexImage2D(
     TransferStateInternal* state,
     AsyncTexImage2DParams tex_params,
     AsyncMemoryParams mem_params,
     ScopedSafeSharedMemory* safe_shared_memory) {
   TRACE_EVENT2("gpu", "PerformAsyncTexImage",
                "width", tex_params.width,
                "height", tex_params.height);
   DCHECK(state);
   DCHECK(!state->thread_texture_id_);
@@ skipping 64 matching lines @@
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
     DoTexSubImage2D(tex_params, data);
   }
   state->WaitForLastUpload();
 
   DCHECK(CHECK_GL());
   state->last_transfer_time_ = base::TimeTicks::HighResNow() - begin_time;
 }
 
-
 namespace {
 bool IsPowerOfTwo (unsigned int x) {
   return ((x != 0) && !(x & (x - 1)));
 }
 
 bool IsMultipleOfEight(unsigned int x) {
   return (x & 7) == 0;
 }
 
 bool DimensionsSupportImgFastPath(int width, int height) {
@@ skipping 93 matching lines @@
     DoTexImage2D(state->late_bind_define_params_, data);
   }
   texture_upload_count_++;
   total_texture_upload_time_ += base::TimeTicks::HighResNow() - begin_time;
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx