Avoid EGLImage target texture reuse on PowerVR

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/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 14 matching lines @@
 }
 
 }  // namespace
 
 // Class which handles async pixel transfers in a platform
 // independent way.
 class AsyncPixelTransferDelegateIdle
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateIdle> {
  public:
+  typedef base::Callback<GLuint()> TextureIdCallback;
   AsyncPixelTransferDelegateIdle(
       AsyncPixelTransferManagerIdle::SharedState* state,
-      GLuint texture_id,
+      const TextureIdCallback& texture_id_callback,
       const AsyncTexImage2DParams& define_params);
   ~AsyncPixelTransferDelegateIdle() override;
 
   // Implement AsyncPixelTransferDelegate:
   void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
                        const AsyncMemoryParams& mem_params,
                        const base::Closure& bind_callback) override;
   void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
                           const AsyncMemoryParams& mem_params) override;
   bool TransferIsInProgress() override;
   void WaitForTransferCompletion() override;
 
  private:
   void PerformAsyncTexImage2D(AsyncTexImage2DParams tex_params,
                               AsyncMemoryParams mem_params,
                               const base::Closure& bind_callback);
   void PerformAsyncTexSubImage2D(AsyncTexSubImage2DParams tex_params,
                                  AsyncMemoryParams mem_params);
 
   uint64 id_;
-  GLuint texture_id_;
+  TextureIdCallback texture_id_callback_;
   bool transfer_in_progress_;
   AsyncTexImage2DParams define_params_;
 
   // Safe to hold a raw pointer because SharedState is owned by the Manager
   // which owns the Delegate.
   AsyncPixelTransferManagerIdle::SharedState* shared_state_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateIdle);
 };
 
 AsyncPixelTransferDelegateIdle::AsyncPixelTransferDelegateIdle(
     AsyncPixelTransferManagerIdle::SharedState* shared_state,
-    GLuint texture_id,
+    const TextureIdCallback& texture_id_callback,
     const AsyncTexImage2DParams& define_params)
     : id_(g_next_pixel_transfer_state_id++),
-      texture_id_(texture_id),
+      texture_id_callback_(texture_id_callback),
       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) {
@@ skipping 53 matching lines @@
     AsyncTexImage2DParams tex_params,
     AsyncMemoryParams mem_params,
     const base::Closure& bind_callback) {
   TRACE_EVENT2("gpu", "PerformAsyncTexImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
 
   void* data = mem_params.GetDataAddress();
 
   base::TimeTicks begin_time(base::TimeTicks::Now());
-  gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id_);
+  gfx::ScopedTextureBinder texture_binder(tex_params.target,
+                                          texture_id_callback_.Run());
 
   {
     TRACE_EVENT0("gpu", "glTexImage2D");
     glTexImage2D(
         tex_params.target,
         tex_params.level,
         tex_params.internal_format,
         tex_params.width,
         tex_params.height,
         tex_params.border,
@@ skipping 15 matching lines @@
 void AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D(
     AsyncTexSubImage2DParams tex_params,
     AsyncMemoryParams mem_params) {
   TRACE_EVENT2("gpu", "PerformAsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
 
   void* data = mem_params.GetDataAddress();
 
   base::TimeTicks begin_time(base::TimeTicks::Now());
-  gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id_);
+  gfx::ScopedTextureBinder texture_binder(tex_params.target,
+                                          texture_id_callback_.Run());
 
   if (shared_state_->use_teximage2d_over_texsubimage2d &&
       tex_params.xoffset == 0 &&
       tex_params.yoffset == 0 &&
       tex_params.target == define_params_.target &&
       tex_params.level  == define_params_.level &&
       tex_params.width  == define_params_.width &&
       tex_params.height == define_params_.height) {
     TRACE_EVENT0("gpu", "glTexImage2D");
     glTexImage2D(
@@ skipping 115 matching lines @@
 
   const Task& task = shared_state_.tasks.back();
   if (task.delegate)
     task.delegate->WaitForTransferCompletion();
 }
 
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferDelegateIdle(&shared_state_,
-                                            ref->service_id(),
-                                            define_params);
+  return new AsyncPixelTransferDelegateIdle(
+      &shared_state_,
+      // Not directly passing texture_ref->service_id here because it can change
+      // if avoid_egl_image_target_texture_reuse workaround is in effect.
+      // Unretained is safe because AsyncPixelTransferManager observes
+      // TextureRef destruction and destroys the delegate before TextureRef
+      // is destroyed.
+      base::Bind(&gles2::TextureRef::service_id, base::Unretained(ref)),
+      define_params);
 }
 
 }  // namespace gpu