Fix various operations in ChunkDemuxer that were not being applied to text tracks.

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 96 matching lines @@
             const NewTextTrackCB& new_text_track_cb);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred.
   bool Append(const uint8* data, size_t length);
 
   // Aborts the current append sequence and resets the parser.
   void Abort();
 
+  // Calls Remove(|start|, |end|, |duration|) on all
+  // ChunkDemuxerStreams managed by this object.
+  void Remove(base::TimeDelta start, base::TimeDelta end,
+              base::TimeDelta duration);

[xhwang, 2013/12/28 01:06:03]

Here and in this file, pass base::TimeDelta by const-ref? I see both patterns in
media/ code. base::TimeDelta is small so this is not a big deal, but we
shouldn't make assumptions on the implementation detail of base::TimeDelta.

[acolwell GONE FROM CHROMIUM, 2013/12/28 02:17:10]

I've talked with scherkus@ and fischman@ about this before and it basically
comes down to the fact that we wouldn't use const& if TimeDelta was 'typedef
int64 TimeDelta' instead of a class. It is only a class because of the
conversion functions and it is unlikely TimeDelta is going to change to a more
complex implementation. I've also tended to use MessageLoop::PostDelayedTask()
and friends as an example of non-const& usage in critical code. We should
probably have a team discussion about this along the lines of the EXPECT_EQ
discussion from before.

For now, I'm just trying to match the style of the rest of this file. I'll
probably s/base::TimeDelta/TimeDelta/ to further blend in though.

[xhwang, 2013/12/30 17:53:38]

sg. thanks for the explanation.

+
   // 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);
 
   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.
   Ranges<TimeDelta> GetBufferedRanges(TimeDelta duration, bool ended) const;
 
+  // Helper methods that call methods with similar names on all the
+  // ChunkDemuxerStreams managed by this object.
   void StartReturningData();
   void AbortReads();
   void Seek(TimeDelta seek_time);
   void CompletePendingReadIfPossible();
+  void OnSetDuration(TimeDelta duration);
+  void MarkEndOfStream();
+  void UnmarkEndOfStream();
+  void Shutdown();
+  void SetMemoryLimitsForTesting(int memory_limit);

[xhwang, 2013/12/28 01:06:03]

Is |memory_limit| in KB or MB?

[acolwell GONE FROM CHROMIUM, 2014/01/08 02:16:49]

It's bytes. I've added a comment clarifying this here and elsewhere.

+  bool IsSeekWaitingForData() const;
 
  private:
   // Called by the |stream_parser_| when a new initialization segment is
   // encountered.
   // Returns true on a successful call. Returns false if an error occured while
   // processing decoder configurations.
   bool OnNewConfigs(bool allow_audio, bool allow_video,
                     const AudioDecoderConfig& audio_config,
                     const VideoDecoderConfig& video_config,
                     const StreamParser::TextTrackConfigMap& text_configs);
@@ skipping 184 matching lines @@
       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());
 }
 
 SourceState::~SourceState() {
-  if (audio_)
-    audio_->Shutdown();
+  Shutdown();
 
-  if (video_)
-    video_->Shutdown();
-
-  for (TextStreamMap::iterator itr = text_stream_map_.begin();
-       itr != text_stream_map_.end(); ++itr) {
-    itr->second->Shutdown();
-    delete itr->second;
-  }
+  STLDeleteValues(&text_stream_map_);
 }
 
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        bool allow_audio,
                        bool allow_video,
                        const StreamParser::NeedKeyCB& need_key_cb,
                        const NewTextTrackCB& new_text_track_cb) {
   new_text_track_cb_ = new_text_track_cb;
 
   StreamParser::NewTextBuffersCB new_text_buffers_cb;
@@ skipping 31 matching lines @@
   return stream_parser_->Parse(data, length);
 }
 
 void SourceState::Abort() {
   stream_parser_->Flush();
   audio_needs_keyframe_ = true;
   video_needs_keyframe_ = true;
   can_update_offset_ = true;
 }
 
+void SourceState::Remove(base::TimeDelta start, base::TimeDelta end,
+                         base::TimeDelta duration) {
+  if (audio_)
+    audio_->Remove(start, end, duration);
+
+  if (video_)
+    video_->Remove(start, end, duration);
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->Remove(start, end, duration);
+  }
+}
+
 Ranges<TimeDelta> SourceState::GetBufferedRanges(TimeDelta duration,
                                                  bool ended) const {
   // TODO(acolwell): When we start allowing disabled tracks we'll need to update
   // this code to only add ranges from active tracks.
   RangesList ranges_list;
   if (audio_)
     ranges_list.push_back(audio_->GetBufferedRanges(duration));
 
   if (video_)
     ranges_list.push_back(video_->GetBufferedRanges(duration));
@@ skipping 52 matching lines @@
 
   if (video_)
     video_->CompletePendingReadIfPossible();
 
   for (TextStreamMap::iterator itr = text_stream_map_.begin();
        itr != text_stream_map_.end(); ++itr) {
     itr->second->CompletePendingReadIfPossible();
   }
 }
 
+void SourceState::OnSetDuration(TimeDelta duration) {
+  if (audio_)
+    audio_->OnSetDuration(duration);
+
+  if (video_)
+    video_->OnSetDuration(duration);
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->OnSetDuration(duration);
+  }
+}
+
+void SourceState::MarkEndOfStream() {
+  if (audio_)
+    audio_->MarkEndOfStream();
+
+  if (video_)
+    video_->MarkEndOfStream();
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->MarkEndOfStream();
+  }
+}
+
+void SourceState::UnmarkEndOfStream() {
+  if (audio_)
+    audio_->UnmarkEndOfStream();
+
+  if (video_)
+    video_->UnmarkEndOfStream();
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->UnmarkEndOfStream();
+  }
+}
+
+void SourceState::Shutdown() {
+  if (audio_)
+    audio_->Shutdown();
+
+  if (video_)
+    video_->Shutdown();
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->Shutdown();
+  }
+}
+
+void SourceState::SetMemoryLimitsForTesting(int memory_limit) {
+  if (audio_)
+    audio_->set_memory_limit_for_testing(memory_limit);
+
+  if (video_)
+    video_->set_memory_limit_for_testing(memory_limit);
+
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->set_memory_limit_for_testing(memory_limit);
+  }
+}
+
+bool SourceState::IsSeekWaitingForData() const {
+  if (audio_ && audio_->IsSeekWaitingForData())
+    return true;
+
+  if (video_ && video_->IsSeekWaitingForData())
+    return true;
+
+  for (TextStreamMap::const_iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    if (itr->second->IsSeekWaitingForData())
+      return true;
+  }
+
+  return false;
+}
+
 void SourceState::AdjustBufferTimestamps(
     const StreamParser::BufferQueue& buffers) {
   if (timestamp_offset_ == TimeDelta())
     return;
 
   for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     (*itr)->SetDecodeTimestamp(
         (*itr)->GetDecodeTimestamp() + timestamp_offset_);
     (*itr)->set_timestamp((*itr)->timestamp() + timestamp_offset_);
@@ skipping 797 matching lines @@
   CHECK(IsValidId(id));
   source_state_map_[id]->Abort();
 }
 
 void ChunkDemuxer::Remove(const std::string& id, base::TimeDelta start,
                           base::TimeDelta end) {
   DVLOG(1) << "Remove(" << id << ", " << start.InSecondsF()
            << ", " << end.InSecondsF() << ")";
   base::AutoLock auto_lock(lock_);
 
-  if (id == source_id_audio_ && audio_)
-    audio_->Remove(start, end, duration_);
-
-  if (id == source_id_video_ && video_)
-    video_->Remove(start, end, duration_);
+  DCHECK(!id.empty());
+  CHECK(IsValidId(id));
+  source_state_map_[id]->Remove(start, end, duration_);
 }
 
 double ChunkDemuxer::GetDuration() {
   base::AutoLock auto_lock(lock_);
   return GetDuration_Locked();
 }
 
 double ChunkDemuxer::GetDuration_Locked() {
   lock_.AssertAcquired();
   if (duration_ == kNoTimestamp())
@@ skipping 37 matching lines @@
     duration_td = TimeDelta::FromMicroseconds(
         duration * base::Time::kMicrosecondsPerSecond);
   }
 
   DCHECK(duration_td > TimeDelta());
 
   user_specified_duration_ = duration;
   duration_ = duration_td;
   host_->SetDuration(duration_);
 
-  if (audio_)
-    audio_->OnSetDuration(duration_);
-
-  if (video_)
-    video_->OnSetDuration(duration_);
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->OnSetDuration(duration_);
+  }
 }
 
 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);
 }
 
 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) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   bool old_waiting_for_data = IsSeekWaitingForData_Locked();
-  if (audio_)
-    audio_->MarkEndOfStream();
-
-  if (video_)
-    video_->MarkEndOfStream();
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->MarkEndOfStream();
+  }
 
   CompletePendingReadsIfPossible();
 
   // Give a chance to resume the pending seek process.
   if (status != PIPELINE_OK) {
     ReportError_Locked(status);
     return;
   }
 
   ChangeState_Locked(ENDED);
   DecreaseDurationIfNecessary();
 
   if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
       !seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   }
 }
 
 void ChunkDemuxer::UnmarkEndOfStream() {
   DVLOG(1) << "UnmarkEndOfStream()";
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, ENDED);
 
   ChangeState_Locked(INITIALIZED);
 
-  if (audio_)
-    audio_->UnmarkEndOfStream();
-
-  if (video_)
-    video_->UnmarkEndOfStream();
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->UnmarkEndOfStream();
+  }
 }
 
 void ChunkDemuxer::SetAppendWindowStart(const std::string& id,
                                         TimeDelta start) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetAppendWindowStart(" << id << ", "
            << start.InSecondsF() << ")";
   CHECK(IsValidId(id));
   source_state_map_[id]->set_append_window_start(start);
 }
 
 void ChunkDemuxer::SetAppendWindowEnd(const std::string& id, TimeDelta end) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetAppendWindowEnd(" << id << ", " << end.InSecondsF() << ")";
   CHECK(IsValidId(id));
   source_state_map_[id]->set_append_window_end(end);
 }
 
 void ChunkDemuxer::Shutdown() {
   DVLOG(1) << "Shutdown()";
   base::AutoLock auto_lock(lock_);
 
   if (state_ == SHUTDOWN)
     return;
 
-  if (audio_)
-    audio_->Shutdown();
-
-  if (video_)
-    video_->Shutdown();
+  ShutdownAllStreams();
 
   ChangeState_Locked(SHUTDOWN);
 
   if(!seek_cb_.is_null())
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_ERROR_ABORT);
 }
 
 void ChunkDemuxer::SetMemoryLimitsForTesting(int memory_limit) {
-  if (audio_)
-    audio_->set_memory_limit_for_testing(memory_limit);
-
-  if (video_)
-    video_->set_memory_limit_for_testing(memory_limit);
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->SetMemoryLimitsForTesting(memory_limit);
+  }
 }
 
 void ChunkDemuxer::ChangeState_Locked(State new_state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxer::ChangeState_Locked() : "
            << state_ << " -> " << new_state;
   state_ = new_state;
 }
 
 ChunkDemuxer::~ChunkDemuxer() {
   DCHECK_NE(state_, INITIALIZED);
-  for (SourceStateMap::iterator it = source_state_map_.begin();
-       it != source_state_map_.end(); ++it) {
-    delete it->second;
-  }
-  source_state_map_.clear();
+
+  STLDeleteValues(&source_state_map_);
 }
 
 void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   DVLOG(1) << "ReportError_Locked(" << error << ")";
   lock_.AssertAcquired();
   DCHECK_NE(error, PIPELINE_OK);
 
   ChangeState_Locked(PARSE_ERROR);
 
   PipelineStatusCB cb;
 
   if (!init_cb_.is_null()) {
     std::swap(cb, init_cb_);
   } else {
     if (!seek_cb_.is_null())
       std::swap(cb, seek_cb_);
 
-    if (audio_)
-      audio_->Shutdown();
-
-    if (video_)
-      video_->Shutdown();
+    ShutdownAllStreams();
   }
 
   if (!cb.is_null()) {
     cb.Run(error);
     return;
   }
 
   base::AutoUnlock auto_unlock(lock_);
   host_->OnDemuxerError(error);
 }
 
 bool ChunkDemuxer::IsSeekWaitingForData_Locked() const {
   lock_.AssertAcquired();
-  bool waiting_for_data = false;
 
-  if (audio_)
-    waiting_for_data = audio_->IsSeekWaitingForData();
+  for (SourceStateMap::const_iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    if (itr->second->IsSeekWaitingForData())
+      return true;
+  }
 
-  if (!waiting_for_data && video_)
-    waiting_for_data = video_->IsSeekWaitingForData();
-
-  return waiting_for_data;
+  return false;
 }
 
 void ChunkDemuxer::OnSourceInitDone(bool success, TimeDelta duration) {
   DVLOG(1) << "OnSourceInitDone(" << success << ", "
            << duration.InSecondsF() << ")";
   lock_.AssertAcquired();
   DCHECK_EQ(state_, INITIALIZING);
   if (!success || (!audio_ && !video_)) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
@@ skipping 132 matching lines @@
   }
 }
 
 void ChunkDemuxer::CompletePendingReadsIfPossible() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->CompletePendingReadIfPossible();
   }
 }
 
+void ChunkDemuxer::ShutdownAllStreams() {
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->Shutdown();
+  }
+}
+
 }  // namespace media