Remove start time logic since the Media Source spec now states the start time must always be 0.

BUG=144240


Review URL: https://chromiumcodereview.appspot.com/10877022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@152832 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 41 insertions, 108 deletions

diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index ab9778d..99e53c2 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -153,7 +153,7 @@ class MockVideoRenderer : public VideoRenderer {
   MOCK_METHOD2(Preroll, void(base::TimeDelta time, const PipelineStatusCB& cb));
   MOCK_METHOD1(Stop, void(const base::Closure& callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
-  MOCK_METHOD0(PrepareForShutdownHack, void());
+  virtual void PrepareForShutdownHack() {}
 
  protected:
   virtual ~MockVideoRenderer();
diff --git a/media/filters/chunk_demuxer.cc b/media/filters/chunk_demuxer.cc
index c22d0c2..6322f5a 100644
--- a/media/filters/chunk_demuxer.cc
+++ b/media/filters/chunk_demuxer.cc
@@ -188,9 +188,6 @@ class ChunkDemuxerStream : public DemuxerStream {
   // Append() belong to a media segment that starts at |start_timestamp|.
   void OnNewMediaSegment(TimeDelta start_timestamp);
 
-  // Notifies the stream that it begins at |start_time|.
-  void SetStartTime(TimeDelta start_time);
-
   // 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.
@@ -316,11 +313,6 @@ void ChunkDemuxerStream::OnNewMediaSegment(TimeDelta start_timestamp) {
   stream_->OnNewMediaSegment(start_timestamp);
 }
 
-void ChunkDemuxerStream::SetStartTime(TimeDelta start_time) {
-  base::AutoLock auto_lock(lock_);
-  stream_->SetStartTime(start_time);
-}
-
 bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
   if (buffers.empty())
     return false;
@@ -532,8 +524,7 @@ bool ChunkDemuxerStream::GetNextBuffer_Locked(
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
-      client_(client),
-      start_time_(kNoTimestamp()) {
+      client_(client) {
   DCHECK(client);
 }
 
@@ -559,7 +550,7 @@ void ChunkDemuxer::Stop(const base::Closure& callback) {
 
 void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
   DVLOG(1) << "Seek(" << time.InSecondsF() << ")";
-  DCHECK(time >= start_time_);
+  DCHECK(time >= TimeDelta());
   DCHECK(seek_cb_.is_null());
 
   PipelineStatus status = PIPELINE_ERROR_INVALID_STATE;
@@ -604,9 +595,7 @@ scoped_refptr<DemuxerStream> ChunkDemuxer::GetStream(
 }
 
 TimeDelta ChunkDemuxer::GetStartTime() const {
-  DCHECK(start_time_ != kNoTimestamp());
-  DVLOG(1) << "GetStartTime(): " << start_time_.InSecondsF();
-  return start_time_;
+  return TimeDelta();
 }
 
 void ChunkDemuxer::StartWaitingForSeek() {
@@ -786,7 +775,6 @@ bool ChunkDemuxer::AppendData(const std::string& id,
 
     switch (state_) {
       case INITIALIZING:
-      case WAITING_FOR_START_TIME:
         DCHECK(IsValidId(id));
         if (!stream_parser_map_[id]->Parse(data, length)) {
           ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
@@ -991,7 +979,19 @@ void ChunkDemuxer::OnStreamParserInitDone(bool success, TimeDelta duration) {
       (!source_id_video_.empty() && !video_))
     return;
 
-  ChangeState_Locked(WAITING_FOR_START_TIME);
+  if (audio_)
+    audio_->Seek(TimeDelta());
+
+  if (video_)
+    video_->Seek(TimeDelta());
+
+  if (duration_ == TimeDelta())
+    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,
@@ -1082,6 +1082,7 @@ bool ChunkDemuxer::OnNeedKey(scoped_array<uint8> init_data,
 
 void ChunkDemuxer::OnNewMediaSegment(const std::string& source_id,
                                      TimeDelta timestamp) {
+  DCHECK(timestamp != kNoTimestamp());
   DVLOG(2) << "OnNewMediaSegment(" << source_id << ", "
            << timestamp.InSecondsF() << ")";
   lock_.AssertAcquired();
@@ -1091,43 +1092,10 @@ void ChunkDemuxer::OnNewMediaSegment(const std::string& source_id,
   base::TimeDelta start_timestamp =
       timestamp + source_info_map_[source_id].timestamp_offset;
 
-  if (start_time_ == kNoTimestamp()) {
-    DCHECK(state_ == INITIALIZING || state_ == WAITING_FOR_START_TIME);
-    // Use the first reported media segment start time as the |start_time_|
-    // for the demuxer.
-    start_time_ = start_timestamp;
-
-    // Ensure |duration_| is never before |start_time_|.
-    // TODO(vrk): We have to do this because there are places in the code that
-    // assumes the media duration is the same as the end time of the media
-    // stream. Fix this once crbug.com/137275 is addressed.
-    if (start_time_ > duration_)
-      UpdateDuration(start_time_);
-  }
-
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
-
-  if (state_ != WAITING_FOR_START_TIME)
-    return;
-
-  if (audio_) {
-    audio_->SetStartTime(start_time_);
-    audio_->Seek(start_time_);
-  }
-  if (video_) {
-    video_->SetStartTime(start_time_);
-    video_->Seek(start_time_);
-  }
-
-  if (duration_ == base::TimeDelta())
-    duration_ = kInfiniteDuration();
-
-  // The demuxer is now initialized after the |start_timestamp_| was set.
-  ChangeState_Locked(INITIALIZED);
-  base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void ChunkDemuxer::OnEndOfMediaSegment(const std::string& source_id) {
diff --git a/media/filters/chunk_demuxer.h b/media/filters/chunk_demuxer.h
index bb29461..08a504e 100644
--- a/media/filters/chunk_demuxer.h
+++ b/media/filters/chunk_demuxer.h
@@ -93,7 +93,6 @@ class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
   enum State {
     WAITING_FOR_INIT,
     INITIALIZING,
-    WAITING_FOR_START_TIME,
     INITIALIZED,
     ENDED,
     PARSE_ERROR,
@@ -183,8 +182,6 @@ class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
   std::string source_id_audio_;
   std::string source_id_video_;
 
-  base::TimeDelta start_time_;
-
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxer);
 };
 
diff --git a/media/filters/chunk_demuxer_unittest.cc b/media/filters/chunk_demuxer_unittest.cc
index c1cec58..bad1223 100644
--- a/media/filters/chunk_demuxer_unittest.cc
+++ b/media/filters/chunk_demuxer_unittest.cc
@@ -359,18 +359,6 @@ class ChunkDemuxerTest : public testing::Test {
     return success;
   }
 
-  bool InitDemuxer_ExpectInitFailure() {
-    EXPECT_CALL(*client_, DemuxerOpened(_));
-    demuxer_->Initialize(
-        &host_, CreateInitDoneCB(
-            kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
-
-    if (AddId(kSourceId, true, true) != ChunkDemuxer::kOk)
-      return false;
-
-    return AppendInitSegment(true, true, false);
-  }
-
   // Initializes the demuxer with data from 2 files with different
   // decoder configurations. This is used to test the decoder config change
   // logic.
@@ -748,10 +736,18 @@ TEST_F(ChunkDemuxerTest, TestInit) {
   }
 }
 
-// Makes sure that pipeline reports an error if Shutdown()
-// is called before the first cluster is passed to the demuxer.
-TEST_F(ChunkDemuxerTest, TestShutdownBeforeFirstCluster) {
-  ASSERT_TRUE(InitDemuxer_ExpectInitFailure());
+// Make sure that the demuxer reports an error if Shutdown()
+// is called before all the initialization segments are appended.
+TEST_F(ChunkDemuxerTest, TestShutdownBeforeAllInitSegmentsAppended) {
+  EXPECT_CALL(*client_, DemuxerOpened(_));
+  demuxer_->Initialize(
+      &host_, CreateInitDoneCB(
+          kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
+
+  EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
+  EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
+
+  EXPECT_TRUE(AppendInitSegment("audio", true, false, false));
 }
 
 // Test that Seek() completes successfully when the first cluster
@@ -779,14 +775,6 @@ TEST_F(ChunkDemuxerTest, TestAppendDataAfterSeek) {
   Checkpoint(2);
 }
 
-// Test that parsing errors are handled for clusters appended before init
-// completes.
-TEST_F(ChunkDemuxerTest, TestErrorWhileParsingClusterBeforeInitCompletes) {
-  ASSERT_TRUE(InitDemuxer_ExpectInitFailure());
-
-  ASSERT_TRUE(AppendGarbage());
-}
-
 // Test that parsing errors are handled for clusters appended after init.
 TEST_F(ChunkDemuxerTest, TestErrorWhileParsingClusterAfterInit) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
@@ -1361,12 +1349,10 @@ TEST_F(ChunkDemuxerTest, TestParseErrorDuringInit) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
-          kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
+          kNoTimestamp(), DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
-  ASSERT_TRUE(AppendInitSegment(true, true, false));
-
   uint8 tmp = 0;
   ASSERT_TRUE(demuxer_->AppendData(kSourceId, &tmp, 1));
 }
@@ -2187,6 +2173,10 @@ TEST_F(ChunkDemuxerTest, TestTimestampPositiveOffset) {
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
+  demuxer_->StartWaitingForSeek();
+  demuxer_->Seek(base::TimeDelta::FromMilliseconds(30000),
+                 NewExpectedStatusCB(PIPELINE_OK));
+
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
diff --git a/media/filters/source_buffer_stream.cc b/media/filters/source_buffer_stream.cc
index f66cdb9..b05c55e8 100644
--- a/media/filters/source_buffer_stream.cc
+++ b/media/filters/source_buffer_stream.cc
@@ -270,7 +270,6 @@ namespace media {
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config)
     : current_config_index_(0),
       append_config_index_(0),
-      stream_start_time_(kNoTimestamp()),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
@@ -289,7 +288,6 @@ SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config)
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config)
     : current_config_index_(0),
       append_config_index_(0),
-      stream_start_time_(kNoTimestamp()),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
@@ -326,15 +324,6 @@ void SourceBufferStream::OnNewMediaSegment(
   last_buffer_timestamp_ = kNoTimestamp();
 }
 
-void SourceBufferStream::SetStartTime(base::TimeDelta stream_start_time) {
-  DCHECK(stream_start_time_ == kNoTimestamp());
-  DCHECK(stream_start_time != kNoTimestamp());
-  stream_start_time_ = stream_start_time;
-
-  DCHECK(ranges_.empty() ||
-         ranges_.front()->GetStartTimestamp() >= stream_start_time_);
-}
-
 bool SourceBufferStream::Append(
     const SourceBufferStream::BufferQueue& buffers) {
   DCHECK(!buffers.empty());
@@ -352,9 +341,9 @@ bool SourceBufferStream::Append(
     return false;
   }
 
-  if (stream_start_time_ != kNoTimestamp() &&
-      media_segment_start_time_ < stream_start_time_) {
-    DVLOG(1) << "Cannot append a media segment before the start of stream.";
+  if (media_segment_start_time_ < base::TimeDelta() ||
+      buffers.front()->GetDecodeTimestamp() < base::TimeDelta()) {
+    DVLOG(1) << "Cannot append a media segment with negative timestamps.";
     return false;
   }
 
@@ -432,9 +421,8 @@ bool SourceBufferStream::ShouldSeekToStartOfBuffered(
     return false;
   base::TimeDelta beginning_of_buffered =
       ranges_.front()->GetStartTimestamp();
-  base::TimeDelta start_time_delta = beginning_of_buffered - stream_start_time_;
-  return seek_timestamp <= beginning_of_buffered &&
-      start_time_delta < kSeekToStartFudgeRoom();
+  return (seek_timestamp <= beginning_of_buffered &&
+          beginning_of_buffered < kSeekToStartFudgeRoom());
 }
 
 bool SourceBufferStream::IsMonotonicallyIncreasing(
@@ -732,8 +720,7 @@ void SourceBufferStream::MergeWithAdjacentRangeIfNecessary(
 }
 
 void SourceBufferStream::Seek(base::TimeDelta timestamp) {
-  DCHECK(stream_start_time_ != kNoTimestamp());
-  DCHECK(timestamp >= stream_start_time_);
+  DCHECK(timestamp >= base::TimeDelta());
   SetSelectedRange(NULL);
   track_buffer_.clear();
   config_change_pending_ = false;
diff --git a/media/filters/source_buffer_stream.h b/media/filters/source_buffer_stream.h
index 0e08327..78ba800 100644
--- a/media/filters/source_buffer_stream.h
+++ b/media/filters/source_buffer_stream.h
@@ -51,9 +51,6 @@ class MEDIA_EXPORT SourceBufferStream {
   // starting at |media_segment_start_time|.
   void OnNewMediaSegment(base::TimeDelta media_segment_start_time);
 
-  // Sets the start time of the stream.
-  void SetStartTime(base::TimeDelta stream_start_time);
-
   // Add the |buffers| to the SourceBufferStream. Buffers within the queue are
   // expected to be in order, but multiple calls to Append() may add buffers out
   // of order or overlapping. Assumes all buffers within |buffers| are in
@@ -223,9 +220,6 @@ class MEDIA_EXPORT SourceBufferStream {
   std::vector<AudioDecoderConfig*> audio_configs_;
   std::vector<VideoDecoderConfig*> video_configs_;
 
-  // The starting time of the stream.
-  base::TimeDelta stream_start_time_;
-
   // True if more data needs to be appended before the Seek() can complete,
   // false if no Seek() has been requested or the Seek() is completed.
   bool seek_pending_;
diff --git a/media/filters/source_buffer_stream_unittest.cc b/media/filters/source_buffer_stream_unittest.cc
index 1f46d0f..0512aea 100644
--- a/media/filters/source_buffer_stream_unittest.cc
+++ b/media/filters/source_buffer_stream_unittest.cc
@@ -25,9 +25,6 @@ class SourceBufferStreamTest : public testing::Test {
                        kCodedSize, NULL, 0, false);
     stream_.reset(new SourceBufferStream(config_));
     SetStreamInfo(kDefaultFramesPerSecond, kDefaultKeyframesPerSecond);
-
-    // Set start time to the beginning of the stream.
-    stream_->SetStartTime(base::TimeDelta());
   }
 
   void SetMemoryLimit(int buffers_of_data) {