Add initial GpuMemoryBufferSurfaceTexture implementation.

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/debug/trace_event.h"
+#include "ui/gl/android/surface_texture.h"
+#include "ui/gl/android/surface_texture_tracker.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace gfx {
+namespace {
+
+// This is admittedly a bit ugly. SurfaceTexture API takes ownership of texture
+// ids when AttachToGLContext() is called and will delete the texture unless
+// DetachFromGLContext() is called with no context current. This helper class
+// can be used to temporarily make no context current for the purpose of
+// stealing the texture id of a given surface texture.
+class ScopedNoContextCurrent {
+ public:
+  ScopedNoContextCurrent()
+      : display_(eglGetCurrentDisplay()),
+        context_(eglGetCurrentContext()),
+        draw_surface_(eglGetCurrentSurface(EGL_DRAW)),
+        read_surface_(eglGetCurrentSurface(EGL_READ)) {
+    eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+  }
+
+  ~ScopedNoContextCurrent() {
+    eglMakeCurrent(display_, draw_surface_, read_surface_, context_);
+  }
+
+ private:
+  EGLDisplay display_;
+  EGLContext context_;
+  EGLSurface draw_surface_;
+  EGLSurface read_surface_;
+};
+
+void DetachFromGLContext(SurfaceTexture* surface_texture) {
+  // Detach with no context current to prevent SurfaceTexture from deleting
+  // currently attached texture id.
+  ScopedNoContextCurrent no_context_current;
+  surface_texture->DetachFromGLContext();
+}
+
+}  // namespace
+
+GLImageSurfaceTexture::GLImageSurfaceTexture(gfx::Size size)
+    : size_(size), texture_id_(0) {}
+
+GLImageSurfaceTexture::~GLImageSurfaceTexture() { Destroy(); }
+
+bool GLImageSurfaceTexture::Initialize(gfx::GpuMemoryBufferHandle buffer) {
+  DCHECK(!surface_texture_);
+  surface_texture_ =
+      SurfaceTextureTracker::GetInstance()->AcquireSurfaceTexture(
+          buffer.surface_texture_id.primary_id,
+          buffer.surface_texture_id.secondary_id);
+  return !!surface_texture_;
+}
+
+void GLImageSurfaceTexture::Destroy() {
+  surface_texture_ = NULL;
+  texture_id_ = 0;
+}
+
+gfx::Size GLImageSurfaceTexture::GetSize() { return size_; }
+
+bool GLImageSurfaceTexture::BindTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageSurfaceTexture::BindTexImage");
+
+  if (target != GL_TEXTURE_EXTERNAL_OES) {
+    LOG(ERROR)
+        << "Surface texture can only be bound to TEXTURE_EXTERNAL_OES target";
+    return false;
+  }
+
+  int texture_id;
+  glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texture_id);
+  DCHECK(texture_id);
+
+  if (texture_id_ && texture_id_ != texture_id) {
+    LOG(ERROR) << "Surface texture can only be bound to one texture ID";
+    return false;
+  }
+
+  DCHECK(surface_texture_);
+  if (texture_id != texture_id_) {
+    DetachFromGLContext(surface_texture_.get());

[piman, 2014/03/27 01:07:25]

Do we need this (including the "ugly hack") given the test above?
We'd only go through this code if texture_id_ is 0. Doesn't that mean we never
attached to a context?

[reveman, 2014/03/27 14:48:11]

The SurfaceTexture implementation also takes ownership of the texture passed to
the ctor. We currently pass a dummy texture id to the ctor as it's done on the
IO thread in the browser where we can't easily generate a real texture id.

This hack would be to prevent the surface texture implementation from calling
glDeleteTextures with the dummy texture id. However, looking at the spec it
seems like the GL is supposed to silently ignore 0 when passed to
glDeleteTextures so it should be safe to just call DetachFromGLContext directly
here and not do the nasty context binding trick.

Removed the hack and added some comments to better explain what's happening
here.

+    surface_texture_->AttachToGLContext();
+    texture_id_ = texture_id;
+  }
+
+  surface_texture_->UpdateTexImage();
+  return true;
+}
+
+}  // namespace gfx