GPU: Replace AsyncPixelTransferState with AsyncPixelTransferDelegate.

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"
@@ skipping 371 matching lines @@
   // and the client can safely use the texture. This occurs
   // during BindCompletedAsyncTransfers().
   base::Closure bind_callback_;
 
   // Customize when we block on fences (these are work-arounds).
   bool wait_for_uploads_;
   bool wait_for_creation_;
   bool use_image_preserved_;
 };
 
-// EGL needs thread-safe ref-counting, so this just wraps
-// an internal thread-safe ref-counted state object.
-class AsyncTransferStateImpl : public AsyncPixelTransferState {
- public:
-  AsyncTransferStateImpl(GLuint texture_id,
-                         const AsyncTexImage2DParams& define_params,
-                         bool wait_for_uploads,
-                         bool wait_for_creation,
-                         bool use_image_preserved)
-      : internal_(new TransferStateInternal(texture_id,
-                                            define_params,
-                                            wait_for_uploads,
-                                            wait_for_creation,
-                                            use_image_preserved)) {
-  }
-
-  virtual bool TransferIsInProgress() OVERRIDE {
-      return internal_->TransferIsInProgress();
-  }
-
-  void BindTransfer() {
-    internal_->BindTransfer();
-  }
-
-  scoped_refptr<TransferStateInternal> internal_;
-
- private:
-  virtual ~AsyncTransferStateImpl() {}
-};
-
 }  // namespace
 
 // Class which handles async pixel transfers using EGLImageKHR and another
 // upload thread
 class AsyncPixelTransferDelegateEGL
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateEGL> {
  public:
-  explicit AsyncPixelTransferDelegateEGL(
-      AsyncPixelTransferManagerEGL::SharedState* shared_state);
+  AsyncPixelTransferDelegateEGL(
+      AsyncPixelTransferManagerEGL::SharedState* shared_state,
+      GLuint texture_id,
+      const AsyncTexImage2DParams& define_params);
   virtual ~AsyncPixelTransferDelegateEGL();
 
+  void BindTransfer() { state_->BindTransfer(); }
+
   // Implement AsyncPixelTransferDelegate:
-  virtual AsyncPixelTransferState* CreatePixelTransferState(
-      GLuint texture_id,
-      const AsyncTexImage2DParams& define_params) OVERRIDE;
   virtual void AsyncTexImage2D(
-      AsyncPixelTransferState* state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params,
       const base::Closure& bind_callback) OVERRIDE;
   virtual void AsyncTexSubImage2D(
-      AsyncPixelTransferState* state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
-  virtual void WaitForTransferCompletion(
-      AsyncPixelTransferState* state) OVERRIDE;
+  virtual bool TransferIsInProgress() OVERRIDE;
+  virtual void WaitForTransferCompletion() OVERRIDE;
 
  private:
   // Returns true if a work-around was used.
   bool WorkAroundAsyncTexImage2D(
-      AsyncPixelTransferState* state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params,
       const base::Closure& bind_callback);
   bool WorkAroundAsyncTexSubImage2D(
-      AsyncPixelTransferState* state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params);
 
   // A raw pointer is safe because the SharedState is owned by the Manager,
   // which owns this Delegate.
   AsyncPixelTransferManagerEGL::SharedState* shared_state_;
+  scoped_refptr<TransferStateInternal> state_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateEGL);
 };
 
 AsyncPixelTransferDelegateEGL::AsyncPixelTransferDelegateEGL(
-    AsyncPixelTransferManagerEGL::SharedState* shared_state)
+    AsyncPixelTransferManagerEGL::SharedState* shared_state,
+    GLuint texture_id,
+    const AsyncTexImage2DParams& define_params)
     : shared_state_(shared_state) {
-}
-
-AsyncPixelTransferDelegateEGL::~AsyncPixelTransferDelegateEGL() {}
-
-AsyncPixelTransferState* AsyncPixelTransferDelegateEGL::
-    CreatePixelTransferState(GLuint texture_id,
-                             const AsyncTexImage2DParams& define_params) {
   // We can't wait on uploads on imagination (it can take 200ms+).
   // In practice, they are complete when the CPU glTexSubImage2D completes.
   bool wait_for_uploads = !shared_state_->is_imagination;
 
   // Qualcomm runs into texture corruption problems if the same texture is
   // uploaded to with both async and normal uploads. Synchronize after EGLImage
   // creation on the main thread as a work-around.
   bool wait_for_creation = shared_state_->is_qualcomm;
 
   // 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 =
       shared_state_->is_qualcomm || shared_state_->is_imagination;
 
-  return new AsyncTransferStateImpl(texture_id,
-                                    define_params,
-                                    wait_for_uploads,
-                                    wait_for_creation,
-                                    use_image_preserved);
+  state_ = new TransferStateInternal(texture_id,
+                                   define_params,
+                                   wait_for_uploads,
+                                   wait_for_creation,
+                                   use_image_preserved);
 }
 
-void AsyncPixelTransferDelegateEGL::WaitForTransferCompletion(
-      AsyncPixelTransferState* transfer_state) {
-  scoped_refptr<TransferStateInternal> state =
-      static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
-  DCHECK(state.get());
-  DCHECK(state->texture_id_);
+AsyncPixelTransferDelegateEGL::~AsyncPixelTransferDelegateEGL() {}
 
-  if (state->TransferIsInProgress()) {
+bool AsyncPixelTransferDelegateEGL::TransferIsInProgress() {
+  return state_->TransferIsInProgress();
+}
+
+void AsyncPixelTransferDelegateEGL::WaitForTransferCompletion() {
+  if (state_->TransferIsInProgress()) {
 #if defined(OS_ANDROID) || defined(OS_LINUX)
     g_transfer_thread.Pointer()->SetPriority(base::kThreadPriority_Display);
 #endif
 
-    state->WaitForTransferCompletion();
-    DCHECK(!state->TransferIsInProgress());
+    state_->WaitForTransferCompletion();
+    DCHECK(!state_->TransferIsInProgress());
 
 #if defined(OS_ANDROID) || defined(OS_LINUX)
     g_transfer_thread.Pointer()->SetPriority(base::kThreadPriority_Background);
 #endif
   }
 }
 
 void AsyncPixelTransferDelegateEGL::AsyncTexImage2D(
-    AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
-  if (WorkAroundAsyncTexImage2D(transfer_state, tex_params,
-                                mem_params, bind_callback))
+  if (WorkAroundAsyncTexImage2D(tex_params, mem_params, bind_callback))
     return;
 
-  scoped_refptr<TransferStateInternal> state =
-      static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
-  DCHECK(state.get());
-  DCHECK(state->texture_id_);
-  DCHECK(!state->TransferIsInProgress());
-  DCHECK_EQ(state->egl_image_, EGL_NO_IMAGE_KHR);
+  DCHECK(!state_->TransferIsInProgress());
+  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(transfer_state->AsWeakPtr());
-  state->bind_callback_ = bind_callback;
+  shared_state_->pending_allocations.push_back(AsWeakPtr());
+  state_->bind_callback_ = bind_callback;
 
   // Mark the transfer in progress.
-  state->MarkAsTransferIsInProgress();
+  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,
+          state_,
           tex_params,
           mem_params,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size))));
 
 
   DCHECK(CHECK_GL());
 }
 
 void AsyncPixelTransferDelegateEGL::AsyncTexSubImage2D(
-    AsyncPixelTransferState* transfer_state,
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   TRACE_EVENT2("gpu", "AsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
-  if (WorkAroundAsyncTexSubImage2D(transfer_state, tex_params, mem_params))
+  if (WorkAroundAsyncTexSubImage2D(tex_params, mem_params))
     return;
-  scoped_refptr<TransferStateInternal> state =
-      static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
-
-  DCHECK(state->texture_id_);
-  DCHECK(!state->TransferIsInProgress());
+  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.
-  state->MarkAsTransferIsInProgress();
+  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();
+  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,
+          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));
 
   DCHECK(CHECK_GL());
 }
 
 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) {
   // Multiple of eight, but not a power of two.
   return IsMultipleOfEight(width) &&
          IsMultipleOfEight(height) &&
          !(IsPowerOfTwo(width) &&
            IsPowerOfTwo(height));
 }
-} // namespace
+}  // namespace
 
 // It is very difficult to stream uploads on Imagination GPUs:
 // - glTexImage2D defers a swizzle/stall until draw-time
 // - glTexSubImage2D will sleep for 16ms on a good day, and 100ms
 //   or longer if OpenGL is in heavy use by another thread.
 // The one combination that avoids these problems requires:
 // a.) Allocations/Uploads must occur on different threads/contexts.
 // b.) Texture size must be non-power-of-two.
 // When using a+b, uploads will be incorrect/corrupt unless:
 // c.) Texture size must be a multiple-of-eight.
 //
 // To achieve a.) we allocate synchronously on the main thread followed
 // by uploading on the upload thread. When b/c are not true we fall back
 // on purely synchronous allocation/upload on the main thread.
 
 bool AsyncPixelTransferDelegateEGL::WorkAroundAsyncTexImage2D(
-    AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
   if (!shared_state_->is_imagination)
     return false;
-  scoped_refptr<TransferStateInternal> state =
-      static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
 
   // On imagination we allocate synchronously all the time, even
   // if the dimensions support fast uploads. This is for part a.)
   // above, so allocations occur on a different thread/context as uploads.
   void* data = GetAddress(mem_params);
   SetGlParametersForEglImageTexture();
 
   {
     TRACE_EVENT0("gpu", "glTexImage2D with data");
     DoTexImage2D(tex_params, data);
   }
 
   // The allocation has already occured, so mark it as finished
   // and ready for binding.
-  CHECK(!state->TransferIsInProgress());
+  CHECK(!state_->TransferIsInProgress());
 
   // If the dimensions support fast async uploads, create the
   // EGLImage for future uploads. The late bind should not
   // be needed since the EGLImage was created from the main thread
   // texture, but this is required to prevent an imagination driver crash.
   if (DimensionsSupportImgFastPath(tex_params.width, tex_params.height)) {
-    state->CreateEglImageOnMainThreadIfNeeded();
-    shared_state_->pending_allocations.push_back(transfer_state->AsWeakPtr());
-    state->bind_callback_ = bind_callback;
+    state_->CreateEglImageOnMainThreadIfNeeded();
+    shared_state_->pending_allocations.push_back(AsWeakPtr());
+    state_->bind_callback_ = bind_callback;
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 bool AsyncPixelTransferDelegateEGL::WorkAroundAsyncTexSubImage2D(
-    AsyncPixelTransferState* transfer_state,
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   if (!shared_state_->is_imagination)
     return false;
 
   // If the dimensions support fast async uploads, we can use the
   // normal async upload path for uploads.
   if (DimensionsSupportImgFastPath(tex_params.width, tex_params.height))
     return false;
 
-  scoped_refptr<TransferStateInternal> state =
-      static_cast<AsyncTransferStateImpl*>(transfer_state)->internal_.get();
-
   // Fall back on a synchronous stub as we don't have a known fast path.
   // Also, older ICS drivers crash when we do any glTexSubImage2D on the
   // same thread. To work around this we do glTexImage2D instead. Since
   // we didn't create an EGLImage for this texture (see above), this is
   // okay, but it limits this API to full updates for now.
-  DCHECK(!state->egl_image_);
+  DCHECK(!state_->egl_image_);
   DCHECK_EQ(tex_params.xoffset, 0);
   DCHECK_EQ(tex_params.yoffset, 0);
-  DCHECK_EQ(state->define_params_.width, tex_params.width);
-  DCHECK_EQ(state->define_params_.height, tex_params.height);
-  DCHECK_EQ(state->define_params_.level, tex_params.level);
-  DCHECK_EQ(state->define_params_.format, tex_params.format);
-  DCHECK_EQ(state->define_params_.type, tex_params.type);
+  DCHECK_EQ(state_->define_params_.width, tex_params.width);
+  DCHECK_EQ(state_->define_params_.height, tex_params.height);
+  DCHECK_EQ(state_->define_params_.level, tex_params.level);
+  DCHECK_EQ(state_->define_params_.format, tex_params.format);
+  DCHECK_EQ(state_->define_params_.type, tex_params.type);
 
   void* data = GetAddress(mem_params);
   base::TimeTicks begin_time;
   if (shared_state_->texture_upload_stats.get())
     begin_time = base::TimeTicks::HighResNow();
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
     // Note we use define_params_ instead of tex_params.
     // The DCHECKs above verify this is always the same.
-    DoTexImage2D(state->define_params_, data);
+    DoTexImage2D(state_->define_params_, data);
   }
   if (shared_state_->texture_upload_stats.get()) {
     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) {
   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()
-    : delegate_(new AsyncPixelTransferDelegateEGL(&shared_state_)) {}
+AsyncPixelTransferManagerEGL::AsyncPixelTransferManagerEGL() {}
 
 AsyncPixelTransferManagerEGL::~AsyncPixelTransferManagerEGL() {}
 
 void AsyncPixelTransferManagerEGL::BindCompletedAsyncTransfers() {
   scoped_ptr<gfx::ScopedTextureBinder> texture_binder;
 
   while(!shared_state_.pending_allocations.empty()) {
     if (!shared_state_.pending_allocations.front().get()) {
       shared_state_.pending_allocations.pop_front();
       continue;
     }
-    scoped_refptr<TransferStateInternal> state =
-        static_cast<AsyncTransferStateImpl*>
-            (shared_state_.pending_allocations.front().get())->internal_.get();
+    AsyncPixelTransferDelegateEGL* delegate =
+        shared_state_.pending_allocations.front().get();
     // Terminate early, as all transfers finish in order, currently.
-    if (state->TransferIsInProgress())
+    if (delegate->TransferIsInProgress())
       break;
 
     if (!texture_binder)
       texture_binder.reset(new gfx::ScopedTextureBinder(GL_TEXTURE_2D, 0));
 
     // If the transfer is finished, bind it to the texture
     // and remove it from pending list.
-    state->BindTransfer();
+    delegate->BindTransfer();
     shared_state_.pending_allocations.pop_front();
   }
 }
 
 void AsyncPixelTransferManagerEGL::AsyncNotifyCompletion(
     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);
@@ skipping 21 matching lines @@
 }
 
 void AsyncPixelTransferManagerEGL::ProcessMorePendingTransfers() {
 }
 
 bool AsyncPixelTransferManagerEGL::NeedsProcessMorePendingTransfers() {
   return false;
 }
 
 AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerEGL::GetAsyncPixelTransferDelegate() {
-  return delegate_.get();
+AsyncPixelTransferManagerEGL::CreatePixelTransferDelegateImpl(
+    gles2::TextureRef* ref,
+    const AsyncTexImage2DParams& define_params) {
+  return new AsyncPixelTransferDelegateEGL(
+      &shared_state_, ref->service_id(), define_params);
 }
 
 }  // namespace gpu