Re-land: ui: Move GLImage::BindTexImage fallback from GLImage implementations to GLES2CmdDecoder.

content/common/gpu/media/avda_codec_image.cc

 // Copyright 2015 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 "content/common/gpu/media/avda_codec_image.h"
 
 #include "content/common/gpu/media/avda_shared_state.h"
+#include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace content {
 
 AVDACodecImage::AVDACodecImage(
@@ skipping 25 matching lines @@
 
 gfx::Size AVDACodecImage::GetSize() {
   return size_;
 }
 
 unsigned AVDACodecImage::GetInternalFormat() {
   return GL_RGBA;
 }
 
 bool AVDACodecImage::BindTexImage(unsigned target) {
-  return true;
+  return false;
 }
 
 void AVDACodecImage::ReleaseTexImage(unsigned target) {}
 
-bool AVDACodecImage::CopyTexSubImage(unsigned target,
-                                     const gfx::Point& offset,
-                                     const gfx::Rect& rect) {
-  return false;
-}
-
-void AVDACodecImage::WillUseTexImage() {
+bool AVDACodecImage::CopyTexImage(unsigned target) {
   // Have we bound the SurfaceTexture's texture handle to the active
   // texture unit yet?
   bool bound_texture = false;
 
   // Attach the surface texture to our GL context if needed.
   if (!shared_state_->surface_texture_service_id()) {
     AttachSurfaceTextureToContext();
     bound_texture = true;
   }
 
   // Make sure that we have the right image in the front buffer.
   bound_texture |= UpdateSurfaceTexture();
 
   // TODO(liberato): Handle the texture matrix properly.
   // Either we can update the shader with it or we can move all of the logic
   // to updateTexImage() to the right place in the cc to send it to the shader.
   // For now, we just skip it.  crbug.com/530681
 
-  // Sneakily bind the ST texture handle in the real GL context.
-  // If we called UpdateTexImage() to update the ST front buffer, then we can
-  // skip this.  Since one draw/frame is the common case, we optimize for it.
-  if (!bound_texture)
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES,

[liberato (no reviews please), 2015/10/19 16:11:41]

this still needs to be done, but i don't see it in the new version.

[reveman, 2015/10/19 16:28:17]

We get this service id from the glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES)
call in AttachSurfaceTextureToContext(). That will return the service id that is
currently bound to the target and will be bound in future calls to
CopyTexImage(). I'm failing to see how the service id will ever not be bound
when this is called. What am I missing?

-                  shared_state_->surface_texture_service_id());
+  gpu::gles2::TextureManager* texture_manager =
+      decoder_->GetContextGroup()->texture_manager();
+  gpu::gles2::Texture* texture =
+      texture_manager->GetTextureForServiceId(
+          shared_state_->surface_texture_service_id());
+  if (texture) {
+    // By setting image state to UNBOUND instead of COPIED we ensure that
+    // CopyTexImage() is called each time the surface texture is used for
+    // drawing.
+    texture->SetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0, this,
+                           gpu::gles2::Texture::UNBOUND);
+  }
+
+  return true;
 }
 
-void AVDACodecImage::DidUseTexImage() {
-  // Unbind the ST's service_id in the real GL context in favor of whatever
-  // the decoder thinks is bound there.
-  const gpu::gles2::ContextState* state = decoder_->GetContextState();
-  const gpu::gles2::TextureUnit& active_unit =
-      state->texture_units[state->active_texture_unit];
-  glBindTexture(GL_TEXTURE_EXTERNAL_OES,

[liberato (no reviews please), 2015/10/19 16:11:41]

i think this still needs to happen as well.

-                active_unit.bound_texture_external_oes.get()
-                    ? active_unit.bound_texture_external_oes->service_id()
-                    : 0);
+bool AVDACodecImage::CopyTexSubImage(unsigned target,
+                                     const gfx::Point& offset,
+                                     const gfx::Rect& rect) {
+  return false;
 }
 
 bool AVDACodecImage::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                           int z_order,
                                           gfx::OverlayTransform transform,
                                           const gfx::Rect& bounds_rect,
                                           const gfx::RectF& crop_rect) {
   return false;
 }
 
@@ skipping 58 matching lines @@
 
   // The surface texture is already detached, so just attach it.
   surface_texture_->AttachToGLContext();
   shared_state_->set_surface_texture_service_id(surface_texture_service_id);
   detach_surface_texture_on_destruction_ = true;
 
   // We do not restore the GL state here.
 }
 
 }  // namespace content