Add DecryptingDemuxerStream.

media/filters/decrypting_audio_decoder.cc

 // Copyright (c) 2012 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/decrypting_audio_decoder.h"
 
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
+#include "base/logging.h"
 #include "base/message_loop_proxy.h"
-#include "base/logging.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/pipeline.h"
 
 namespace media {
@@ skipping 10 matching lines @@
          kOutOfSyncThresholdInMicroseconds;
 }
 
 DecryptingAudioDecoder::DecryptingAudioDecoder(
     const MessageLoopFactoryCB& message_loop_factory_cb,
     const RequestDecryptorNotificationCB& request_decryptor_notification_cb)
     : message_loop_factory_cb_(message_loop_factory_cb),
       state_(kUninitialized),
       request_decryptor_notification_cb_(request_decryptor_notification_cb),
       decryptor_(NULL),
-      key_added_while_pending_decode_(false),
+      key_added_while_decode_pending_(false),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       samples_per_second_(0),
       bytes_per_sample_(0),
       output_timestamp_base_(kNoTimestamp()),
       total_samples_decoded_(0) {
 }
 
 void DecryptingAudioDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
@@ skipping 266 matching lines @@
     int buffer_size,
     Decryptor::Status status,
     const Decryptor::AudioBuffers& frames) {
   DVLOG(3) << "DoDeliverFrame() - status: " << status;
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPendingDecode) << state_;
   DCHECK(!read_cb_.is_null());
   DCHECK(pending_buffer_to_decode_);
   DCHECK(queued_audio_frames_.empty());
 
-  bool need_to_try_again_if_nokey_is_returned = key_added_while_pending_decode_;
-  key_added_while_pending_decode_ = false;
+  bool need_to_try_again_if_nokey_is_returned = key_added_while_decode_pending_;
+  key_added_while_decode_pending_ = false;
 
   scoped_refptr<DecoderBuffer> scoped_pending_buffer_to_decode =
       pending_buffer_to_decode_;
   pending_buffer_to_decode_ = NULL;
 
   if (!reset_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
     DoReset();
     return;
   }
@@ skipping 50 matching lines @@
 
   state_ = kIdle;
   base::ResetAndReturn(&read_cb_).Run(kOk, queued_audio_frames_.front());
   queued_audio_frames_.pop_front();
 }
 
 void DecryptingAudioDecoder::OnKeyAdded() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kPendingDecode) {
-    key_added_while_pending_decode_ = true;
+    key_added_while_decode_pending_ = true;
     return;
   }
 
   if (state_ == kWaitingForKey) {
     state_ = kPendingDecode;
     DecodePendingBuffer();
   }
 }
 
 void DecryptingAudioDecoder::DoReset() {
@@ skipping 42 matching lines @@
 
 base::TimeDelta DecryptingAudioDecoder::NumberOfSamplesToDuration(
     int number_of_samples) const {
   DCHECK(samples_per_second_);
   return base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
                                            number_of_samples /
                                            samples_per_second_);
 }
 
 }  // namespace media