Add status parameter to DemuxerStream::ReadCB

media/filters/chunk_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 "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
@@ skipping 54 matching lines @@
   }
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
   return arg && !arg->IsEndOfStream() &&
       arg->GetTimestamp().InMilliseconds() == timestamp_in_ms;
 }
 
 static void OnReadDone(const base::TimeDelta& expected_time,
                        bool* called,
+                       DemuxerStream::Status status,
                        const scoped_refptr<DecoderBuffer>& buffer) {
+  EXPECT_EQ(status, DemuxerStream::kOk);
   EXPECT_EQ(expected_time, buffer->GetTimestamp());
   *called = true;
 }
 
 static void OnReadDone_EOSExpected(bool* called,
+                                   DemuxerStream::Status status,
                                    const scoped_refptr<DecoderBuffer>& buffer) {
+  EXPECT_EQ(status, DemuxerStream::kOk);
   EXPECT_TRUE(buffer->IsEndOfStream());
   *called = true;
 }
 
 class MockChunkDemuxerClient : public ChunkDemuxerClient {
  public:
   MockChunkDemuxerClient() {}
   virtual ~MockChunkDemuxerClient() {}
 
   MOCK_METHOD1(DemuxerOpened, void(ChunkDemuxer* demuxer));
@@ skipping 418 matching lines @@
     std::stringstream ss;
     ss << "{ ";
     for (size_t i = 0; i < r.size(); ++i) {
       ss << "[" << r.start(i).InMilliseconds() << ","
          << r.end(i).InMilliseconds() << ") ";
     }
     ss << "}";
     EXPECT_EQ(ss.str(), expected);
   }
 
-  MOCK_METHOD1(ReadDone, void(const scoped_refptr<DecoderBuffer>&));
+  MOCK_METHOD2(ReadDone, void(DemuxerStream::Status status,
+                              const scoped_refptr<DecoderBuffer>&));
 
   void ExpectRead(DemuxerStream* stream, int64 timestamp_in_ms) {
-    EXPECT_CALL(*this, ReadDone(HasTimestamp(timestamp_in_ms)));
+    EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk,
+                                HasTimestamp(timestamp_in_ms)));
     stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
                             base::Unretained(this)));
   }
 
   MOCK_METHOD1(Checkpoint, void(int id));
 
   struct BufferTimestamps {
     int video_time_ms;
     int audio_time_ms;
   };
@@ skipping 424 matching lines @@
 
   // Check to see if |audio_read_done_| and |video_read_done_| variables
   // match |expected|.
   void CheckIfReadDonesWereCalled(bool expected) {
     EXPECT_EQ(expected, audio_read_done_);
     EXPECT_EQ(expected, video_read_done_);
   }
 
  private:
   static void OnEndOfStreamReadDone(
-      bool* called, const scoped_refptr<DecoderBuffer>& buffer) {
+      bool* called,
+      DemuxerStream::Status status,
+      const scoped_refptr<DecoderBuffer>& buffer) {
+    EXPECT_EQ(status, DemuxerStream::kOk);
     EXPECT_TRUE(buffer->IsEndOfStream());
     *called = true;
   }
 
   scoped_refptr<Demuxer> demuxer_;
   bool audio_read_done_;
   bool video_read_done_;
 
   DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper);
 };
@@ skipping 807 matching lines @@
 
   GenerateExpectedReads(0, 4, audio, video);
   GenerateExpectedReads(46, 66, 5, audio, video);
 
   EndOfStreamHelper end_of_stream_helper(demuxer_);
   end_of_stream_helper.RequestReads();
   end_of_stream_helper.CheckIfReadDonesWereCalled(true);
 }
 
 }  // namespace media