Add status parameter to DemuxerStream::ReadCB

media/filters/ffmpeg_demuxer_unittest.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 <algorithm>
 #include <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 21 matching lines @@
 using ::testing::_;
 
 namespace media {
 
 MATCHER(IsEndOfStreamBuffer,
         std::string(negation ? "isn't" : "is") + " end of stream") {
   return arg->IsEndOfStream();
 }
 
 static void EosOnReadDone(bool* got_eos_buffer,
+                          DemuxerStream::Status status,
                           const scoped_refptr<DecoderBuffer>& buffer) {
+  EXPECT_EQ(status, DemuxerStream::kOk);
   if (buffer->IsEndOfStream()) {
     *got_eos_buffer = true;
     EXPECT_TRUE(!buffer->GetData());
     EXPECT_EQ(buffer->GetDataSize(), 0);
     return;
   }
 
   EXPECT_TRUE(buffer->GetData());
   EXPECT_GT(buffer->GetDataSize(), 0);
   *got_eos_buffer = false;
@@ skipping 41 matching lines @@
     message_loop_.RunAllPending();
   }
 
   MOCK_METHOD2(OnReadDoneCalled, void(int, int64));
 
   // Verifies that |buffer| has a specific |size| and |timestamp|.
   // |location| simply indicates where the call to this function was made.
   // This makes it easier to track down where test failures occur.
   void OnReadDone(const tracked_objects::Location& location,
                   int size, int64 timestampInMicroseconds,
+                  DemuxerStream::Status status,
                   const scoped_refptr<DecoderBuffer>& buffer) {
     std::string location_str;
     location.Write(true, false, &location_str);
     location_str += "\n";
     SCOPED_TRACE(location_str);
+    EXPECT_EQ(status, DemuxerStream::kOk);
     OnReadDoneCalled(size, timestampInMicroseconds);
     EXPECT_TRUE(buffer.get() != NULL);
     EXPECT_EQ(size, buffer->GetDataSize());
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(timestampInMicroseconds),
               buffer->GetTimestamp());
   }
 
   DemuxerStream::ReadCB NewReadCB(const tracked_objects::Location& location,
                                   int size, int64 timestampInMicroseconds) {
     EXPECT_CALL(*this, OnReadDoneCalled(size, timestampInMicroseconds));
@@ skipping 285 matching lines @@
   message_loop_.RunAllPending();
 }
 
 // A mocked callback specialization for calling Read().  Since RunWithParams()
 // is mocked we don't need to pass in object or method pointers.
 class MockReadCB : public base::RefCountedThreadSafe<MockReadCB> {
  public:
   MockReadCB() {}
 
   MOCK_METHOD0(OnDelete, void());
-  MOCK_METHOD1(Run, void(const scoped_refptr<DecoderBuffer>& buffer));
+  MOCK_METHOD2(Run, void(DemuxerStream::Status status,
+                         const scoped_refptr<DecoderBuffer>& buffer));
 
  protected:
   virtual ~MockReadCB() {
     OnDelete();
   }
 
  private:
   friend class base::RefCountedThreadSafe<MockReadCB>;
 
   DISALLOW_COPY_AND_ASSIGN(MockReadCB);
@@ skipping 14 matching lines @@
 
   // Expect all calls in sequence.
   InSequence s;
 
   // Create our mocked callback. The Callback created by base::Bind() will take
   // ownership of this pointer.
   StrictMock<MockReadCB>* callback = new StrictMock<MockReadCB>();
 
   // The callback should be immediately deleted.  We'll use a checkpoint to
   // verify that it has indeed been deleted.
-  EXPECT_CALL(*callback, Run(IsEndOfStreamBuffer()));
+  EXPECT_CALL(*callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
   EXPECT_CALL(*callback, OnDelete());
   EXPECT_CALL(*this, CheckPoint(1));
 
   // Attempt the read...
   audio->Read(base::Bind(&MockReadCB::Run, callback));
 
   message_loop_.RunAllPending();
 
   // ...and verify that |callback| was deleted.
   CheckPoint(1);
@@ skipping 19 matching lines @@
 
   // Expect all calls in sequence.
   InSequence s;
 
   // Create our mocked callback. The Callback created by base::Bind() will take
   // ownership of this pointer.
   StrictMock<MockReadCB>* callback = new StrictMock<MockReadCB>();
 
   // The callback should be immediately deleted.  We'll use a checkpoint to
   // verify that it has indeed been deleted.
-  EXPECT_CALL(*callback, Run(IsEndOfStreamBuffer()));
+  EXPECT_CALL(*callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
   EXPECT_CALL(*callback, OnDelete());
   EXPECT_CALL(*this, CheckPoint(1));
 
   // Release the reference to the demuxer. This should also destroy it.
   demuxer_ = NULL;
   // |audio| now has a demuxer_ pointer to invalid memory.
 
   // Attempt the read...
   audio->Read(base::Bind(&MockReadCB::Run, callback));
 
@@ skipping 216 matching lines @@
 TEST_F(FFmpegDemuxerTest, UnsupportedVideoSupportedAudioDemux) {
   CreateDemuxer("vorbis_audio_wmv_video.mkv");
   InitializeDemuxer();
 
   // Ensure the expected streams are present.
   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::VIDEO));
   EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::AUDIO));
 }
 
 }  // namespace media