Avoid EGLImage target texture reuse on PowerVR

gpu/command_buffer/service/texture_definition.cc

 // Copyright 2014 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/texture_definition.h"
 
 #include <list>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 225 matching lines @@
  private:
   ~NativeImageBufferStub() override {}
   void AddClient(gfx::GLImage* client) override {}
   void RemoveClient(gfx::GLImage* client) override {}
   bool IsClient(gfx::GLImage* client) override { return true; }
   void BindToTexture(GLenum target) override {}
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferStub);
 };
 
+bool g_avoid_egl_target_texture_reuse = false;
+
 }  // anonymous namespace
 
 // static
 scoped_refptr<NativeImageBuffer> NativeImageBuffer::Create(GLuint texture_id) {
   switch (gfx::GetGLImplementation()) {
 #if !defined(OS_MACOSX)
     case gfx::kGLImplementationEGLGLES2:
       return NativeImageBufferEGL::Create(texture_id);
 #endif
     case gfx::kGLImplementationMockGL:
       return new NativeImageBufferStub;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
+// static
+void TextureDefinition::AvoidEGLTargetTextureReuse() {
+  g_avoid_egl_target_texture_reuse = true;
+}
+
 TextureDefinition::LevelInfo::LevelInfo()
     : target(0),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
       type(0),
       cleared(false) {
@@ skipping 67 matching lines @@
 }
 
 TextureDefinition::~TextureDefinition() {
 }
 
 Texture* TextureDefinition::CreateTexture() const {
   GLuint texture_id;
   glGenTextures(1, &texture_id);
 
   Texture* texture(new Texture(texture_id));
-  UpdateTexture(texture);
+  UpdateTextureInternal(texture);
 
   return texture;
 }
 
-void TextureDefinition::UpdateTexture(Texture* texture) const {
+void TextureDefinition::UpdateTextureInternal(Texture* texture) const {
   gfx::ScopedTextureBinder texture_binder(target_, texture->service_id());
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t_);
   if (image_buffer_.get())
     image_buffer_->BindToTexture(target_);
   // We have to make sure the changes are visible to other clients in this share
   // group. As far as the clients are concerned, the mailbox semantics only
   // demand a single flush from the client after changes are first made,
@@ skipping 24 matching lines @@
 
   texture->target_ = target_;
   texture->SetImmutable(immutable_);
   texture->min_filter_ = min_filter_;
   texture->mag_filter_ = mag_filter_;
   texture->wrap_s_ = wrap_s_;
   texture->wrap_t_ = wrap_t_;
   texture->usage_ = usage_;
 }
 
+void TextureDefinition::UpdateTexture(Texture* texture) const {
+  GLuint old_service_id = 0u;
+  if (image_buffer_.get() && g_avoid_egl_target_texture_reuse) {
+    GLuint service_id = 0u;
+    glGenTextures(1, &service_id);
+    old_service_id = texture->service_id();
+    texture->SetServiceId(service_id);
+  }
+

[no sievers, 2015/04/29 17:21:30]

Sorry I missed this though we talked about it - but we have to fix it:
Need to handle the case where old_service_id is currently bound. I think it's
simple, we just bind the new texture if that is the case.

I'm also not fully sure about what if the texture is bound to an FBO.
On the one hand it's the same buffer (egl image), so in that regard it doesn't
really matter. But maybe I'm missing something that can go wrong, because the
old and not the new texture really remains the attachment.

[boliu, 2015/04/29 18:22:36]

SG, I'll make the patch.
So... do nothing for now?

+  UpdateTextureInternal(texture);
+
+  if (old_service_id) {
+    glDeleteTextures(1, &old_service_id);
+  }
+}
+
 bool TextureDefinition::Matches(const Texture* texture) const {
   DCHECK(target_ == texture->target());
   if (texture->min_filter_ != min_filter_ ||
       texture->mag_filter_ != mag_filter_ ||
       texture->wrap_s_ != wrap_s_ ||
       texture->wrap_t_ != wrap_t_ ||
       texture->SafeToRenderFrom() != SafeToRenderFrom()) {
     return false;
   }
 
   // Texture became defined.
   if (!image_buffer_.get() && texture->IsDefined())
     return false;
 
   // All structural changes should have orphaned the texture.
   if (image_buffer_.get() && !texture->GetLevelImage(texture->target(), 0))
     return false;
 
   return true;
 }
 
 bool TextureDefinition::SafeToRenderFrom() const {
   return level_info_.cleared;
 }
 
 }  // namespace gles2
 }  // namespace gpu