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..34f76834e697dac00c1ea6048abf05333beef0ca 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,74 @@ gfx::Size GLImageMemory::GetSize() {
 }
 
 bool GLImageMemory::BindTexImage(unsigned target) {
-  TRACE_EVENT0("gpu", "GLImageMemory::BindTexImage");
+  target_ = target;
+
+  // Defer DoBindTexImage if not currently in use.
+  if (!in_use_) {
+    need_do_bind_tex_image_ = true;
+    return true;
+  }
+
+  DoBindTexImage(target);
+  need_do_bind_tex_image_ = false;

[piman, 2014/09/04 17:32:54]

nit: move this to DoBindTexImage and save a line. (conceptually, it makes sense
that DoBindTexImage resets the state).

[reveman, 2014/09/04 18:57:43]

Done.

+  return true;
+}
+
+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;
+
+  DCHECK(memory_);
+  glTexImage2D(target,
+               0,  // mip level
+               TextureFormat(internalformat_),
+               size_.width(),
+               size_.height(),
+               0,  // border
+               DataFormat(internalformat_),
+               DataType(internalformat_),
+               memory_);

[piman, 2014/09/04 17:32:54]

If the data was already uploaded to the source texture, a GPU->GPU copy will be
more efficient than a new upload. Is there a way to detect this? E.g. if
need_do_bind_tex_image_ is false, fail the copy, so that the calling code will
fallback.

BTW, why do we need the copy in the first place?

[reveman, 2014/09/04 18:57:43]

Good point. I made this work by tracking if the image is bound to a texture
using |target_| and in that case only upload directly to destination texture if
need_do_bind_tex_image_ is set.
You mean instead of just using the image for zero-copy? This alternative
one-copy approach is useful for 2 reasons:

1. Easier synchronization if images are used in a fixed sequence in a staging
pool as we only have to worry about the copy operations completing on the GPU.
Doesn't matter in the software case but useful with SurfaceTextures where the
synchronization mechanism is not exactly what we want.

2. Gives us control over the amount of staging resources and zero-copy buffers
that are used. On some systems it might be too expensive to use one zero-copy
buffer for each tile resource. ie. file descriptor limits on Android. In the
software case, it's shared memory objects and having a shared memory backing for
each tile texture is not really an option. This allows us to use a number of
images as staging buffers for uploads, similar to async uploads but this gives
us much better control over the amount of staging memory.

+
+  return true;
+}
+
+void GLImageMemory::WillUseTexImage() {
+  DCHECK(!in_use_);
+  in_use_ = true;
+
+  if (!need_do_bind_tex_image_)
+    return;
+
+  DoBindTexImage(target_);
+  need_do_bind_tex_image_ = false;
+}
+
+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(memory_);
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
@@ -176,8 +246,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 +260,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