Let WebSourceBufferImpl::setMode() update SourceState::sequence_mode_

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 <limits>
 #include <list>
@@ skipping 105 matching lines @@
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
   // Sets |timestamp_offset_| if possible.
   // Returns if the offset was set. Returns false if the offset could not be
   // updated at this time.
   bool SetTimestampOffset(TimeDelta timestamp_offset);
 
+  // Sets |append_mode_| if possible.
+  // Returns if the mode was set. Returns false if the mode could not be updated

[acolwell GONE FROM CHROMIUM, 2014/01/10 23:10:37]

s/Returns if/Returns true if/

[wolenetz, 2014/01/11 00:55:44]

Done.

+  // at this time.
+  bool SetAppendMode(ChunkDemuxer::AppendMode mode);

[acolwell GONE FROM CHROMIUM, 2014/01/10 23:10:37]

How about SetSequenceMode(bool is_sequence_mode) since we only have 2 modes at
this point? That way you don't have to introduce this new enum?

[wolenetz, 2014/01/11 00:55:44]

Done.

+
   TimeDelta timestamp_offset() const { return timestamp_offset_; }
 
   void set_append_window_start(TimeDelta start) {
     append_window_start_ = start;
   }
   void set_append_window_end(TimeDelta end) { append_window_end_ = end; }
 
   // Returns the range of buffered data in this source, capped at |duration|.
   // |ended| - Set to true if end of stream has been signalled and the special
   // end of stream range logic needs to be executed.
@@ skipping 74 matching lines @@
                               bool* needs_keyframe,
                               StreamParser::BufferQueue* filtered_buffers);
 
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   IncreaseDurationCB increase_duration_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // The offset to apply to media segment timestamps.
   TimeDelta timestamp_offset_;
 
+  // The mode by which appended media is processed.
+  // TODO(wolenetz): Enable |kSequence| mode logic. See http://crbug.com/249422
+  // and http://crbug.com/333437.
+  ChunkDemuxer::AppendMode append_mode_;
+
   TimeDelta append_window_start_;
   TimeDelta append_window_end_;
 
   // Set to true if the next buffers appended within the append window
   // represent the start of a new media segment. This flag being set
   // triggers a call to |new_segment_cb_| when the new buffers are
   // appended. The flag is set on actual media segment boundaries and
   // when the "append window" filtering causes discontinuities in the
   // appended data.
   bool new_media_segment_;
 
-  // Keeps track of whether |timestamp_offset_| can be modified.
-  bool can_update_offset_;
+  // Keeps track of whether |timestamp_offset_| or |append_mode_| can be
+  // set. These cannot be set if media segment is currently being parsed.
+  bool parsing_media_segment_;
 
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;
   bool audio_needs_keyframe_;
 
   ChunkDemuxerStream* video_;
   bool video_needs_keyframe_;
 
@@ skipping 106 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          const LogCB& log_cb,
                          const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                          const IncreaseDurationCB& increase_duration_cb)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       increase_duration_cb_(increase_duration_cb),
+      append_mode_(ChunkDemuxer::kSegments),
       append_window_end_(kInfiniteDuration()),
       new_media_segment_(false),
-      can_update_offset_(true),
+      parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       audio_needs_keyframe_(true),
       video_(NULL),
       video_needs_keyframe_(true),
       log_cb_(log_cb) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(!increase_duration_cb_.is_null());
 }
 
@@ skipping 27 matching lines @@
                        new_text_buffers_cb,
                        need_key_cb,
                        base::Bind(&SourceState::OnNewMediaSegment,
                                   base::Unretained(this)),
                        base::Bind(&SourceState::OnEndOfMediaSegment,
                                   base::Unretained(this)),
                        log_cb_);
 }
 
 bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
-  if (!can_update_offset_)
+  if (parsing_media_segment_)
     return false;
 
   timestamp_offset_ = timestamp_offset;
   return true;
 }
 
+bool SourceState::SetAppendMode(ChunkDemuxer::AppendMode mode) {
+  if (parsing_media_segment_)
+    return false;
+
+  append_mode_ = mode;
+  return true;
+}
+
+
 bool SourceState::Append(const uint8* data, size_t length) {
   return stream_parser_->Parse(data, length);
 }
 
 void SourceState::Abort() {
   stream_parser_->Flush();
   audio_needs_keyframe_ = true;
   video_needs_keyframe_ = true;
-  can_update_offset_ = true;
+  parsing_media_segment_ = false;
 }
 
 void SourceState::Remove(TimeDelta start, TimeDelta end, TimeDelta duration) {
   if (audio_)
     audio_->Remove(start, end, duration);
 
   if (video_)
     video_->Remove(start, end, duration);
 
   for (TextStreamMap::iterator itr = text_stream_map_.begin();
@@ skipping 302 matching lines @@
       }
     }
   }
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   return success;
 }
 
 void SourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
-  can_update_offset_ = false;
+  parsing_media_segment_ = true;
   new_media_segment_ = true;
 }
 
 void SourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
-  can_update_offset_ = true;
+  parsing_media_segment_ = false;
   new_media_segment_ = false;
 }
 
 bool SourceState::OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
                                const StreamParser::BufferQueue& video_buffers) {
   DCHECK(!audio_buffers.empty() || !video_buffers.empty());
   AdjustBufferTimestamps(audio_buffers);
   AdjustBufferTimestamps(video_buffers);
 
   StreamParser::BufferQueue filtered_audio;
@@ skipping 753 matching lines @@
 }
 
 bool ChunkDemuxer::SetTimestampOffset(const std::string& id, TimeDelta offset) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset.InSecondsF() << ")";
   CHECK(IsValidId(id));
 
   return source_state_map_[id]->SetTimestampOffset(offset);
 }
 
+bool ChunkDemuxer::SetAppendMode(const std::string& id, AppendMode mode) {
+  base::AutoLock auto_lock(lock_);
+  DVLOG(1) << "SetAppendMode(" << id << ", " << mode << ")";
+  CHECK(IsValidId(id));
+  DCHECK_NE(state_, ENDED);
+
+  return source_state_map_[id]->SetAppendMode(mode);
+}
+
 void ChunkDemuxer::MarkEndOfStream(PipelineStatus status) {
   DVLOG(1) << "MarkEndOfStream(" << status << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, WAITING_FOR_INIT);
   DCHECK_NE(state_, ENDED);
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return;
 
   if (state_ == INITIALIZING) {
@@ skipping 283 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media