Store AVDACodecImage list in shared state, cleanup callers.

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 938 matching lines @@
 
   state_ = WAITING_FOR_CODEC;
 
   // Tell the strategy that we're changing codecs.  The codec itself could be
   // used normally, since we don't replace it until we're back on the main
   // thread.  However, if we're using an output surface, then the incoming codec
   // might access that surface while the main thread is drawing.  Telling the
   // strategy to forget the codec avoids this.
   if (media_codec_) {
     media_codec_.reset();
-    strategy_->CodecChanged(nullptr, output_picture_buffers_);
+    strategy_->CodecChanged(nullptr);
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       g_avda_timer.Pointer()->ConstructionTaskRunner();
   CHECK(task_runner);
 
   base::PostTaskAndReplyWithResult(
       task_runner.get(), FROM_HERE,
       base::Bind(&AndroidVideoDecodeAccelerator::ConfigureMediaCodecOnAnyThread,
                  codec_config_),
@@ skipping 31 matching lines @@
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<media::VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, WAITING_FOR_CODEC);
 
   media_codec_ = std::move(media_codec);
 
   // Record one instance of the codec being initialized.
   RecordFormatChangedMetric(FormatChangedValue::CodecInitialized);
 
-  strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
+  strategy_->CodecChanged(media_codec_.get());
 
   // If we are supposed to notify that initialization is complete, then do so
   // now.  Otherwise, this is a reconfiguration.
   if (deferred_initialization_pending_) {
     NotifyInitializationComplete(!!media_codec_);
     deferred_initialization_pending_ = false;
   }
 
   if (!media_codec_) {
     POST_ERROR(PLATFORM_FAILURE, "Failed to create MediaCodec.");
@@ skipping 39 matching lines @@
   // flush()) for JB-MR2 and beyond. Prior to JB-MR2, flush() had several bugs
   // (b/8125974, b/8347958) so we must delete the MediaCodec and create a new
   // one. The full reconfigure is much slower and may cause visible freezing if
   // done mid-stream.
   if (state_ == NO_ERROR &&
       base::android::BuildInfo::GetInstance()->sdk_int() >= 18) {
     DVLOG(3) << __FUNCTION__ << " Doing fast MediaCodec reset (flush).";
     media_codec_->Reset();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
-    strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
+    strategy_->CodecChanged(media_codec_.get());
   } else {
     DVLOG(3) << __FUNCTION__
              << " Deleting the MediaCodec and creating a new one.";
     g_avda_timer.Pointer()->StopTimer(this);
     // Changing the codec will also notify the strategy to forget about any
     // output buffers it has currently.
     state_ = NO_ERROR;
     ConfigureMediaCodecAsynchronously();
   }
 }
@@ skipping 272 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace content