Add GLStreamTextureImage

content/common/gpu/media/android_deferred_rendering_backing_strategy.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/android_deferred_rendering_backing_strategy.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_surface_lookup.h"
 #include "content/common/gpu/media/avda_codec_image.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
 #include "content/common/gpu/media/avda_shared_state.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_stream_texture_image.h"
 
 namespace content {
 
 AndroidDeferredRenderingBackingStrategy::
     AndroidDeferredRenderingBackingStrategy(AVDAStateProvider* state_provider)
     : state_provider_(state_provider), media_codec_(nullptr) {}
 
 AndroidDeferredRenderingBackingStrategy::
     ~AndroidDeferredRenderingBackingStrategy() {}
 
@@ skipping 12 matching lines @@
     surface_texture_->DetachFromGLContext();
     surface = gfx::ScopedJavaSurface(surface_texture_.get());
   }
 
   // Create a texture for the SurfaceTexture to use.  We don't attach it here
   // so that it gets attached in the compositor gl context in the common case.
   GLuint service_id = 0;
   glGenTextures(1, &service_id);
   DCHECK(service_id);
   shared_state_->set_surface_texture_service_id(service_id);
+  shared_state_->set_share_group(gfx::GLContext::GetCurrent()->share_group());
 
   return surface;
 }
 
 void AndroidDeferredRenderingBackingStrategy::Cleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // If we failed before Initialize, then do nothing.
   if (!shared_state_)
     return;
@@ skipping 37 matching lines @@
     const media::PictureBuffer& picture_buffer) {
   gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
   RETURN_NULL_IF_NULL(texture_ref);
   gl::GLImage* image =
       texture_ref->texture()->GetLevelImage(GetTextureTarget(), 0);
   return static_cast<AVDACodecImage*>(image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
     const media::PictureBuffer& picture_buffer,
-    const scoped_refptr<gl::GLImage>& image) {
+    const scoped_refptr<gl::GLStreamTextureImage>& image) {
   gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
   RETURN_IF_NULL(texture_ref);
 
   gpu::gles2::TextureManager* texture_manager =
       state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
   RETURN_IF_NULL(texture_manager);
 
   if (image) {
     // Also set the parameters for the level if we're not clearing
     // the image.
@@ skipping 19 matching lines @@
   // For SurfaceTexture we set the image to UNBOUND so that the implementation
   // will call CopyTexImage, which is where AVDACodecImage updates the
   // SurfaceTexture to the right frame.
   // For SurfaceView we set the image to be BOUND because ScheduleOverlayPlane
   // expects it. If something tries to sample from this texture it won't work,
   // but there's no way to sample from a SurfaceView anyway, so it doesn't
   // matter. The only way to use this texture is to schedule it as an overlay.
   const gpu::gles2::Texture::ImageState image_state =
       surface_texture_ ? gpu::gles2::Texture::UNBOUND
                        : gpu::gles2::Texture::BOUND;
-  texture_manager->SetLevelImage(texture_ref, GetTextureTarget(), 0,
-                                 image.get(), image_state);
+  texture_manager->SetLevelStreamTextureImage(texture_ref, GetTextureTarget(),
+                                              0, image.get(), image_state);
 }
 
 void AndroidDeferredRenderingBackingStrategy::UseCodecBufferForPictureBuffer(
     int32_t codec_buf_index,
     const media::PictureBuffer& picture_buffer) {
   // Make sure that the decoder is available.
   RETURN_IF_NULL(state_provider_->GetGlDecoder());
 
   // Notify the AVDACodecImage for picture_buffer that it should use the
   // decoded buffer codec_buf_index to render this frame.
   AVDACodecImage* avda_image = GetImageForPicture(picture_buffer);
   RETURN_IF_NULL(avda_image);
   DCHECK_EQ(avda_image->GetMediaCodecBufferIndex(), -1);
   // Note that this is not a race, since we do not re-use a PictureBuffer
   // until after the CC is done drawing it.
   avda_image->SetMediaCodecBufferIndex(codec_buf_index);
   avda_image->SetSize(state_provider_->GetSize());
 }
 
 void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
     const media::PictureBuffer& picture_buffer) {
   // Attach a GLImage to each texture that will use the surface texture.
   // We use a refptr here in case SetImageForPicture fails.
-  scoped_refptr<gl::GLImage> gl_image =
+  scoped_refptr<gl::GLStreamTextureImage> gl_image =
       new AVDACodecImage(shared_state_, media_codec_,
                          state_provider_->GetGlDecoder(), surface_texture_);
   SetImageForPicture(picture_buffer, gl_image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBufferForPicture(
     const media::PictureBuffer& picture_buffer) {
   AVDACodecImage* avda_image = GetImageForPicture(picture_buffer);
 
   // See if there is a media codec buffer still attached to this image.
@@ skipping 44 matching lines @@
   shared_state_->SignalFrameAvailable();
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ArePicturesOverlayable() {
   // SurfaceView frames are always overlayable because that's the only way to
   // display them.
   return !surface_texture_;
 }
 
 }  // namespace content