ui: Use single buffer SurfaceTexture mode for native GpuMemoryBuffers on Android.

ui/gl/gl_image_surface_texture.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 "ui/gl/gl_image_surface_texture.h"
 
+#include "base/strings/stringize_macros.h"
+#include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/android/surface_texture.h"
+#include "ui/gl/gl_helper.h"
+#include "ui/gl/scoped_binders.h"
 
 namespace gl {
 
 GLImageSurfaceTexture::GLImageSurfaceTexture(const gfx::Size& size)
-    : size_(size), texture_id_(0) {}
+    : size_(size) {}
 
 GLImageSurfaceTexture::~GLImageSurfaceTexture() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!surface_texture_.get());
-  DCHECK_EQ(0, texture_id_);
 }
 
 bool GLImageSurfaceTexture::Initialize(gfx::SurfaceTexture* surface_texture) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!surface_texture_.get());
   surface_texture_ = surface_texture;
   return true;
 }
 
 void GLImageSurfaceTexture::Destroy(bool have_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  surface_texture_ = NULL;
-  texture_id_ = 0;
+  if (have_context && framebuffer_) {
+    glDeleteProgram(program_);
+    glDeleteShader(vertex_shader_);
+    glDeleteShader(fragment_shader_);
+    glDeleteBuffersARB(1, &vertex_buffer_);
+    glDeleteFramebuffersEXT(1, &framebuffer_);
+  }
+  surface_texture_ = nullptr;
 }
 
 gfx::Size GLImageSurfaceTexture::GetSize() {
   return size_;
 }
 
 unsigned GLImageSurfaceTexture::GetInternalFormat() { return GL_RGBA; }
 
 bool GLImageSurfaceTexture::BindTexImage(unsigned target) {
-  TRACE_EVENT0("gpu", "GLImageSurfaceTexture::BindTexImage");
+  // Binding of surface textures directly to a target is not supported as
+  // an explicit release call is required before the buffer can be reused.
+  return false;
+}
+
+bool GLImageSurfaceTexture::CopyTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageSurfaceTexture::CopyTexImage");
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (target != GL_TEXTURE_EXTERNAL_OES) {
-    LOG(ERROR)
-        << "Surface texture can only be bound to TEXTURE_EXTERNAL_OES target";
+  if (target != GL_TEXTURE_2D) {
+    LOG(ERROR) << "CopyTexImage requires TEXTURE_2D target";
     return false;
   }
 
-  GLint texture_id;
-  glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texture_id);
-  DCHECK(texture_id);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size_.width(), size_.height(), 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
-  if (texture_id_ && texture_id_ != texture_id) {
-    LOG(ERROR) << "Surface texture can only be bound to one texture ID";
-    return false;
-  }
-
-  DCHECK(surface_texture_.get());
-  if (texture_id != texture_id_) {
-    // Note: Surface textures used as gpu memory buffers are created with an
-    // initial dummy texture id of 0. We need to call DetachFromGLContext() here
-    // to detach from the dummy texture before we can attach to a real texture
-    // id. DetachFromGLContext() will delete the texture for the current
-    // attachment point so it's important that this is never called when
-    // attached to a real texture id. Detaching from the dummy texture id should
-    // not cause any problems as the GL should silently ignore 0 when passed to
-    // glDeleteTextures.
-    DCHECK_EQ(0, texture_id_);
-    surface_texture_->DetachFromGLContext();
-
-    // This will attach the surface texture to the texture currently bound to
-    // GL_TEXTURE_EXTERNAL_OES target.
-    surface_texture_->AttachToGLContext();
-    texture_id_ = texture_id;
-  }
-
-  surface_texture_->UpdateTexImage();
-  return true;
-}
-
-bool GLImageSurfaceTexture::CopyTexImage(unsigned target) {
-  return false;
+  return CopyTexSubImage(target, gfx::Point(), gfx::Rect(size_));
 }
 
 bool GLImageSurfaceTexture::CopyTexSubImage(unsigned target,

[Daniele Castagna, 2015/11/03 19:57:34]

Why implement CopyTexSubImage that supports only full rect?
To avoid re-allocating texture storage?

[reveman, 2015/12/05 23:09:08]

This is what the compositor use for one-copy.

                                             const gfx::Point& offset,
                                             const gfx::Rect& rect) {
-  return false;
+  TRACE_EVENT0("gpu", "GLImageSurfaceTexture::CopyTexSubImage");
+
+  if (!offset.IsOrigin()) {
+    LOG(ERROR) << "Non-origin offset is not supported";
+    return false;
+  }
+
+  if (rect != gfx::Rect(size_)) {
+    LOG(ERROR) << "Sub-rectangle is not supported";
+    return false;
+  }
+
+  if (!framebuffer_) {
+    // Framebuffer.
+    glGenFramebuffersEXT(1, &framebuffer_);
+
+    // clang-format off
+    const char kVertexShader[] = STRINGIZE(
+      attribute vec2 a_position;
+      varying vec2 v_texCoord;
+      void main() {
+        gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);
+        v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;
+      }
+    );
+    const char kFragmentShader[] = STRINGIZE(
+      precision mediump float;
+      uniform samplerExternalOES a_texture;
+      varying vec2 v_texCoord;
+      void main() {
+        gl_FragColor = texture2D(a_texture, v_texCoord);
+      }
+    );
+    // clang-format on
+
+    // Shaders.
+    vertex_shader_ = gfx::GLHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
+    fragment_shader_ = gfx::GLHelper::LoadShader(
+        GL_FRAGMENT_SHADER,
+        base::StringPrintf("#extension GL_OES_EGL_image_external : require\n%s",
+                           kFragmentShader)
+            .c_str());
+    program_ = gfx::GLHelper::SetupProgram(vertex_shader_, fragment_shader_);
+    gfx::ScopedUseProgram use_program(program_);
+    int sampler_location = glGetUniformLocation(program_, "a_texture");
+    DCHECK_NE(-1, sampler_location);
+    glUniform1i(sampler_location, 0);
+
+    // Vertex buffer.
+    glGenBuffersARB(1, &vertex_buffer_);
+    gfx::ScopedBufferBinder buffer_binder(GL_ARRAY_BUFFER, vertex_buffer_);
+    GLfloat data[] = {-1.f, -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, 1.f};
+    glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, 0);

[Daniele Castagna, 2015/11/03 19:57:34]

As pointed out by piman@, this needs to be set and restored at every draw.

[reveman, 2015/12/05 23:09:08]

Fixed by rebase.

+  }
+
+  GLint target_texture = 0;
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &target_texture);
+  DCHECK(target_texture);
+
+  gfx::ScopedActiveTexture active_texture(GL_TEXTURE0);

[Daniele Castagna, 2015/11/03 19:57:34]

As mentioned by piman in the previous CL, we need to set/restore all the drawing
related state we're assuming here.
Should we add more Scoped* classes or do you have a better idea?

[reveman, 2015/12/05 23:09:08]

Latest patch should be consistent with what we do in the IOSurface case.

+  // UpdateTexImage() call below will bind the surface texture to
+  // TEXTURE_EXTERNAL_OES. This scoped texture binder will restore the current
+  // binding before this function returns.
+  gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_EXTERNAL_OES, 0);
+
+  DCHECK(surface_texture_.get());
+  surface_texture_->UpdateTexImage();
+
+  {
+    gfx::ScopedFrameBufferBinder framebuffer_binder(framebuffer_);
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, target_texture, 0);
+    DCHECK_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+              glCheckFramebufferStatusEXT(GL_FRAMEBUFFER));
+
+    gfx::ScopedViewport viewport(0, 0, size_.width(), size_.height());
+    glViewport(0, 0, size_.width(), size_.height());
+
+    gfx::ScopedUseProgram use_program(program_);
+    gfx::ScopedEnableVertexAttribArray enable_vertex_attrib_array(0);
+    gfx::ScopedBufferBinder buffer_binder(GL_ARRAY_BUFFER, vertex_buffer_);
+
+    // Draw surface texture to target texture.
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+    // Detach the output texture from the fbo.
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, 0, 0);
+  }
+
+  surface_texture_->ReleaseTexImage();
+  return true;
 }
 
 bool GLImageSurfaceTexture::ScheduleOverlayPlane(
     gfx::AcceleratedWidget widget,
     int z_order,
     gfx::OverlayTransform transform,
     const gfx::Rect& bounds_rect,
     const gfx::RectF& crop_rect) {
   return false;
 }
 
 void GLImageSurfaceTexture::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd,
     uint64_t process_tracing_id,
     const std::string& dump_name) {
   // TODO(ericrk): Add OnMemoryDump for GLImages. crbug.com/514914
 }
 
 }  // namespace gl