Split out AVDA cleanups from SetSurface() change.

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/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "media/base/android/sdk_media_codec_bridge.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,
     VideoCodecBridge* codec,
     const base::WeakPtr<gpu::gles2::GLES2Decoder>& decoder)
     : shared_state_(shared_state),
       codec_buffer_index_(kInvalidCodecBufferIndex),
       media_codec_(codec),
       decoder_(decoder),
       has_surface_texture_(!!shared_state_->surface_texture_service_id()),
-      texture_(0),
-      picture_buffer_id_(picture_buffer_id) {
-  shared_state_->SetImageForPicture(picture_buffer_id_, this);
-}
+      texture_(0) {}
 
-AVDACodecImage::~AVDACodecImage() {
-  shared_state_->SetImageForPicture(picture_buffer_id_, nullptr);
-}
+AVDACodecImage::~AVDACodecImage() {}
 
 gfx::Size AVDACodecImage::GetSize() {
   return size_;
 }
 
 unsigned AVDACodecImage::GetInternalFormat() {
   return GL_RGBA;
 }
 
 bool AVDACodecImage::BindTexImage(unsigned target) {
   return false;
 }
 
 void AVDACodecImage::ReleaseTexImage(unsigned target) {}
 
 bool AVDACodecImage::CopyTexImage(unsigned target) {
-  if (!has_surface_texture_)
-    return false;
-
-  if (target != GL_TEXTURE_EXTERNAL_OES)
+  if (!has_surface_texture_ || 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.
   if (bound_service_id !=
       static_cast<GLint>(shared_state_->surface_texture_service_id())) {
     return false;
   }
 
@@ skipping 128 matching lines @@
     codec_buffer_index_ = kUpdateOnly;
   }
 
   // Only wait for the SurfaceTexture update if we're rendering to the front.
   if (update_mode == UpdateMode::RENDER_TO_FRONT_BUFFER)
     shared_state_->WaitForFrameAvailable();
 }
 
 std::unique_ptr<ui::ScopedMakeCurrent> AVDACodecImage::MakeCurrentIfNeeded() {
   DCHECK(shared_state_->context());
-  std::unique_ptr<ui::ScopedMakeCurrent> scoped_make_current;
   // Remember: virtual contexts return true if and only if their shared context
   // is current, regardless of which virtual context it is.
-  if (!shared_state_->context()->IsCurrent(NULL)) {
-    scoped_make_current.reset(new ui::ScopedMakeCurrent(
-        shared_state_->context(), shared_state_->surface()));
-  }
-
-  return scoped_make_current;
+  return std::unique_ptr<ui::ScopedMakeCurrent>(
+      shared_state_->context()->IsCurrent(nullptr)
+          ? nullptr
+          : new ui::ScopedMakeCurrent(shared_state_->context(),
+                                      shared_state_->surface()));
 }
 
 void AVDACodecImage::GetTextureMatrix(float matrix[16]) {
   // Our current matrix may be stale.  Update it if possible.
   if (has_surface_texture_)
     UpdateSurface(UpdateMode::RENDER_TO_FRONT_BUFFER);
   shared_state_->GetTransformMatrix(matrix);
   YInvertMatrix(matrix);
 }
 
 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