gpu: Add CopyTexImage function to GLImage API.

ui/gl/gl_image_memory.cc

Index: ui/gl/gl_image_memory.cc
diff --git a/ui/gl/gl_image_memory.cc b/ui/gl/gl_image_memory.cc
index dfd3d2cb95c3b55df7c515411551d08f3fb4c72f..64bbc399e0b276725cf00665d2590e0ae0f97684 100644
--- a/ui/gl/gl_image_memory.cc
+++ b/ui/gl/gl_image_memory.cc
@@ -70,7 +70,10 @@ int BytesPerPixel(unsigned internalformat) {
 GLImageMemory::GLImageMemory(const gfx::Size& size, unsigned internalformat)
     : memory_(NULL),
       size_(size),
-      internalformat_(internalformat)
+      internalformat_(internalformat),
+      in_use_(false),
+      target_(0),
+      need_do_bind_tex_image_(false)
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
       ,
@@ -122,7 +125,87 @@ gfx::Size GLImageMemory::GetSize() {
 }
 
 bool GLImageMemory::BindTexImage(unsigned target) {
-  TRACE_EVENT0("gpu", "GLImageMemory::BindTexImage");
+  DCHECK(!target_);

[piman, 2014/09/04 19:11:10]

I don't think we (currently) raise an error if the client binds the image to 2
textures. Should we return false instead if target_ is set?
Do we need consistency between the image types?

[reveman, 2014/09/04 20:12:44]

Ah, right. We should probably add some unit tests for binding the image to
multiple textures if we want to keep supporting that. I'll do that in a separate
patch.

I made this return false if the target is different. Similar to EGL version.
That means binding of image to multiple textures is limited to the same target
for this implementation. Maybe we can improve that if necessary by changing the
Will/DidUseTexImage API.

+  target_ = target;
+
+  // Defer DoBindTexImage if not currently in use.
+  if (!in_use_) {
+    need_do_bind_tex_image_ = true;
+    return true;
+  }
+
+  DoBindTexImage(target);
+  return true;
+}
+
+void GLImageMemory::ReleaseTexImage(unsigned target) {
+  DCHECK_EQ(target_, target);
+  target_ = 0;
+}
+
+bool GLImageMemory::CopyTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageMemory::CopyTexImage");
+
+  // GL_TEXTURE_EXTERNAL_OES is not a supported CopyTexImage target.
+  if (target == GL_TEXTURE_EXTERNAL_OES)
+    return false;
+
+  // The caller can handle this copy more efficiently using general GPU-to-GPU
+  // code if image is bound to a texture and data has been uploaded to it.
+  if (target_ && !need_do_bind_tex_image_)
+    return false;

[reveman, 2014/09/04 20:12:44]

I prefer to remove this as there's not really a way we can know from here that
the caller is interested in copying the data from a texture that this image is
currently bound to. We can revisit this later if it becomes a use case we need
to support efficiently. For now we assume that the client is not interested in
using the image both for sampling and and copying out of.

+
+  DCHECK(memory_);
+  glTexImage2D(target,
+               0,  // mip level
+               TextureFormat(internalformat_),
+               size_.width(),
+               size_.height(),
+               0,  // border
+               DataFormat(internalformat_),
+               DataType(internalformat_),
+               memory_);
+
+  return true;
+}
+
+void GLImageMemory::WillUseTexImage() {
+  DCHECK(!in_use_);
+  in_use_ = true;
+
+  if (!need_do_bind_tex_image_)
+    return;
+
+  DCHECK(target_);
+  DoBindTexImage(target_);
+}
+
+void GLImageMemory::DidUseTexImage() {
+  DCHECK(in_use_);
+  in_use_ = false;
+}
+
+bool GLImageMemory::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                                         int z_order,
+                                         OverlayTransform transform,
+                                         const Rect& bounds_rect,
+                                         const RectF& crop_rect) {
+  return false;
+}
+
+bool GLImageMemory::HasValidFormat() const {
+  return ValidFormat(internalformat_);
+}
+
+size_t GLImageMemory::Bytes() const {
+  return size_.GetArea() * BytesPerPixel(internalformat_);
+}
+
+void GLImageMemory::DoBindTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageMemory::DoBindTexImage");
+
+  DCHECK(need_do_bind_tex_image_);
+  need_do_bind_tex_image_ = false;
 
   DCHECK(memory_);
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
@@ -176,8 +259,7 @@ bool GLImageMemory::BindTexImage(unsigned target) {
 
     glEGLImageTargetTexture2DOES(target, egl_image_);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
-
-    return true;
+    return;
   }
 #endif
 
@@ -191,24 +273,6 @@ bool GLImageMemory::BindTexImage(unsigned target) {
                DataFormat(internalformat_),
                DataType(internalformat_),
                memory_);
-
-  return true;
-}
-
-bool GLImageMemory::HasValidFormat() const {
-  return ValidFormat(internalformat_);
-}
-
-size_t GLImageMemory::Bytes() const {
-  return size_.GetArea() * BytesPerPixel(internalformat_);
-}
-
-bool GLImageMemory::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                         int z_order,
-                                         OverlayTransform transform,
-                                         const Rect& bounds_rect,
-                                         const RectF& crop_rect) {
-  return false;
 }
 
 }  // namespace gfx