Add is_encrypted() in VideoDecoderConfig.

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 149 matching lines @@
   // |type| didn't match any of the supported types.
   return false;
 }
 
 class ChunkDemuxerStream : public DemuxerStream {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
   typedef std::deque<ReadCB> ReadCBQueue;
   typedef std::deque<base::Closure> ClosureQueue;
 
-  explicit ChunkDemuxerStream(const AudioDecoderConfig& audio_config);
-  explicit ChunkDemuxerStream(const VideoDecoderConfig& video_config);
+  ChunkDemuxerStream(const AudioDecoderConfig& audio_config, bool is_encrypted);
+  ChunkDemuxerStream(const VideoDecoderConfig& video_config, bool is_encrypted);
 
   void StartWaitingForSeek();
   void Seek(TimeDelta time);
   void CancelPendingSeek();
   bool IsSeekPending() const;
 
   // Add buffers to this stream.  Buffers are stored in SourceBufferStreams,
   // which handle ordering and overlap resolution.
   // Returns true if buffers were successfully added.
   bool Append(const StreamParser::BufferQueue& buffers);
 
   // Signal to the stream that duration has changed to |duration|.
   void OnSetDuration(base::TimeDelta duration);
 
   // Returns the range of buffered data in this stream, capped at |duration|.
   Ranges<TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;
 
   // Signal to the stream that buffers handed in through subsequent calls to
   // Append() belong to a media segment that starts at |start_timestamp|.
   void OnNewMediaSegment(TimeDelta start_timestamp);
 
   // Called when mid-stream config updates occur.
   // Returns true if the new config is accepted.
   // Returns false if the new config should trigger an error.
-  bool UpdateAudioConfig(const AudioDecoderConfig& config);
-  bool UpdateVideoConfig(const VideoDecoderConfig& config);
+  bool UpdateAudioConfig(const AudioDecoderConfig& config, bool is_encrypted);
+  bool UpdateVideoConfig(const VideoDecoderConfig& config, bool is_encrypted);
 
   void EndOfStream();
   bool CanEndOfStream() const;
   void Shutdown();
 
   // DemuxerStream methods.
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual Type type() OVERRIDE;
   virtual void EnableBitstreamConverter() OVERRIDE;
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
+  virtual bool is_encrypted() OVERRIDE;
 
  protected:
   virtual ~ChunkDemuxerStream();
 
  private:
   enum State {
     RETURNING_DATA_FOR_READS,
     WAITING_FOR_SEEK,
     CANCELED,
     SHUTDOWN,
   };
 
   // Assigns |state_| to |state|
   void ChangeState_Locked(State state);
 
   // Adds the callback to |read_cbs_| so it can be called later when we
   // have data.
   void DeferRead_Locked(const ReadCB& read_cb);
 
   // Creates closures that bind ReadCBs in |read_cbs_| to data in
-  // |buffers_| and pops the callbacks & buffers from the respecive queues.
+  // |buffers_| and pops the callbacks & buffers from the respective queues.
   void CreateReadDoneClosures_Locked(ClosureQueue* closures);
 
   // Gets the value to pass to the next Read() callback. Returns true if
   // |status| and |buffer| should be passed to the callback. False indicates
   // that |status| and |buffer| were not set and more data is needed.
   bool GetNextBuffer_Locked(DemuxerStream::Status* status,
                             scoped_refptr<StreamParserBuffer>* buffer);
 
   // Specifies the type of the stream (must be AUDIO or VIDEO for now).
   Type type_;
 
   scoped_ptr<SourceBufferStream> stream_;
 
   mutable base::Lock lock_;
   State state_;
   ReadCBQueue read_cbs_;
   bool end_of_stream_;
+  bool is_encrypted_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
-ChunkDemuxerStream::ChunkDemuxerStream(const AudioDecoderConfig& audio_config)
+ChunkDemuxerStream::ChunkDemuxerStream(const AudioDecoderConfig& audio_config,
+                                       bool is_encrypted)
     : type_(AUDIO),
       state_(RETURNING_DATA_FOR_READS),
-      end_of_stream_(false) {
+      end_of_stream_(false),
+      is_encrypted_(is_encrypted) {
   stream_.reset(new SourceBufferStream(audio_config));
 }
 
-ChunkDemuxerStream::ChunkDemuxerStream(const VideoDecoderConfig& video_config)
+ChunkDemuxerStream::ChunkDemuxerStream(const VideoDecoderConfig& video_config,
+                                       bool is_encrypted)
     : type_(VIDEO),
       state_(RETURNING_DATA_FOR_READS),
-      end_of_stream_(false) {
+      end_of_stream_(false),
+      is_encrypted_(is_encrypted) {
   stream_.reset(new SourceBufferStream(video_config));
 }
 
 void ChunkDemuxerStream::StartWaitingForSeek() {
   DVLOG(1) << "StartWaitingForSeek()";
   ReadCBQueue read_cbs;
   {
     base::AutoLock auto_lock(lock_);
     ChangeState_Locked(WAITING_FOR_SEEK);
     end_of_stream_ = false;
@@ skipping 79 matching lines @@
     return range;
 
   // Clamp the end of the stream's buffered ranges to fit within the duration.
   // This can be done by intersecting the stream's range with the valid time
   // range.
   Ranges<TimeDelta> valid_time_range;
   valid_time_range.Add(range.start(0), duration);
   return range.IntersectionWith(valid_time_range);
 }
 
-bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
+bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config,
+                                           bool is_encrypted) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
+  is_encrypted_ = is_encrypted;

[acolwell GONE FROM CHROMIUM, 2012/09/15 00:25:24]

This is not correct. It will cause the is_encrypted_ state to be incorrect when
a config change happens. This method updates the "append side" config of the
SourceBufferStream and the DemuxerStream methods are supposed to reflect the
current playback position config. If you are currently playing encrypted content
and an unencrypted init segment is appended, the DemuxerStream will reflect that
the stream is not encrypted eventhough the current playback position hasn't
reached the config change yet.

   return stream_->UpdateAudioConfig(config);
 }
 
-bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
+bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config,
+                                           bool is_encrypted) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, VIDEO);
+  is_encrypted_ = is_encrypted;

[acolwell GONE FROM CHROMIUM, 2012/09/15 00:25:24]

ditto

   return stream_->UpdateVideoConfig(config);
 }
 
 void ChunkDemuxerStream::EndOfStream() {
   ClosureQueue closures;
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(!end_of_stream_);
     DCHECK(stream_->IsEndSelected());
     end_of_stream_ = true;
@@ skipping 70 matching lines @@
 }
 
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
            << "type " << type_
            << " - " << state_ << " -> " << state;
   state_ = state;
 }
 
+bool ChunkDemuxerStream::is_encrypted() {
+  base::AutoLock auto_lock(lock_);
+  return is_encrypted_;
+}
+
 ChunkDemuxerStream::~ChunkDemuxerStream() {}
 
 void ChunkDemuxerStream::DeferRead_Locked(const ReadCB& read_cb) {
   lock_.AssertAcquired();
   // Wrap & store |read_cb| so that it will
   // get called on the current MessageLoop.
   read_cbs_.push_back(base::Bind(&RunOnMessageLoop, read_cb,
                                  base::MessageLoopProxy::current()));
 }
 
@@ skipping 542 matching lines @@
     duration_ = kInfiniteDuration();
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 
 }
 
 bool ChunkDemuxer::OnNewConfigs(bool has_audio, bool has_video,
                                 const AudioDecoderConfig& audio_config,
-                                const VideoDecoderConfig& video_config) {
+                                const VideoDecoderConfig& video_config,
+                                bool is_audio_encrypted,
+                                bool is_video_encrypted) {
   DVLOG(1) << "OnNewConfigs(" << has_audio << ", " << has_video
            << ", " << audio_config.IsValidConfig()
            << ", " << video_config.IsValidConfig() << ")";
   lock_.AssertAcquired();
 
   if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
     return false;
   }
 
   // Signal an error if we get configuration info for stream types that weren't
   // specified in AddId() or more configs after a stream is initialized.
   // Only allow a single audio config for now.
   if (has_audio != audio_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Got unexpected audio config.";
     return false;
   }
 
   // Only allow a single video config for now.
   if (has_video != video_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Got unexpected video config.";
     return false;
   }
 
   bool success = true;
   if (audio_config.IsValidConfig()) {
     if (audio_) {
-      success &= audio_->UpdateAudioConfig(audio_config);
+      success &= audio_->UpdateAudioConfig(audio_config, is_audio_encrypted);
     } else {
-      audio_ = new ChunkDemuxerStream(audio_config);
+      audio_ = new ChunkDemuxerStream(audio_config, is_audio_encrypted);
     }
   }
 
   if (video_config.IsValidConfig()) {
     if (video_) {
-      success &= video_->UpdateVideoConfig(video_config);
+      success &= video_->UpdateVideoConfig(video_config, is_video_encrypted);
     } else {
-      video_ = new ChunkDemuxerStream(video_config);
+      video_ = new ChunkDemuxerStream(video_config, is_video_encrypted);
     }
   }
 
   DVLOG(1) << "OnNewConfigs() : success " << success;
   return success;
 }
 
 bool ChunkDemuxer::OnAudioBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
@@ skipping 116 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media