Add initial GpuMemoryBufferSurfaceTexture implementation.

ui/gl/gl_image_surface_texture.cc

Index: ui/gl/gl_image_surface_texture.cc
diff --git a/ui/gl/gl_image_surface_texture.cc b/ui/gl/gl_image_surface_texture.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9aeb384f225e74a726bc62230509861410bfaf04
--- /dev/null
+++ b/ui/gl/gl_image_surface_texture.cc
@@ -0,0 +1,86 @@
+// 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) {

[epennerAtGoogle, 2014/03/12 00:45:06]

I'm not sure this works 100% the way we want, at least for the use cases we
discussed. The entire bit about 'early fencing' being caused by detach also
won't happen if there is no context current. In fact I'm not sure this can even
be called at all with no context current.

In any case, without that first bit I don't see why we need it at all yet. Is
there cases where we need to delete the GLImage but not service texture (along
with it's ID)?

[reveman, 2014/03/12 16:07:06]

Seems to be working OK but there might be some fencing issues as you mentioned.
What do you mean by the first bit?

The GLImage instance never owns the texture id. Deleting it will mess up the
service, which should be allowed to reuse it.

[epennerAtGoogle, 2014/03/12 19:46:28]

What I meant here was, 'if we don't need the fencing, do we need this at all'.
Sounds like we do, such that the service can delete the texture rather than the
GLImage doing it on behalf of it etc.

I'm a bit confused what is 'left' inside the texture this way. Perhaps it keeps
a single ST buffer(s) alive until the texture is redefined, similar to EGL. SGTM
if that's the idea.

[epennerAtGoogle, 2014/03/12 20:52:33]

Oh, one thought here would be: should we redefine the texture to free any
remaining reference to the ST data? Overall if this works it's cleaner than I
expected.

If we ever want the 'early fencing' part we'll need to revisit swapping out
service IDs, but for one-copy we just need to releaseTexImage after the FBO
blit, which doesn't have this problem.

[reveman, 2014/03/12 21:19:11]

Yes, we might want to do that in GLImage::ReleaseTexImage later but not sure it
makes a difference with current usage by the compositor. I'm trying to keep
things minimal for now.
Right.

+  // 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) {}
+
+GLImageSurfaceTexture::~GLImageSurfaceTexture() { Destroy(); }
+
+bool GLImageSurfaceTexture::Initialize(gfx::GpuMemoryBufferHandle buffer) {
+  DCHECK(!surface_texture_);
+  surface_texture_ =
+      SurfaceTextureTracker::GetInstance()->AcquireSurfaceTexture(
+          buffer.surface_texture_id);
+  return !!surface_texture_;
+}
+
+void GLImageSurfaceTexture::Destroy() {
+  if (surface_texture_)
+    DetachFromGLContext(surface_texture_.get());
+}
+
+gfx::Size GLImageSurfaceTexture::GetSize() { return size_; }
+
+bool GLImageSurfaceTexture::BindTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageSurfaceTexture::BindTexImage");
+
+  DCHECK(surface_texture_);
+  DetachFromGLContext(surface_texture_.get());
+  DCHECK_EQ(static_cast<unsigned>(GL_TEXTURE_EXTERNAL_OES), target);
+  surface_texture_->AttachToGLContext();
+  surface_texture_->UpdateTexImage();
+  return true;
+}
+
+void GLImageSurfaceTexture::ReleaseTexImage(unsigned target) {}
+
+void GLImageSurfaceTexture::WillUseTexImage() {}
+
+void GLImageSurfaceTexture::DidUseTexImage() {}
+
+}  // namespace gfx