AVDACodecImages keep their backing SurfaceTexture alive

media/gpu/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 "media/gpu/avda_codec_image.h"
 
 #include <string.h>
 
 #include <memory>
 
-#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 "media/gpu/avda_shared_state.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace media {
 
 AVDACodecImage::AVDACodecImage(
     int picture_buffer_id,
     const scoped_refptr<AVDASharedState>& shared_state,
-    media::VideoCodecBridge* codec,
+    media::MediaCodecBridge* codec,
     const base::WeakPtr<gpu::gles2::GLES2Decoder>& decoder,
     const scoped_refptr<gfx::SurfaceTexture>& surface_texture)
     : shared_state_(shared_state),
       codec_buffer_index_(kInvalidCodecBufferIndex),
       media_codec_(codec),
       decoder_(decoder),
       surface_texture_(surface_texture),
       texture_(0),
       picture_buffer_id_(picture_buffer_id) {
   // Default to a sane guess of "flip Y", just in case we can't get
@@ skipping 26 matching lines @@
 
 bool AVDACodecImage::CopyTexImage(unsigned target) {
   if (!surface_texture_)
     return false;
 
   if (target != GL_TEXTURE_EXTERNAL_OES)
     return false;
 
   GLint bound_service_id = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &bound_service_id);
-  // We insist that the currently bound texture is the right one.  We could
-  // make a new glimage from a 2D image.
-  if (bound_service_id != shared_state_->surface_texture_service_id())
+  // We insist that the currently bound texture is the right one.
+  if (bound_service_id !=
+      static_cast<GLint>(shared_state_->surface_texture_service_id())) {
     return false;
+  }
 
   // Make sure that we have the right image in the front buffer.  Note that the
   // bound_service_id is guaranteed to be equal to the surface texture's client
   // texture id, so we can skip preserving it if the right context is current.
   UpdateSurfaceInternal(UpdateMode::RENDER_TO_FRONT_BUFFER,
                         kDontRestoreBindings);
 
   // By setting image state to UNBOUND instead of COPIED we ensure that
   // CopyTexImage() is called each time the surface texture is used for drawing.
   // It would be nice if we could do this via asking for the currently bound
@@ skipping 77 matching lines @@
   // SurfaceViews are updated implicitly, so no further steps are necessary.
   if (!surface_texture_) {
     DCHECK(update_mode != UpdateMode::RENDER_TO_BACK_BUFFER);
     return;
   }
 
   // If front buffer rendering hasn't been requested, exit early.
   if (update_mode != UpdateMode::RENDER_TO_FRONT_BUFFER)
     return;
 
-  DCHECK(shared_state_->surface_texture_is_attached());
   UpdateSurfaceTexture(attached_bindings_mode);
 }
 
 void AVDACodecImage::ReleaseOutputBuffer(UpdateMode update_mode) {
   DCHECK(IsCodecBufferOutstanding());
 
   // In case of discard, simply discard and clear our codec buffer index.
   if (update_mode == UpdateMode::DISCARD_CODEC_BUFFER) {
     if (codec_buffer_index_ != kUpdateOnly)
       media_codec_->ReleaseOutputBuffer(codec_buffer_index_, false);
@@ skipping 51 matching lines @@
 }
 
 bool AVDACodecImage::IsCodecBufferOutstanding() const {
   static_assert(kUpdateOnly < 0 && kUpdateOnly > kRendered &&
                     kRendered > kInvalidCodecBufferIndex,
                 "Codec buffer index enum values are not ordered correctly.");
   return codec_buffer_index_ > kRendered && media_codec_;
 }
 
 }  // namespace media