Remove media::StreamSample::IsDiscontinuous() and friends.

We don't rely on samples identifying themselves as discontinuous and instead have the pipeline force a flush as part of a seek.

BUG=54110
TEST=media_unittests and layout tests

Review URL: http://codereview.chromium.org/4878001

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

7 files changed, 9 insertions, 77 deletions

diff --git a/media/base/buffers.cc b/media/base/buffers.cc
index 5b18ff7..4708726 100644
--- a/media/base/buffers.cc
+++ b/media/base/buffers.cc
@@ -9,11 +9,8 @@ namespace media {
 const base::TimeDelta kNoTimestamp =
     base::TimeDelta::FromMicroseconds(kint64min);
 
-StreamSample::StreamSample()
-    : discontinuous_(false) {
-}
+StreamSample::StreamSample() {}
 
-StreamSample::~StreamSample() {
-}
+StreamSample::~StreamSample() {}
 
 }  // namespace media
diff --git a/media/base/buffers.h b/media/base/buffers.h
index 82667fe..525450d 100644
--- a/media/base/buffers.h
+++ b/media/base/buffers.h
@@ -53,12 +53,6 @@ class StreamSample : public base::RefCountedThreadSafe<StreamSample> {
   // depending on specific data.
   virtual bool IsEndOfStream() const = 0;
 
-  // Indicates that this sample is discontinuous from the previous one, for
-  // example, following a seek.
-  bool IsDiscontinuous() const {
-    return discontinuous_;
-  }
-
   // Sets the timestamp of this buffer in microseconds.
   void SetTimestamp(const base::TimeDelta& timestamp) {
     timestamp_ = timestamp;
@@ -69,11 +63,6 @@ class StreamSample : public base::RefCountedThreadSafe<StreamSample> {
     duration_ = duration;
   }
 
-  // Sets the value returned by IsDiscontinuous().
-  void SetDiscontinuous(bool discontinuous) {
-    discontinuous_ = discontinuous;
-  }
-
  protected:
   friend class base::RefCountedThreadSafe<StreamSample>;
   StreamSample();
@@ -81,7 +70,6 @@ class StreamSample : public base::RefCountedThreadSafe<StreamSample> {
 
   base::TimeDelta timestamp_;
   base::TimeDelta duration_;
-  bool discontinuous_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StreamSample);
diff --git a/media/base/data_buffer_unittest.cc b/media/base/data_buffer_unittest.cc
index 8c870cf..f22e05e 100644
--- a/media/base/data_buffer_unittest.cc
+++ b/media/base/data_buffer_unittest.cc
@@ -23,16 +23,10 @@ TEST(DataBufferTest, StreamSampleImpl) {
   EXPECT_TRUE(kTimestampA == buffer->GetTimestamp());
   EXPECT_TRUE(kDurationA == buffer->GetDuration());
   EXPECT_TRUE(buffer->IsEndOfStream());
-  EXPECT_FALSE(buffer->IsDiscontinuous());
   buffer->SetTimestamp(kTimestampB);
   buffer->SetDuration(kDurationB);
   EXPECT_TRUE(kTimestampB == buffer->GetTimestamp());
   EXPECT_TRUE(kDurationB == buffer->GetDuration());
-
-  buffer->SetDiscontinuous(true);
-  EXPECT_TRUE(buffer->IsDiscontinuous());
-  buffer->SetDiscontinuous(false);
-  EXPECT_FALSE(buffer->IsDiscontinuous());
 }
 
 TEST(DataBufferTest, Constructors) {
diff --git a/media/base/video_frame_unittest.cc b/media/base/video_frame_unittest.cc
index 633ccc0..dac228d 100644
--- a/media/base/video_frame_unittest.cc
+++ b/media/base/video_frame_unittest.cc
@@ -106,7 +106,6 @@ TEST(VideoFrame, CreateFrame) {
   EXPECT_EQ(kDurationA.InMicroseconds(),
             frame->GetDuration().InMicroseconds());
   EXPECT_FALSE(frame->IsEndOfStream());
-  EXPECT_FALSE(frame->IsDiscontinuous());
   frame->SetTimestamp(kTimestampB);
   frame->SetDuration(kDurationB);
   EXPECT_EQ(kTimestampB.InMicroseconds(),
@@ -114,10 +113,6 @@ TEST(VideoFrame, CreateFrame) {
   EXPECT_EQ(kDurationB.InMicroseconds(),
             frame->GetDuration().InMicroseconds());
   EXPECT_FALSE(frame->IsEndOfStream());
-  frame->SetDiscontinuous(true);
-  EXPECT_TRUE(frame->IsDiscontinuous());
-  frame->SetDiscontinuous(false);
-  EXPECT_FALSE(frame->IsDiscontinuous());
 
   // Test VideoFrame implementation.
   EXPECT_EQ(media::VideoFrame::TYPE_SYSTEM_MEMORY, frame->type());
diff --git a/media/filters/decoder_base.h b/media/filters/decoder_base.h
index 355bb06..e4cdaeb 100644
--- a/media/filters/decoder_base.h
+++ b/media/filters/decoder_base.h
@@ -67,7 +67,6 @@ class DecoderBase : public Decoder {
   DecoderBase()
       : pending_reads_(0),
         pending_requests_(0),
-        expecting_discontinuous_(false),
         state_(kUninitialized) {
   }
 
@@ -176,22 +175,13 @@ class DecoderBase : public Decoder {
     DCHECK_EQ(0u, pending_requests_) << "Pending requests should be empty";
 
     // Delegate to the subclass first.
-    //
-    // TODO(scherkus): if we have the strong assertion that there are no pending
-    // reads in the entire pipeline when we receive Seek(), subclasses could
-    // either flush their buffers here or wait for IsDiscontinuous().  I'm
-    // inclined to say that they should still wait for IsDiscontinuous() so they
-    // don't have duplicated logic for Seek() and actual discontinuous frames.
     DoSeek(time,
            NewRunnableMethod(this, &DecoderBase::OnSeekComplete, callback));
   }
 
   void OnSeekComplete(FilterCallback* callback) {
-    // Flush our decoded results.  We'll set a boolean that we can DCHECK to
-    // verify our assertion that the first buffer received after a Seek() should
-    // always be discontinuous.
+    // Flush our decoded results.
     result_queue_.clear();
-    expecting_discontinuous_ = true;
 
     // Signal that we're done seeking.
     if (callback) {
@@ -257,13 +247,6 @@ class DecoderBase : public Decoder {
       return;
     }
 
-    // TODO(scherkus): remove this when we're less paranoid about our seeking
-    // invariants.
-    if (buffer->IsDiscontinuous()) {
-      DCHECK(expecting_discontinuous_);
-      expecting_discontinuous_ = false;
-    }
-
     // Decode the frame right away.
     DoDecode(buffer);
   }
@@ -298,9 +281,6 @@ class DecoderBase : public Decoder {
   // Tracks the number of asynchronous reads issued from renderer.
   size_t pending_requests_;
 
-  // A flag used for debugging that we expect our next read to be discontinuous.
-  bool expecting_discontinuous_;
-
   // Pointer to the demuxer stream that will feed us compressed buffers.
   scoped_refptr<DemuxerStream> demuxer_stream_;
 
diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index 116a20d..1ab307e 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -58,7 +58,6 @@ FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
                                          AVStream* stream)
     : demuxer_(demuxer),
       stream_(stream),
-      discontinuous_(false),
       stopped_(false) {
   DCHECK(demuxer_);
 
@@ -141,7 +140,6 @@ void FFmpegDemuxerStream::FlushBuffers() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   DCHECK(read_queue_.empty()) << "Read requests should be empty";
   buffer_queue_.clear();
-  discontinuous_ = true;
 }
 
 void FFmpegDemuxerStream::Stop() {
@@ -194,14 +192,6 @@ void FFmpegDemuxerStream::FulfillPendingRead() {
   buffer_queue_.pop_front();
   read_queue_.pop_front();
 
-  // Handle discontinuities due to FlushBuffers() being called.
-  //
-  // TODO(scherkus): get rid of |discontinuous_| and use buffer flags.
-  if (discontinuous_) {
-    buffer->SetDiscontinuous(true);
-    discontinuous_ = false;
-  }
-
   // Execute the callback.
   read_callback->Run(buffer);
 }
diff --git a/media/filters/ffmpeg_demuxer_unittest.cc b/media/filters/ffmpeg_demuxer_unittest.cc
index 97f16d3..b47b3c8 100644
--- a/media/filters/ffmpeg_demuxer_unittest.cc
+++ b/media/filters/ffmpeg_demuxer_unittest.cc
@@ -334,7 +334,6 @@ TEST_F(FFmpegDemuxerTest, Read_Audio) {
 
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kAudioData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
@@ -366,7 +365,6 @@ TEST_F(FFmpegDemuxerTest, Read_Video) {
 
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
@@ -400,10 +398,8 @@ TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
 }
 
 TEST_F(FFmpegDemuxerTest, Seek) {
-  // We're testing the following:
-  //
-  //   1) The demuxer frees all queued packets when it receives a Seek().
-  //   2) The demuxer queues a single discontinuous packet on every stream.
+  // We're testing that the demuxer frees all queued packets when it receives
+  // a Seek().
   //
   // Since we can't test which packets are being freed, we use check points to
   // infer that the correct packets have been freed.
@@ -485,7 +481,6 @@ TEST_F(FFmpegDemuxerTest, Seek) {
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
@@ -501,48 +496,41 @@ TEST_F(FFmpegDemuxerTest, Seek) {
   message_loop_.RunAllPending();
   MockFFmpeg::get()->CheckPoint(2);
 
-  // The next read from each stream should now be discontinuous, but subsequent
-  // reads should not.
-
-  // Audio read #1, should be discontinuous.
+  // Audio read #1.
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_TRUE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kAudioData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 
-  // Audio read #2, should not be discontinuous.
+  // Audio read #2.
   reader->Reset();
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kAudioData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 
-  // Video read #1, should be discontinuous.
+  // Video read #1.
   reader->Reset();
   reader->Read(video);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_TRUE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));
 
-  // Video read #2, should not be discontinuous.
+  // Video read #2.
   reader->Reset();
   reader->Read(video);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
-  EXPECT_FALSE(reader->buffer()->IsDiscontinuous());
   ASSERT_EQ(kDataSize, reader->buffer()->GetDataSize());
   EXPECT_EQ(0, memcmp(kVideoData, reader->buffer()->GetData(),
                       reader->buffer()->GetDataSize()));