gpu: Add CopyTexImage function to GLImage API.

This provides a mechanism for GLImage implementations to optimize
blit image to texture.

In the case of GLImageMemory, this allows us to upload directly
to the destination texture instead of first uploading to a temporary
texture copying pixels from this texture to the destination texture.

BUG=374962

Review URL: https://codereview.chromium.org/536353002

Cr-Commit-Position: refs/heads/master@{#293404}

content/common/gpu/stream_texture_android.cc

@@ -202,6 +202,11 @@ void StreamTexture::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
 
+bool StreamTexture::CopyTexImage(unsigned target) {
+  NOTREACHED();
+  return false;
+}
+
 bool StreamTexture::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                          int z_order,
                                          gfx::OverlayTransform transform,

content/common/gpu/stream_texture_android.h

@@ -37,6 +37,7 @@ class StreamTexture : public gfx::GLImage,
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE;
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE;
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}

gpu/command_buffer/service/gles2_cmd_decoder.cc

@@ -10128,9 +10128,19 @@ void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
         dest_texture_ref, GL_TEXTURE_2D, level, true);
   }
 
-  DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
   ScopedModifyPixels modify(dest_texture_ref);
 
+  // Try using GLImage::CopyTexImage when possible.
+  bool unpack_premultiply_alpha_change =
+      unpack_premultiply_alpha_ ^ unpack_unpremultiply_alpha_;
+  if (image && !unpack_flip_y_ && !unpack_premultiply_alpha_change && !level) {
+    glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
+    if (image->CopyTexImage(GL_TEXTURE_2D))
+      return;
+  }
+
+  DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
+
   // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
   // before presenting.
   if (source_texture->target() == GL_TEXTURE_EXTERNAL_OES) {

gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc

@@ -2279,6 +2279,7 @@ class MockGLImage : public gfx::GLImage {
   MOCK_METHOD1(Destroy, void(bool));
   MOCK_METHOD1(BindTexImage, bool(unsigned));
   MOCK_METHOD1(ReleaseTexImage, void(unsigned));
+  MOCK_METHOD1(CopyTexImage, bool(unsigned));
   MOCK_METHOD0(WillUseTexImage, void());
   MOCK_METHOD0(DidUseTexImage, void());
   MOCK_METHOD0(WillModifyTexImage, void());

gpu/command_buffer/service/stream_texture_manager_in_process_android.cc

@@ -27,6 +27,7 @@ class GLImageImpl : public gfx::GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE;
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE;
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}
@@ -72,6 +73,11 @@ void GLImageImpl::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
 
+bool GLImageImpl::CopyTexImage(unsigned target) {
+  NOTREACHED();
+  return false;
+}
+
 void GLImageImpl::WillUseTexImage() {
   surface_texture_->UpdateTexImage();
 }

gpu/command_buffer/service/texture_definition.cc

@@ -34,6 +34,7 @@ class GLImageSync : public gfx::GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE;
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE;
   virtual void WillModifyTexImage() OVERRIDE;
   virtual void DidModifyTexImage() OVERRIDE;
@@ -83,6 +84,11 @@ void GLImageSync::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
 
+bool GLImageSync::CopyTexImage(unsigned target) {
+  NOTREACHED();
+  return false;
+}
+
 void GLImageSync::WillUseTexImage() {
   if (buffer_.get())
     buffer_->WillRead(this);

ui/gl/gl_image.cc

@@ -12,6 +12,8 @@ GLImage::GLImage() {
 GLImage::~GLImage() {
 }
 
+bool GLImage::CopyTexImage(unsigned target) { return false; }
+
 void GLImage::SetReleaseAfterUse() {
   // Default no-op implementation for workaround.
 }

ui/gl/gl_image.h

@@ -33,6 +33,9 @@ class GL_EXPORT GLImage : public base::RefCounted<GLImage> {
   // Release image from texture currently bound to |target|.
   virtual void ReleaseTexImage(unsigned target) = 0;
 
+  // Copy image to texture currently bound to |target|.
+  virtual bool CopyTexImage(unsigned target) = 0;
+
   // Called before the texture is used for drawing.
   virtual void WillUseTexImage() = 0;
 

ui/gl/gl_image_egl.cc

@@ -50,6 +50,10 @@ bool GLImageEGL::BindTexImage(unsigned target) {
   return true;
 }
 
+bool GLImageEGL::CopyTexImage(unsigned target) {
+  return false;
+}
+
 bool GLImageEGL::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                       int z_order,
                                       OverlayTransform transform,

ui/gl/gl_image_egl.h

@@ -21,6 +21,7 @@ class GL_EXPORT GLImageEGL : public GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE {}
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE {}
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}

ui/gl/gl_image_glx.cc

@@ -190,6 +190,10 @@ void GLImageGLX::ReleaseTexImage(unsigned target) {
   glXReleaseTexImageEXT(gfx::GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT);
 }
 
+bool GLImageGLX::CopyTexImage(unsigned target) {
+  return false;
+}
+
 bool GLImageGLX::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                       int z_order,
                                       OverlayTransform transform,

ui/gl/gl_image_glx.h

@@ -23,6 +23,7 @@ class GL_EXPORT GLImageGLX : public GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE;
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE {}
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}

ui/gl/gl_image_io_surface.cc

@@ -64,6 +64,10 @@ bool GLImageIOSurface::BindTexImage(unsigned target) {
   return true;
 }
 
+bool GLImageIOSurface::CopyTexImage(unsigned target) {
+  return false;
+}
+
 bool GLImageIOSurface::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                             int z_order,
                                             OverlayTransform transform,

ui/gl/gl_image_io_surface.h

@@ -24,6 +24,7 @@ class GL_EXPORT GLImageIOSurface : public GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE {}
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE {}
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}

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,80 @@ gfx::Size GLImageMemory::GetSize() {
 }
 
 bool GLImageMemory::BindTexImage(unsigned target) {
-  TRACE_EVENT0("gpu", "GLImageMemory::BindTexImage");
+  if (target_ && target_ != target) {
+    LOG(ERROR) << "GLImage can only be bound to one target";
+    return false;
+  }
+  target_ = target;
+
+  // Defer DoBindTexImage if not currently in use.
+  if (!in_use_) {
+    need_do_bind_tex_image_ = true;
+    return true;
+  }
+
+  DoBindTexImage(target);
+  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_);
+
+  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 +252,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 +266,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

ui/gl/gl_image_memory.h

@@ -26,8 +26,9 @@ class GL_EXPORT GLImageMemory : public GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE {}
-  virtual void WillUseTexImage() OVERRIDE {}
-  virtual void DidUseTexImage() OVERRIDE {}
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
+  virtual void WillUseTexImage() OVERRIDE;
+  virtual void DidUseTexImage() OVERRIDE;
   virtual void WillModifyTexImage() OVERRIDE {}
   virtual void DidModifyTexImage() OVERRIDE {}
   virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
@@ -43,9 +44,14 @@ class GL_EXPORT GLImageMemory : public GLImage {
   size_t Bytes() const;
 
  private:
+  void DoBindTexImage(unsigned target);
+
   const unsigned char* memory_;
   const gfx::Size size_;
   const unsigned internalformat_;
+  bool in_use_;
+  unsigned target_;
+  bool need_do_bind_tex_image_;
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
   unsigned egl_texture_id_;

ui/gl/gl_image_stub.cc

@@ -14,6 +14,8 @@ gfx::Size GLImageStub::GetSize() { return gfx::Size(1, 1); }
 
 bool GLImageStub::BindTexImage(unsigned target) { return true; }
 
+bool GLImageStub::CopyTexImage(unsigned target) { return true; }
+
 bool GLImageStub::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                        int z_order,
                                        OverlayTransform transform,

ui/gl/gl_image_stub.h

@@ -19,6 +19,7 @@ class GL_EXPORT GLImageStub : public GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE {}
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE {}
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}

ui/gl/gl_image_surface_texture.cc

@@ -77,6 +77,10 @@ bool GLImageSurfaceTexture::BindTexImage(unsigned target) {
   return true;
 }
 
+bool GLImageSurfaceTexture::CopyTexImage(unsigned target) {
+  return false;
+}
+
 bool GLImageSurfaceTexture::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                                  int z_order,
                                                  OverlayTransform transform,

ui/gl/gl_image_surface_texture.h

@@ -25,6 +25,7 @@ class GL_EXPORT GLImageSurfaceTexture : public GLImage {
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE {}
+  virtual bool CopyTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE {}
   virtual void DidUseTexImage() OVERRIDE {}
   virtual void WillModifyTexImage() OVERRIDE {}