media: Always provide CdmContext when selecting decoder in DecoderStream

media/filters/decoder_stream.cc

 // Copyright 2014 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/filters/decoder_stream.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 34 matching lines @@
 template <DemuxerStream::Type StreamType>
 DecoderStream<StreamType>::DecoderStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<Decoder> decoders,
     const scoped_refptr<MediaLog>& media_log)
     : traits_(media_log),
       task_runner_(task_runner),
       media_log_(media_log),
       state_(STATE_UNINITIALIZED),
       stream_(NULL),
+      cdm_context_(nullptr),
       decoder_selector_(new DecoderSelector<StreamType>(task_runner,
                                                         std::move(decoders),
                                                         media_log)),
       decoded_frames_since_fallback_(0),
       decoding_eos_(false),
       pending_decode_requests_(0),
       duration_tracker_(8),
       received_config_change_during_reinit_(false),
       pending_demuxer_read_(false),
       weak_factory_(this),
@@ skipping 35 matching lines @@
     const InitCB& init_cb,
     CdmContext* cdm_context,
     const StatisticsCB& statistics_cb,
     const base::Closure& waiting_for_decryption_key_cb) {
   FUNCTION_DVLOG(1);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
 
+  stream_ = stream;
+  init_cb_ = init_cb;
+  cdm_context_ = cdm_context;
   statistics_cb_ = statistics_cb;
-  init_cb_ = init_cb;
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
-  stream_ = stream;
 
   traits_.OnStreamReset(stream_);
 
   state_ = STATE_INITIALIZING;
-  SelectDecoder(cdm_context);
+  SelectDecoder();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Read(const ReadCB& read_cb) {
   FUNCTION_DVLOG(3);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_INITIALIZING)
       << state_;
   // No two reads in the flight at any time.
   DCHECK(read_cb_.is_null());
@@ skipping 112 matching lines @@
 }
 
 template <DemuxerStream::Type StreamType>
 base::TimeDelta DecoderStream<StreamType>::AverageDuration() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return duration_tracker_.count() ? duration_tracker_.Average()
                                    : base::TimeDelta();
 }
 
 template <DemuxerStream::Type StreamType>
-void DecoderStream<StreamType>::SelectDecoder(CdmContext* cdm_context) {
+void DecoderStream<StreamType>::SelectDecoder() {
   decoder_selector_->SelectDecoder(
-      &traits_, stream_, cdm_context,
+      &traits_, stream_, cdm_context_,
       base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  fallback_weak_factory_.GetWeakPtr()),
       waiting_for_decryption_key_cb_);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderSelected(
     std::unique_ptr<Decoder> selected_decoder,
@@ skipping 162 matching lines @@
       if (!decoded_frames_since_fallback_) {
         pending_decode_requests_ = 0;
 
         // Prevent all pending decode requests and outputs form those requests
         // from being called back.
         fallback_weak_factory_.InvalidateWeakPtrs();
 
         FUNCTION_DVLOG(1)
             << ": Falling back to new decoder after initial decode error.";
         state_ = STATE_REINITIALIZING_DECODER;
-        decoder_selector_->SelectDecoder(
-            &traits_, stream_, nullptr,
-            base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
-                       weak_factory_.GetWeakPtr()),
-            base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
-                       fallback_weak_factory_.GetWeakPtr()),
-            waiting_for_decryption_key_cb_);
+        SelectDecoder();
         return;
       }
       FUNCTION_DVLOG(1) << ": Decode error!";
       state_ = STATE_ERROR;
       MEDIA_LOG(ERROR, media_log_) << GetStreamTypeString() << " decode error";
       ready_outputs_.clear();
       if (!read_cb_.is_null())
         SatisfyRead(DECODE_ERROR, NULL);
       return;
 
@@ skipping 251 matching lines @@
   // ReinitializeDecoder() can be called in two cases:
   // 1, Flushing decoder finished (see OnDecodeOutputReady()).
   // 2, Reset() was called during flushing decoder (see OnDecoderReset()).
   // Also, Reset() can be called during pending ReinitializeDecoder().
   // This function needs to handle them all!
 
   if (!success) {
     // Reinitialization failed. Try to fall back to one of the remaining
     // decoders. This will consume at least one decoder so doing it more than
     // once is safe.
-    // For simplicity, don't attempt to fall back to a decrypting decoder.
-    // Calling this with a null CdmContext ensures that one won't be selected.
-    SelectDecoder(nullptr);
+    SelectDecoder();
   } else {
     CompleteDecoderReinitialization(true);
   }
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::CompleteDecoderReinitialization(bool success) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_REINITIALIZING_DECODER);
@@ skipping 52 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media