Don't ReleaseCodecAndBundle in AVDA::ActualDestroy.

media/gpu/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 "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 1284 matching lines @@
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note that async codec construction might still be in progress.  In that
   // case, the codec will be deleted when it completes once we invalidate all
   // our weak refs.
   weak_this_factory_.InvalidateWeakPtrs();
   GetManager()->StopTimer(this);
-  ReleaseCodecAndBundle();
+  // We only release the codec here, in case codec allocation is in progress.
+  // We don't want to modify |codec_config_|.  Note that the ref will sill be
+  // dropped when it completes, or when we delete |this|.
+  ReleaseCodec();
 
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
@@ skipping 71 matching lines @@
       incoming_overlay_ = std::unique_ptr<AndroidOverlay>();
 
     UpdateSurface();
     // Switching to a SurfaceTexture should never need to wait.  If it does,
     // then the codec might still be using the destroyed surface, which is bad.
     return;
   }
 
   // If we're currently asynchronously configuring a codec, it will be destroyed
   // when configuration completes and it notices that |state_| has changed to
-  // SURFACE_DESTROYED.
+  // SURFACE_DESTROYED.  It's safe to modify |codec_config_| here, since we
+  // checked above for WAITING_FOR_CODEC.
   state_ = SURFACE_DESTROYED;
   ReleaseCodecAndBundle();
 
   // If we're draining, signal completion now because the drain can no longer
   // proceed.
   if (drain_type_)
     OnDrainCompleted();
 }
 
 void AndroidVideoDecodeAccelerator::InitializeCdm() {
@@ skipping 241 matching lines @@
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
   return !config_.is_encrypted() && (codec_config_->codec == kCodecVP8 ||
                                      codec_config_->codec == kCodecVP9);
 }
 
 bool AndroidVideoDecodeAccelerator::UpdateSurface() {
   DCHECK(incoming_overlay_);
+  DCHECK_NE(state_, WAITING_FOR_CODEC);
 
   // Start surface creation.  Note that if we're called via surfaceDestroyed,
   // then this must complete synchronously or it will DCHECK.  Otherwise, we
   // might still be using the destroyed surface.  We don't enforce this, but
   // it's worth remembering that there are cases where it's required.
   // Note that we don't re-use |surface_bundle|, since the codec is using it!
   incoming_bundle_ =
       new AVDASurfaceBundle(std::move(incoming_overlay_.value()));
   incoming_overlay_.reset();
   InitializePictureBufferManager();
@@ skipping 25 matching lines @@
                                       codec_config_->task_type,
                                       codec_config_->surface_bundle);
 }
 
 void AndroidVideoDecodeAccelerator::ReleaseCodecAndBundle() {
   ReleaseCodec();
   codec_config_->surface_bundle = nullptr;
 }
 
 }  // namespace media