MSE: Plumb ChunkDemuxer appendData failures into append Error algorithm

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 "media/filters/chunk_demuxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 455 matching lines @@
     codecs.push_back("avc1.640028");
     ChunkDemuxer::Status status = demuxer_->AddId(source_id, type, codecs);
     if (status == ChunkDemuxer::kOk)
       demuxer_->SetTracksWatcher(
           source_id, base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                 base::Unretained(this)));
     return status;
   }
 #endif
 
-  void AppendData(const uint8_t* data, size_t length) {
-    AppendData(kSourceId, data, length);
+  bool AppendData(const uint8_t* data, size_t length) {
+    return AppendData(kSourceId, data, length);
   }
 
-  void AppendCluster(const std::string& source_id,
+  bool AppendCluster(const std::string& source_id,
                      std::unique_ptr<Cluster> cluster) {
-    AppendData(source_id, cluster->data(), cluster->size());
+    return AppendData(source_id, cluster->data(), cluster->size());
   }
 
-  void AppendCluster(std::unique_ptr<Cluster> cluster) {
-    AppendCluster(kSourceId, std::move(cluster));
+  bool AppendCluster(std::unique_ptr<Cluster> cluster) {
+    return AppendCluster(kSourceId, std::move(cluster));
   }
 
-  void AppendCluster(int timecode, int block_count) {
-    AppendCluster(GenerateCluster(timecode, block_count));
+  bool AppendCluster(int timecode, int block_count) {
+    return AppendCluster(GenerateCluster(timecode, block_count));
   }
 
   void AppendSingleStreamCluster(const std::string& source_id, int track_number,
                                  int timecode, int block_count) {
     int block_duration = 0;
     switch (track_number) {
       case kVideoTrackNum:
       case kAlternateVideoTrackNum:
         block_duration = kVideoBlockDuration;
         break;
       case kAudioTrackNum:
       case kAlternateAudioTrackNum:
         block_duration = kAudioBlockDuration;
         break;
       case kTextTrackNum:  // Fall-through.
       case kAlternateTextTrackNum:
         block_duration = kTextBlockDuration;
         break;
     }
     ASSERT_NE(block_duration, 0);
     int end_timecode = timecode + block_count * block_duration;
-    AppendCluster(source_id,
-                  GenerateSingleStreamCluster(
-                      timecode, end_timecode, track_number, block_duration));
+    ASSERT_TRUE(AppendCluster(
+        source_id, GenerateSingleStreamCluster(timecode, end_timecode,
+                                               track_number, block_duration)));
   }
 
   struct BlockInfo {
     BlockInfo()
         : track_number(0),
           timestamp_in_ms(0),
           flags(0),
           duration(0) {
     }
 
@@ skipping 118 matching lines @@
     return GenerateCluster(blocks, unknown_size);
   }
 
   // |block_descriptions| - The block descriptions used to construct the
   // cluster. See the documentation for ParseBlockDescriptions() for details on
   // the string format.
   void AppendSingleStreamCluster(const std::string& source_id, int track_number,
                                  const std::string& block_descriptions) {
     std::vector<BlockInfo> blocks;
     ParseBlockDescriptions(track_number, block_descriptions, &blocks);
-    AppendCluster(source_id, GenerateCluster(blocks, false));
+    ASSERT_TRUE(AppendCluster(source_id, GenerateCluster(blocks, false)));
   }
 
   struct MuxedStreamInfo {
     MuxedStreamInfo()
         : track_number(0),
           block_descriptions(""),
           last_blocks_estimated_duration(-1) {}
 
     MuxedStreamInfo(int track_num, const char* block_desc)
         : track_number(track_num),
@@ skipping 50 matching lines @@
 
       if (msi[i].last_blocks_estimated_duration != -1) {
         EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
             msi[i].last_blocks_estimated_duration));
       }
     }
     return GenerateCluster(block_queue, false);
   }
 
   void AppendMuxedCluster(const std::vector<MuxedStreamInfo> msi) {
-    AppendCluster(kSourceId, GenerateMuxedCluster(msi));
+    ASSERT_TRUE(AppendCluster(kSourceId, GenerateMuxedCluster(msi)));
   }
 
-  void AppendData(const std::string& source_id,
+  bool AppendData(const std::string& source_id,
                   const uint8_t* data,
                   size_t length) {
     EXPECT_CALL(host_, OnBufferedTimeRangesChanged(_)).Times(AnyNumber());
 
-    demuxer_->AppendData(
+    return demuxer_->AppendData(
         source_id, data, length, append_window_start_for_next_append_,
         append_window_end_for_next_append_, &timestamp_offset_map_[source_id]);
   }
 
-  void AppendDataInPieces(const uint8_t* data, size_t length) {
-    AppendDataInPieces(data, length, 7);
+  bool AppendDataInPieces(const uint8_t* data, size_t length) {
+    return AppendDataInPieces(data, length, 7);
   }
 
-  void AppendDataInPieces(const uint8_t* data,
+  bool AppendDataInPieces(const uint8_t* data,
                           size_t length,
                           size_t piece_size) {
     const uint8_t* start = data;
     const uint8_t* end = data + length;
     while (start < end) {
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
-      AppendData(start, append_size);
+      if (!AppendData(start, append_size))
+        return false;
       start += append_size;
     }
+    return true;
   }
 
-  void AppendInitSegment(int stream_flags) {
-    AppendInitSegmentWithSourceId(kSourceId, stream_flags);
+  bool AppendInitSegment(int stream_flags) {
+    return AppendInitSegmentWithSourceId(kSourceId, stream_flags);
   }
 
-  void AppendInitSegmentWithSourceId(const std::string& source_id,
+  bool AppendInitSegmentWithSourceId(const std::string& source_id,
                                      int stream_flags) {
-    AppendInitSegmentWithEncryptedInfo(source_id, stream_flags, false, false);
+    return AppendInitSegmentWithEncryptedInfo(source_id, stream_flags, false,
+                                              false);
   }
 
-  void AppendInitSegmentWithEncryptedInfo(const std::string& source_id,
+  bool AppendInitSegmentWithEncryptedInfo(const std::string& source_id,
                                           int stream_flags,
                                           bool is_audio_encrypted,
                                           bool is_video_encrypted) {
     std::unique_ptr<uint8_t[]> info_tracks;
     int info_tracks_size = 0;
     CreateInitSegment(stream_flags,
                       is_audio_encrypted, is_video_encrypted,
                       &info_tracks, &info_tracks_size);
-    AppendData(source_id, info_tracks.get(), info_tracks_size);
+    return AppendData(source_id, info_tracks.get(), info_tracks_size);
   }
 
   void AppendGarbage() {
     // Fill up an array with gibberish.
     int garbage_cluster_size = 10;
     std::unique_ptr<uint8_t[]> garbage_cluster(
         new uint8_t[garbage_cluster_size]);
     for (int i = 0; i < garbage_cluster_size; ++i)
       garbage_cluster[i] = i;
-    AppendData(garbage_cluster.get(), garbage_cluster_size);
+    ASSERT_FALSE(AppendData(garbage_cluster.get(), garbage_cluster_size));
   }
 
   void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
   }
 
   PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
                                     PipelineStatus expected_status) {
     if (expected_duration != kNoTimestamp())
@@ skipping 69 matching lines @@
       // OnNewConfigs() requires at least one audio, video, or text track.
       EXPECT_MEDIA_LOG(StreamParsingFailed());
     }
 
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(expected_duration, expected_status), true);
 
     if (AddId(kSourceId, stream_flags) != ChunkDemuxer::kOk)
       return false;
 
-    AppendInitSegmentWithEncryptedInfo(
-        kSourceId, stream_flags,
-        is_audio_encrypted, is_video_encrypted);
-    return true;
+    return AppendInitSegmentWithEncryptedInfo(
+        kSourceId, stream_flags, is_audio_encrypted, is_video_encrypted);
   }
 
   bool InitDemuxerAudioAndVideoSourcesText(const std::string& audio_id,
                                            const std::string& video_id,
                                            bool has_text) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
     if (AddId(audio_id, HAS_AUDIO) != ChunkDemuxer::kOk)
       return false;
     if (AddId(video_id, HAS_VIDEO) != ChunkDemuxer::kOk)
       return false;
 
     int audio_flags = HAS_AUDIO;
     int video_flags = HAS_VIDEO;
 
     if (has_text) {
       audio_flags |= HAS_TEXT;
       video_flags |= HAS_TEXT;
     }
 
     // Note: Unlike InitDemuxerWithEncryptionInfo, this method is currently
     // incompatible with InSequence tests. Refactoring of the duration
     // set expectation to not be added during CreateInitDoneCB() could fix this.
     ExpectInitMediaLogs(audio_flags);
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-    AppendInitSegmentWithSourceId(audio_id, audio_flags);
+    EXPECT_TRUE(AppendInitSegmentWithSourceId(audio_id, audio_flags));
 
     ExpectInitMediaLogs(video_flags);
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-    AppendInitSegmentWithSourceId(video_id, video_flags);
+    EXPECT_TRUE(AppendInitSegmentWithSourceId(video_id, video_flags));
     return true;
   }
 
   bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
                                        const std::string& video_id) {
     return InitDemuxerAudioAndVideoSourcesText(audio_id, video_id, false);
   }
 
   // Initializes the demuxer with data from 2 files with different
   // decoder configurations. This is used to test the decoder config change
@@ skipping 27 matching lines @@
                                  PIPELINE_OK), true);
 
     if (AddId(kSourceId, HAS_AUDIO | HAS_VIDEO) != ChunkDemuxer::kOk)
       return false;
 
     // Append the whole bear1 file.
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2)).Times(7);
     // Expect duration adjustment since actual duration differs slightly from
     // duration in the init segment.
     EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2746)));
-    AppendData(bear1->data(), bear1->data_size());
+    EXPECT_TRUE(AppendData(bear1->data(), bear1->data_size()));
     // Last audio frame has timestamp 2721 and duration 24 (estimated from max
     // seen so far for audio track).
     // Last video frame has timestamp 2703 and duration 33 (from TrackEntry
     // DefaultDuration for video track).
     CheckExpectedRanges("{ [0,2736) }");
 
     // Append initialization segment for bear2.
     // Note: Offsets here and below are derived from
     // media/test/data/bear-640x360-manifest.js and
     // media/test/data/bear-320x240-manifest.js which were
     // generated from media/test/data/bear-640x360.webm and
     // media/test/data/bear-320x240.webm respectively.
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-    AppendData(bear2->data(), 4340);
+    EXPECT_TRUE(AppendData(bear2->data(), 4340));
 
     // Append a media segment that goes from [0.527000, 1.014000).
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
     EXPECT_MEDIA_LOG(GeneratedSplice(20000, 527000));
-    AppendData(bear2->data() + 55290, 18785);
+    EXPECT_TRUE(AppendData(bear2->data() + 55290, 18785));
     CheckExpectedRanges("{ [0,1027) [1201,2736) }");
 
     // Append initialization segment for bear1 & fill gap with [779-1197)
     // segment.
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-    AppendData(bear1->data(), 4370);
+    EXPECT_TRUE(AppendData(bear1->data(), 4370));
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
     EXPECT_MEDIA_LOG(GeneratedSplice(26000, 779000));
-    AppendData(bear1->data() + 72737, 28183);
+    EXPECT_TRUE(AppendData(bear1->data() + 72737, 28183));
     CheckExpectedRanges("{ [0,2736) }");
 
     MarkEndOfStream(PIPELINE_OK);
     return true;
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       demuxer_->Shutdown();
       message_loop_.RunUntilIdle();
@@ skipping 326 matching lines @@
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(duration, PIPELINE_OK), true);
 
     if (AddId(kSourceId, stream_flags) != ChunkDemuxer::kOk)
       return false;
 
     // Read a WebM file into memory and send the data to the demuxer.
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-    AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
+    EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 
     // Verify that the timestamps on the first few packets match what we
     // expect.
     for (size_t i = 0;
          (timestamps[i].audio_time_ms != kSkip ||
           timestamps[i].video_time_ms != kSkip);
          i++) {
       bool audio_read_done = false;
       bool video_read_done = false;
 
@@ skipping 97 matching lines @@
 
     CreateNewDemuxer();
 
     int stream_flags = 0;
     if (has_audio)
       stream_flags |= HAS_AUDIO;
 
     if (has_video)
       stream_flags |= HAS_VIDEO;
 
-    ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
-        stream_flags, is_audio_encrypted, is_video_encrypted));
+    if (has_audio || has_video) {
+      ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
+          stream_flags, is_audio_encrypted, is_video_encrypted));
+    } else {
+      ASSERT_FALSE(InitDemuxerWithEncryptionInfo(
+          stream_flags, is_audio_encrypted, is_video_encrypted));
+    }
 
     DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
     if (has_audio) {
       ASSERT_TRUE(audio_stream);
 
       const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
       EXPECT_EQ(kCodecVorbis, config.codec());
       EXPECT_EQ(32, config.bits_per_channel());
       EXPECT_EQ(CHANNEL_LAYOUT_STEREO, config.channel_layout());
       EXPECT_EQ(44100, config.samples_per_second());
@@ skipping 114 matching lines @@
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30),
                      MuxedStreamInfo(kTextTrackNum, "10K"));
   CheckExpectedRanges("{ [0,46) }");
 
   std::unique_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
   CreateInitSegment(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO | USE_ALTERNATE_TEXT_TRACK_ID, false,
       false, &info_tracks, &info_tracks_size);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size,
-                       append_window_start_for_next_append_,
-                       append_window_end_for_next_append_,
-                       &timestamp_offset_map_[kSourceId]);
+  ASSERT_TRUE(demuxer_->AppendData(
+      kSourceId, info_tracks.get(), info_tracks_size,
+      append_window_start_for_next_append_, append_window_end_for_next_append_,
+      &timestamp_offset_map_[kSourceId]));
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "46K 69K", 23),
       MuxedStreamInfo(kVideoTrackNum, "60K",
                       WebMClusterParser::kDefaultVideoBufferDurationInMs),
       MuxedStreamInfo(kAlternateTextTrackNum, "45K"));
 
   CheckExpectedRanges("{ [0,92) }");
   CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
   CheckExpectedBuffers(video_stream, "0K 30 60K");
@@ skipping 12 matching lines @@
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30));
   CheckExpectedRanges("{ [0,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegment(HAS_AUDIO | HAS_VIDEO | USE_ALTERNATE_AUDIO_TRACK_ID |
-                    USE_ALTERNATE_VIDEO_TRACK_ID);
+  ASSERT_TRUE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO |
+                                USE_ALTERNATE_AUDIO_TRACK_ID |
+                                USE_ALTERNATE_VIDEO_TRACK_ID));
   AppendMuxedCluster(MuxedStreamInfo(kAlternateAudioTrackNum, "46K 69K", 63),
                      MuxedStreamInfo(kAlternateVideoTrackNum, "60K", 23));
   CheckExpectedRanges("{ [0,92) }");
   CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
   CheckExpectedBuffers(video_stream, "0K 30 60K");
 
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
@@ skipping 14 matching lines @@
   ASSERT_TRUE(audio_stream && video_stream && text_stream);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "23K",
                       WebMClusterParser::kDefaultAudioBufferDurationInMs),
       MuxedStreamInfo(kVideoTrackNum, "0 30K", 30),
       MuxedStreamInfo(kTextTrackNum, "25K 40K"));
   CheckExpectedRanges("{ [23,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO);
+  ASSERT_TRUE(AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "46K 69K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "60 90K", 30),
                      MuxedStreamInfo(kTextTrackNum, "80K 90K"));
   CheckExpectedRanges("{ [23,92) }");
 
   CheckExpectedBuffers(audio_stream, "23K 46K 69K");
   CheckExpectedBuffers(video_stream, "30K 90K");
   CheckExpectedBuffers(text_stream, "25K 40K 80K 90K");
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   EXPECT_EQ(AddId("audio", HAS_AUDIO), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video", HAS_VIDEO), ChunkDemuxer::kOk);
 
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegmentWithSourceId("audio", HAS_AUDIO);
+  ASSERT_TRUE(AppendInitSegmentWithSourceId("audio", HAS_AUDIO));
 
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppendedText) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   EXPECT_EQ(AddId("audio", HAS_AUDIO), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video_and_text", HAS_VIDEO), ChunkDemuxer::kOk);
 
   EXPECT_CALL(host_, AddTextStream(_, _))
       .Times(Exactly(1));
 
   ExpectInitMediaLogs(HAS_VIDEO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegmentWithSourceId("video_and_text", HAS_VIDEO | HAS_TEXT);
+  ASSERT_TRUE(
+      AppendInitSegmentWithSourceId("video_and_text", HAS_VIDEO | HAS_TEXT));
 
   ShutdownDemuxer();
 }
 
 // Verifies that all streams waiting for data receive an end of stream
 // buffer when Shutdown() is called.
 TEST_F(ChunkDemuxerTest, Shutdown_EndOfStreamWhileWaitingForData) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
@@ skipping 18 matching lines @@
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
   EXPECT_TRUE(text_read_done);
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
 TEST_F(ChunkDemuxerTest, AppendDataAfterSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   InSequence s;
 
   EXPECT_CALL(*this, Checkpoint(1));
 
   Seek(base::TimeDelta::FromMilliseconds(46));
 
   EXPECT_CALL(*this, Checkpoint(2));
 
   Checkpoint(1);
 
-  AppendCluster(kDefaultSecondCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
 
   message_loop_.RunUntilIdle();
 
   Checkpoint(2);
 }
 
 // Test that parsing errors are handled for clusters appended after init.
 TEST_F(ChunkDemuxerTest, ErrorWhileParsingClusterAfterInit) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   EXPECT_CALL(host_, OnDemuxerError(CHUNK_DEMUXER_ERROR_APPEND_FAILED));
   AppendGarbage();
 }
 
 // Test the case where a Seek() is requested while the parser
 // is in the middle of cluster. This is to verify that the parser
 // does not reset itself on a seek.
 TEST_F(ChunkDemuxerTest, SeekWhileParsingCluster) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   InSequence s;
 
   std::unique_ptr<Cluster> cluster_a(GenerateCluster(0, 6));
 
   // Split the cluster into two appends at an arbitrary point near the end.
   int first_append_size = cluster_a->size() - 11;
   int second_append_size = cluster_a->size() - first_append_size;
 
   // Append the first part of the cluster.
-  AppendData(cluster_a->data(), first_append_size);
+  ASSERT_TRUE(AppendData(cluster_a->data(), first_append_size));
 
   ExpectRead(DemuxerStream::AUDIO, 0);
   ExpectRead(DemuxerStream::VIDEO, 0);
   ExpectRead(DemuxerStream::AUDIO, kAudioBlockDuration);
 
   Seek(base::TimeDelta::FromSeconds(5));
 
   // Append the rest of the cluster.
-  AppendData(cluster_a->data() + first_append_size, second_append_size);
+  ASSERT_TRUE(
+      AppendData(cluster_a->data() + first_append_size, second_append_size));
 
   // Append the new cluster and verify that only the blocks
   // in the new cluster are returned.
-  AppendCluster(GenerateCluster(5000, 6));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(5000, 6)));
   GenerateExpectedReads(5000, 6);
 }
 
 // Test the case where AppendData() is called before Init().
 TEST_F(ChunkDemuxerTest, AppendDataBeforeInit) {
   std::unique_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
   CreateInitSegment(HAS_AUDIO | HAS_VIDEO,
                     false, false, &info_tracks, &info_tracks_size);
-  demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size,
-                       append_window_start_for_next_append_,
-                       append_window_end_for_next_append_,
-                       &timestamp_offset_map_[kSourceId]);
+  ASSERT_FALSE(demuxer_->AppendData(
+      kSourceId, info_tracks.get(), info_tracks_size,
+      append_window_start_for_next_append_, append_window_end_for_next_append_,
+      &timestamp_offset_map_[kSourceId]));
 }
 
 // Make sure Read() callbacks are dispatched with the proper data.
 TEST_F(ChunkDemuxerTest, Read) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, OutOfOrderClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
   EXPECT_MEDIA_LOG(GeneratedSplice(13000, 10000));
-  AppendCluster(GenerateCluster(10, 4));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(10, 4)));
 
   // Make sure that AppendCluster() does not fail with a cluster that has
   // overlaps with the previously appended cluster.
   EXPECT_MEDIA_LOG(SkippingSpliceAlreadySpliced(0));
-  AppendCluster(GenerateCluster(5, 4));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(5, 4)));
 
   // Verify that AppendData() can still accept more data.
   std::unique_ptr<Cluster> cluster_c(GenerateCluster(45, 2));
   EXPECT_MEDIA_LOG(GeneratedSplice(6000, 45000));
-  demuxer_->AppendData(kSourceId, cluster_c->data(), cluster_c->size(),
-                       append_window_start_for_next_append_,
-                       append_window_end_for_next_append_,
-                       &timestamp_offset_map_[kSourceId]);
+  ASSERT_TRUE(demuxer_->AppendData(
+      kSourceId, cluster_c->data(), cluster_c->size(),
+      append_window_start_for_next_append_, append_window_end_for_next_append_,
+      &timestamp_offset_map_[kSourceId]));
 }
 
 TEST_F(ChunkDemuxerTest, NonMonotonicButAboveClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   ClusterBuilder cb;
 
   // Test the case where block timecodes are not monotonically
   // increasing but stay above the cluster timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   AddSimpleBlock(&cb, kAudioTrackNum, 7);
   AddSimpleBlock(&cb, kVideoTrackNum, 15);
 
   EXPECT_MEDIA_LOG(WebMOutOfOrderTimecode());
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   EXPECT_CALL(host_, OnDemuxerError(CHUNK_DEMUXER_ERROR_APPEND_FAILED));
-  AppendCluster(cb.Finish());
+  ASSERT_FALSE(AppendCluster(cb.Finish()));
 
   // Verify that AppendData() ignores data after the error.
   std::unique_ptr<Cluster> cluster_b(GenerateCluster(20, 2));
-  demuxer_->AppendData(kSourceId, cluster_b->data(), cluster_b->size(),
-                       append_window_start_for_next_append_,
-                       append_window_end_for_next_append_,
-                       &timestamp_offset_map_[kSourceId]);
+  ASSERT_FALSE(demuxer_->AppendData(
+      kSourceId, cluster_b->data(), cluster_b->size(),
+      append_window_start_for_next_append_, append_window_end_for_next_append_,
+      &timestamp_offset_map_[kSourceId]));
 }
 
 TEST_F(ChunkDemuxerTest, BackwardsAndBeforeClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   ClusterBuilder cb;
 
   // Test timecodes going backwards and including values less than the cluster
   // timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 3);
   AddSimpleBlock(&cb, kVideoTrackNum, 3);
 
   EXPECT_MEDIA_LOG(WebMNegativeTimecodeOffset("-2"));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   EXPECT_CALL(host_, OnDemuxerError(CHUNK_DEMUXER_ERROR_APPEND_FAILED));
-  AppendCluster(cb.Finish());
+  ASSERT_FALSE(AppendCluster(cb.Finish()));
 
   // Verify that AppendData() ignores data after the error.
   std::unique_ptr<Cluster> cluster_b(GenerateCluster(6, 2));
-  demuxer_->AppendData(kSourceId, cluster_b->data(), cluster_b->size(),
-                       append_window_start_for_next_append_,
-                       append_window_end_for_next_append_,
-                       &timestamp_offset_map_[kSourceId]);
+  ASSERT_FALSE(demuxer_->AppendData(
+      kSourceId, cluster_b->data(), cluster_b->size(),
+      append_window_start_for_next_append_, append_window_end_for_next_append_,
+      &timestamp_offset_map_[kSourceId]));
 }
 
 
 TEST_F(ChunkDemuxerTest, PerStreamMonotonicallyIncreasingTimestamps) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   ClusterBuilder cb;
 
   // Test monotonic increasing timestamps on a per stream
   // basis.
   cb.SetClusterTimecode(4);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 4);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
 
   EXPECT_MEDIA_LOG(WebMOutOfOrderTimecode());
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   EXPECT_CALL(host_, OnDemuxerError(CHUNK_DEMUXER_ERROR_APPEND_FAILED));
-  AppendCluster(cb.Finish());
+  ASSERT_FALSE(AppendCluster(cb.Finish()));
 }
 
 // Test the case where a cluster is passed to AppendCluster() before
 // INFO & TRACKS data.
 TEST_F(ChunkDemuxerTest, ClusterBeforeInitSegment) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(CHUNK_DEMUXER_ERROR_APPEND_FAILED), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   EXPECT_MEDIA_LOG(WebMClusterBeforeFirstInfo());
   EXPECT_MEDIA_LOG(StreamParsingFailed());
-  AppendCluster(GenerateCluster(0, 1));
+  ASSERT_FALSE(AppendCluster(GenerateCluster(0, 1)));
 }
 
 // Test cases where we get an MarkEndOfStream() call during initialization.
 TEST_F(ChunkDemuxerTest, EOSDuringInit) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
   MarkEndOfStream(PIPELINE_OK);
 }
 
@@ skipping 16 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   CheckExpectedRanges("{ }");
   MarkEndOfStream(PIPELINE_OK);
   CheckExpectedRanges("{ }");
 }
 
 TEST_F(ChunkDemuxerTest, DecodeErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
   CheckExpectedRanges(kDefaultFirstClusterRange);
 
   EXPECT_CALL(host_,
               OnDemuxerError(CHUNK_DEMUXER_ERROR_EOS_STATUS_DECODE_ERROR));
   MarkEndOfStream(CHUNK_DEMUXER_ERROR_EOS_STATUS_DECODE_ERROR);
   CheckExpectedRanges(kDefaultFirstClusterRange);
 }
 
 TEST_F(ChunkDemuxerTest, NetworkErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
   CheckExpectedRanges(kDefaultFirstClusterRange);
 
   EXPECT_CALL(host_,
               OnDemuxerError(CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR));
   MarkEndOfStream(CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR);
 }
 
 // Helper class to reduce duplicate code when testing end of stream
 // Read() behavior.
 class EndOfStreamHelper {
@@ skipping 40 matching lines @@
   bool video_read_done_;
 
   DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper);
 };
 
 // Make sure that all pending reads that we don't have media data for get an
 // "end of stream" buffer when MarkEndOfStream() is called.
 TEST_F(ChunkDemuxerTest, EndOfStreamWithPendingReads) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(GenerateCluster(0, 2));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 2)));
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
   EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
   EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
 
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done_1));
   ReadVideo(base::Bind(&OnReadDone,
@@ skipping 14 matching lines @@
 
   end_of_stream_helper_2.RequestReads();
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 }
 
 // Make sure that all Read() calls after we get an MarkEndOfStream()
 // call return an "end of stream" buffer.
 TEST_F(ChunkDemuxerTest, ReadsAfterEndOfStream) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(GenerateCluster(0, 2));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 2)));
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
   EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
   EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
   EndOfStreamHelper end_of_stream_helper_3(demuxer_.get());
 
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done_1));
@@ skipping 18 matching lines @@
   end_of_stream_helper_2.RequestReads();
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 
   end_of_stream_helper_3.RequestReads();
   end_of_stream_helper_3.CheckIfReadDonesWereCalled(true);
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamDuringCanceledSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(0, 10);
+  ASSERT_TRUE(AppendCluster(0, 10));
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(138)));
   MarkEndOfStream(PIPELINE_OK);
 
   // Start the first seek.
   Seek(base::TimeDelta::FromMilliseconds(20));
 
   // Simulate another seek being requested before the first
   // seek has finished prerolling.
   base::TimeDelta seek_time2 = base::TimeDelta::FromMilliseconds(30);
   demuxer_->CancelPendingSeek(seek_time2);
@@ skipping 78 matching lines @@
   dst += info_tracks_size;
 
   memcpy(dst, cluster_a->data(), cluster_a->size());
   dst += cluster_a->size();
 
   memcpy(dst, cluster_b->data(), cluster_b->size());
   dst += cluster_b->size();
 
   ExpectInitMediaLogs(HAS_AUDIO | HAS_VIDEO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendDataInPieces(buffer.get(), buffer_size);
+  ASSERT_TRUE(AppendDataInPieces(buffer.get(), buffer_size));
 
   GenerateExpectedReads(0, 9);
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_AudioAndVideo) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {67, 6},
     {100, 9},
@@ skipping 111 matching lines @@
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
 
   // Make sure the reads haven't completed yet.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Append data one byte at a time until one or both reads complete.
   int i = 0;
   for (; i < cluster->size() && !(audio_read_done || video_read_done); ++i) {
-    AppendData(cluster->data() + i, 1);
+    ASSERT_TRUE(AppendData(cluster->data() + i, 1));
     message_loop_.RunUntilIdle();
   }
 
   EXPECT_TRUE(audio_read_done || video_read_done);
   EXPECT_GT(i, 0);
   EXPECT_LT(i, cluster->size());
 
   audio_read_done = false;
   video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(23),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(33),
                        &video_read_done));
 
   // Make sure the reads haven't completed yet.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Append the remaining data.
   ASSERT_LT(i, cluster->size());
-  AppendData(cluster->data() + i, cluster->size() - i);
+  ASSERT_TRUE(AppendData(cluster->data() + i, cluster->size() - i));
 
   message_loop_.RunUntilIdle();
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, ParseErrorDuringInit) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(kNoTimestamp(), CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   uint8_t tmp = 0;
-  demuxer_->AppendData(kSourceId, &tmp, 1, append_window_start_for_next_append_,
-                       append_window_end_for_next_append_,
-                       &timestamp_offset_map_[kSourceId]);
+  ASSERT_FALSE(demuxer_->AppendData(
+      kSourceId, &tmp, 1, append_window_start_for_next_append_,
+      append_window_end_for_next_append_, &timestamp_offset_map_[kSourceId]));
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithAudioOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(kNoTimestamp(), CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vorbis";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Video track is unexpected per mimetype.
   EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("a video", true));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
-  AppendInitSegment(HAS_AUDIO | HAS_VIDEO);
+  ASSERT_FALSE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithVideoOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(kNoTimestamp(), CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Audio track is unexpected per mimetype.
   EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("an audio", true));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
-  AppendInitSegment(HAS_AUDIO | HAS_VIDEO);
+  ASSERT_FALSE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, AudioOnlyHeaderWithAVType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(kNoTimestamp(), CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
   std::vector<std::string> codecs(2);
   codecs[0] = "vorbis";
   codecs[1] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Video track is also expected per mimetype.
   EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("a video", false));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
-  AppendInitSegment(HAS_AUDIO);
+  ASSERT_FALSE(AppendInitSegment(HAS_AUDIO));
 }
 
 TEST_F(ChunkDemuxerTest, VideoOnlyHeaderWithAVType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(kNoTimestamp(), CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
   std::vector<std::string> codecs(2);
   codecs[0] = "vorbis";
   codecs[1] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Audio track is also expected per mimetype.
   EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("an audio", false));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
-  AppendInitSegment(HAS_VIDEO);
+  ASSERT_FALSE(AppendInitSegment(HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, MultipleHeaders) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   // Append another identical initialization segment.
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegment(HAS_AUDIO | HAS_VIDEO);
+  ASSERT_TRUE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultSecondCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
 
   GenerateExpectedReads(0, 9);
 }
 
 TEST_F(ChunkDemuxerTest, AddSeparateSourcesForAudioAndVideo) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Append audio and video data into separate source ids.
-  AppendCluster(audio_id,
-      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
   GenerateAudioStreamExpectedReads(0, 4);
-  AppendCluster(video_id,
-      GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(video_id,
+                            GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
+                                                        kVideoBlockDuration)));
   GenerateVideoStreamExpectedReads(0, 4);
 }
 
 TEST_F(ChunkDemuxerTest, AddSeparateSourcesForAudioAndVideoText) {
   // TODO(matthewjheaney): Here and elsewhere, we need more tests
   // for inband text tracks (http://crbug/321455).
 
   std::string audio_id = "audio1";
   std::string video_id = "video1";
 
   EXPECT_CALL(host_, AddTextStream(_, _))
     .Times(Exactly(2));
   ASSERT_TRUE(InitDemuxerAudioAndVideoSourcesText(audio_id, video_id, true));
 
   // Append audio and video data into separate source ids.
-  AppendCluster(audio_id,
-      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
   GenerateAudioStreamExpectedReads(0, 4);
-  AppendCluster(video_id,
-      GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(video_id,
+                            GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
+                                                        kVideoBlockDuration)));
   GenerateVideoStreamExpectedReads(0, 4);
 }
 
 TEST_F(ChunkDemuxerTest, AddIdFailures) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   std::string audio_id = "audio1";
   std::string video_id = "video1";
 
   ASSERT_EQ(AddId(audio_id, HAS_AUDIO), ChunkDemuxer::kOk);
 
   // Adding an id with audio/video should fail because we already added audio.
   ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit);
 
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegmentWithSourceId(audio_id, HAS_AUDIO);
+  ASSERT_TRUE(AppendInitSegmentWithSourceId(audio_id, HAS_AUDIO));
 
   // Adding an id after append should fail.
   ASSERT_EQ(AddId(video_id, HAS_VIDEO), ChunkDemuxer::kReachedIdLimit);
 }
 
 // Test that Read() calls after a RemoveId() return "end of stream" buffers.
 TEST_F(ChunkDemuxerTest, RemoveId) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Append audio and video data into separate source ids.
-  AppendCluster(audio_id,
-      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(video_id,
-      GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(video_id,
+                            GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
+                                                        kVideoBlockDuration)));
 
   // Read() from audio should return normal buffers.
   GenerateAudioStreamExpectedReads(0, 4);
 
   // Remove the audio id.
   demuxer_->RemoveId(audio_id);
 
   // Read() from audio should return "end of stream" buffers.
   bool audio_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
@@ skipping 12 matching lines @@
   demuxer_->RemoveId(audio_id_1);
 
   std::string audio_id_2 = "audio2";
   ASSERT_TRUE(AddId(audio_id_2, HAS_AUDIO) == ChunkDemuxer::kOk);
 }
 
 TEST_F(ChunkDemuxerTest, SeekCanceled) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Append cluster at the beginning of the stream.
-  AppendCluster(GenerateCluster(0, 4));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 4)));
 
   // Seek to an unbuffered region.
   Seek(base::TimeDelta::FromSeconds(50));
 
   // Attempt to read in unbuffered area; should not fulfill the read.
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone_AbortExpected, &video_read_done));
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Now cancel the pending seek, which should flush the reads with empty
   // buffers.
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(0);
   demuxer_->CancelPendingSeek(seek_time);
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // A seek back to the buffered region should succeed.
   Seek(seek_time);
   GenerateExpectedReads(0, 4);
 }
 
 TEST_F(ChunkDemuxerTest, SeekCanceledWhileWaitingForSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Append cluster at the beginning of the stream.
-  AppendCluster(GenerateCluster(0, 4));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 4)));
 
   // Start waiting for a seek.
   base::TimeDelta seek_time1 = base::TimeDelta::FromSeconds(50);
   base::TimeDelta seek_time2 = base::TimeDelta::FromSeconds(0);
   demuxer_->StartWaitingForSeek(seek_time1);
 
   // Now cancel the upcoming seek to an unbuffered region.
   demuxer_->CancelPendingSeek(seek_time2);
   demuxer_->Seek(seek_time1, NewExpectedStatusCB(PIPELINE_OK));
 
   // Read requests should be fulfilled with empty buffers.
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone_AbortExpected, &video_read_done));
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // A seek back to the buffered region should succeed.
   Seek(seek_time2);
   GenerateExpectedReads(0, 4);
 }
 
 // Test that Seek() successfully seeks to all source IDs.
 TEST_F(ChunkDemuxerTest, SeekAudioAndVideoSources) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
-  AppendCluster(
+  ASSERT_TRUE(AppendCluster(
       audio_id,
-      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(
-      video_id,
-      GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
+      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(video_id,
+                            GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
+                                                        kVideoBlockDuration)));
 
   // Read() should return buffers at 0.
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // Seek to 3 (an unbuffered region).
   Seek(base::TimeDelta::FromSeconds(3));
 
   audio_read_done = false;
   video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromSeconds(3),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromSeconds(3),
                        &video_read_done));
   // Read()s should not return until after data is appended at the Seek point.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(
-                    3000, 3092, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(
-                    3000, 3132, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(3000, 3092, kAudioTrackNum,
+                                            kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(3000, 3132, kVideoTrackNum,
+                                            kVideoBlockDuration)));
 
   message_loop_.RunUntilIdle();
 
   // Read() should return buffers at 3.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 // Test that Seek() completes successfully when EndOfStream
 // is called before data is available for that seek point.
@@ skipping 68 matching lines @@
 
   message_loop_.RunUntilIdle();
 
   EXPECT_TRUE(seek_cb_was_called);
 
   ShutdownDemuxer();
 }
 
 // Test ranges in an audio-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
-  EXPECT_CALL(*this, DemuxerOpened());
-  demuxer_->Initialize(
-      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
-
-  ASSERT_EQ(AddId(kSourceId, HAS_AUDIO), ChunkDemuxer::kOk);
-  ExpectInitMediaLogs(HAS_AUDIO);
-  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegment(HAS_AUDIO);
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   // Test a simple cluster.
-  AppendCluster(
-      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
 
   CheckExpectedRanges("{ [0,92) }");
 
   // Append a disjoint cluster to check for two separate ranges.
-  AppendCluster(GenerateSingleStreamCluster(
-      150, 219, kAudioTrackNum, kAudioBlockDuration));
+  ASSERT_TRUE(AppendCluster(GenerateSingleStreamCluster(
+      150, 219, kAudioTrackNum, kAudioBlockDuration)));
 
   CheckExpectedRanges("{ [0,92) [150,219) }");
 }
 
 // Test ranges in a video-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) {
-  EXPECT_CALL(*this, DemuxerOpened());
-  demuxer_->Initialize(
-      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
-
-  ASSERT_EQ(AddId(kSourceId, HAS_VIDEO), ChunkDemuxer::kOk);
-  ExpectInitMediaLogs(HAS_VIDEO);
-  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendInitSegment(HAS_VIDEO);
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
 
   // Test a simple cluster.
-  AppendCluster(
-      GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
+                                                        kVideoBlockDuration)));
 
   CheckExpectedRanges("{ [0,132) }");
 
   // Append a disjoint cluster to check for two separate ranges.
-  AppendCluster(GenerateSingleStreamCluster(
-      200, 299, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(GenerateSingleStreamCluster(
+      200, 299, kVideoTrackNum, kVideoBlockDuration)));
 
   CheckExpectedRanges("{ [0,132) [200,299) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_SeparateStreams) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Append audio and video data into separate source ids.
 
   // Audio block: 0 -> 23
   // Video block: 0 -> 33
   // Buffered Range: 0 -> 23
   // Audio block duration is smaller than video block duration,
   // so the buffered ranges should correspond to the audio blocks.
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(0, 23, kAudioTrackNum, 23));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(0, 33, kVideoTrackNum, 33));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(0, 23, kAudioTrackNum, 23)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(0, 33, kVideoTrackNum, 33)));
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) }");
   CheckExpectedRangesForMediaSource("{ [0,23) }");
 
   // Audio blocks: 300 -> 400
   // Video blocks: 320 -> 420
   // Buffered Range: 320 -> 400  (jagged start and end across SourceBuffers)
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(300, 400, kAudioTrackNum, 50));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(320, 420, kVideoTrackNum, 50));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(300, 400, kAudioTrackNum, 50)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(320, 420, kVideoTrackNum, 50)));
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) [300,400) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) [320,420) }");
   CheckExpectedRangesForMediaSource("{ [0,23) [320,400) }");
 
   // Audio block: 520 -> 590
   // Video block: 500 -> 570
   // Buffered Range: 520 -> 570  (jagged start and end across SourceBuffers)
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(520, 590, kAudioTrackNum, 70));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(500, 570, kVideoTrackNum, 70));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(520, 590, kAudioTrackNum, 70)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(500, 570, kVideoTrackNum, 70)));
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) [300,400) [520,590) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) [320,420) [500,570) }");
   CheckExpectedRangesForMediaSource("{ [0,23) [320,400) [520,570) }");
 
   // Audio block: 720 -> 750
   // Video block: 700 -> 770
   // Buffered Range: 720 -> 750  (complete overlap of audio)
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(720, 750, kAudioTrackNum, 30));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(700, 770, kVideoTrackNum, 70));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(720, 750, kAudioTrackNum, 30)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(700, 770, kVideoTrackNum, 70)));
   CheckExpectedRanges(DemuxerStream::AUDIO,
                       "{ [0,23) [300,400) [520,590) [720,750) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [320,420) [500,570) [700,770) }");
   CheckExpectedRangesForMediaSource("{ [0,23) [320,400) [520,570) [720,750) }");
 
   // Audio block: 900 -> 970
   // Video block: 920 -> 950
   // Buffered Range: 920 -> 950  (complete overlap of video)
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30)));
   CheckExpectedRanges(DemuxerStream::AUDIO,
                       "{ [0,23) [300,400) [520,590) [720,750) [900,970) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [320,420) [500,570) [700,770) [920,950) }");
   CheckExpectedRangesForMediaSource(
       "{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
 
   // Appending within buffered range should not affect buffered ranges.
   EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000));
-  AppendCluster(audio_id,
-                GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20));
-  AppendCluster(video_id,
-                GenerateSingleStreamCluster(930, 950, kVideoTrackNum, 20));
+  ASSERT_TRUE(AppendCluster(
+      audio_id, GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20)));
+  ASSERT_TRUE(AppendCluster(
+      video_id, GenerateSingleStreamCluster(930, 950, kVideoTrackNum, 20)));
   CheckExpectedRanges(DemuxerStream::AUDIO,
                       "{ [0,23) [300,400) [520,590) [720,750) [900,970) }");
   CheckExpectedRanges(DemuxerStream::VIDEO,
                       "{ [0,33) [320,420) [500,570) [700,770) [920,950) }");
   CheckExpectedRangesForMediaSource(
       "{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
@@ skipping 155 matching lines @@
   // end timestamp according to the spec. The last audio range gets extended
   // from [200,246) to [200,398) which is why the intersection results in the
   // middle range getting larger AND the new range appearing.
   CheckExpectedRanges("{ [0,46) [200,266) [332,398) }");
 }
 
 TEST_F(ChunkDemuxerTest, DifferentStreamTimecodes) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Create a cluster where the video timecode begins 25ms after the audio.
-  AppendCluster(GenerateCluster(0, 25, 8));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 25, 8)));
 
   Seek(base::TimeDelta::FromSeconds(0));
   GenerateExpectedReads(0, 25, 8);
 
   // Seek to 5 seconds.
   Seek(base::TimeDelta::FromSeconds(5));
 
   // Generate a cluster to fulfill this seek, where audio timecode begins 25ms
   // after the video.
-  AppendCluster(GenerateCluster(5025, 5000, 8));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(5025, 5000, 8)));
   GenerateExpectedReads(5025, 5000, 8);
 }
 
 TEST_F(ChunkDemuxerTest, DifferentStreamTimecodesSeparateSources) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Generate two streams where the video stream starts 5ms after the audio
   // stream and append them.
-  AppendCluster(audio_id, GenerateSingleStreamCluster(
-      25, 4 * kAudioBlockDuration + 25, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(video_id, GenerateSingleStreamCluster(
-      30, 4 * kVideoBlockDuration + 30, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(25, 4 * kAudioBlockDuration + 25,
+                                  kAudioTrackNum, kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(
+      video_id,
+      GenerateSingleStreamCluster(30, 4 * kVideoBlockDuration + 30,
+                                  kVideoTrackNum, kVideoBlockDuration)));
 
   // Both streams should be able to fulfill a seek to 25.
   Seek(base::TimeDelta::FromMilliseconds(25));
   GenerateAudioStreamExpectedReads(25, 4);
   GenerateVideoStreamExpectedReads(30, 4);
 }
 
 TEST_F(ChunkDemuxerTest, DifferentStreamTimecodesOutOfRange) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Generate two streams where the video stream starts 10s after the audio
   // stream and append them.
-  AppendCluster(audio_id, GenerateSingleStreamCluster(0,
-      4 * kAudioBlockDuration + 0, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(video_id, GenerateSingleStreamCluster(10000,
-      4 * kVideoBlockDuration + 10000, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(0, 4 * kAudioBlockDuration + 0,
+                                  kAudioTrackNum, kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(
+      video_id,
+      GenerateSingleStreamCluster(10000, 4 * kVideoBlockDuration + 10000,
+                                  kVideoTrackNum, kVideoBlockDuration)));
 
   // Should not be able to fulfill a seek to 0.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(0);
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  NewExpectedStatusCB(PIPELINE_ERROR_ABORT));
   ExpectRead(DemuxerStream::AUDIO, 0);
   ExpectEndOfStream(DemuxerStream::VIDEO);
 }
 
@@ skipping 46 matching lines @@
 
 TEST_F(ChunkDemuxerTest, EndOfStreamStillSetAfterSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   EXPECT_CALL(host_, SetDuration(_))
       .Times(AnyNumber());
 
   base::TimeDelta kLastAudioTimestamp = base::TimeDelta::FromMilliseconds(92);
   base::TimeDelta kLastVideoTimestamp = base::TimeDelta::FromMilliseconds(99);
 
-  AppendCluster(kDefaultFirstCluster());
-  AppendCluster(kDefaultSecondCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
+  ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
   MarkEndOfStream(PIPELINE_OK);
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
   // Verify that we can read audio & video to the end w/o problems.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastAudioTimestamp, last_timestamp);
 
@@ skipping 23 matching lines @@
   CheckExpectedRanges("video", "{ }");
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
 TEST_F(ChunkDemuxerTest, EndOfStreamDuringSeek) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(0);
   demuxer_->StartWaitingForSeek(seek_time);
 
-  AppendCluster(kDefaultSecondCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultSecondClusterEndTimestamp)));
   MarkEndOfStream(PIPELINE_OK);
 
   demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
 
   GenerateExpectedReads(0, 4);
   GenerateExpectedReads(46, 66, 5);
 
   EndOfStreamHelper end_of_stream_helper(demuxer_.get());
@@ skipping 136 matching lines @@
 
   // Verify that no config change is signalled.
   ExpectRead(DemuxerStream::VIDEO, 801);
   ASSERT_TRUE(video_config_1.Matches(video->video_decoder_config()));
 }
 
 TEST_F(ChunkDemuxerTest, TimestampPositiveOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(SetTimestampOffset(kSourceId, base::TimeDelta::FromSeconds(30)));
-  AppendCluster(GenerateCluster(0, 2));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 2)));
 
   Seek(base::TimeDelta::FromMilliseconds(30000));
 
   GenerateExpectedReads(30000, 2);
 }
 
 TEST_F(ChunkDemuxerTest, TimestampNegativeOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(SetTimestampOffset(kSourceId, base::TimeDelta::FromSeconds(-1)));
-  AppendCluster(GenerateCluster(1000, 2));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(1000, 2)));
 
   GenerateExpectedReads(0, 2);
 }
 
 TEST_F(ChunkDemuxerTest, TimestampOffsetSeparateStreams) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   ASSERT_TRUE(SetTimestampOffset(
       audio_id, base::TimeDelta::FromMilliseconds(-2500)));
   ASSERT_TRUE(SetTimestampOffset(
       video_id, base::TimeDelta::FromMilliseconds(-2500)));
-  AppendCluster(audio_id, GenerateSingleStreamCluster(2500,
-      2500 + kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(video_id, GenerateSingleStreamCluster(2500,
-      2500 + kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(2500, 2500 + kAudioBlockDuration * 4,
+                                  kAudioTrackNum, kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(
+      video_id,
+      GenerateSingleStreamCluster(2500, 2500 + kVideoBlockDuration * 4,
+                                  kVideoTrackNum, kVideoBlockDuration)));
   GenerateAudioStreamExpectedReads(0, 4);
   GenerateVideoStreamExpectedReads(0, 4);
 
   Seek(base::TimeDelta::FromMilliseconds(27300));
 
   ASSERT_TRUE(SetTimestampOffset(
       audio_id, base::TimeDelta::FromMilliseconds(27300)));
   ASSERT_TRUE(SetTimestampOffset(
       video_id, base::TimeDelta::FromMilliseconds(27300)));
-  AppendCluster(audio_id, GenerateSingleStreamCluster(
-      0, kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(video_id, GenerateSingleStreamCluster(
-      0, kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
+  ASSERT_TRUE(AppendCluster(
+      audio_id,
+      GenerateSingleStreamCluster(0, kAudioBlockDuration * 4, kAudioTrackNum,
+                                  kAudioBlockDuration)));
+  ASSERT_TRUE(AppendCluster(
+      video_id,
+      GenerateSingleStreamCluster(0, kVideoBlockDuration * 4, kVideoTrackNum,
+                                  kVideoBlockDuration)));
   GenerateVideoStreamExpectedReads(27300, 4);
   GenerateAudioStreamExpectedReads(27300, 4);
 }
 
 TEST_F(ChunkDemuxerTest, IsParsingMediaSegmentMidMediaSegment) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   std::unique_ptr<Cluster> cluster = GenerateCluster(0, 2);
   // Append only part of the cluster data.
-  AppendData(cluster->data(), cluster->size() - 13);
+  ASSERT_TRUE(AppendData(cluster->data(), cluster->size() - 13));
 
   // Confirm we're in the middle of parsing a media segment.
   ASSERT_TRUE(demuxer_->IsParsingMediaSegment(kSourceId));
 
   demuxer_->ResetParserState(kSourceId,
                              append_window_start_for_next_append_,
                              append_window_end_for_next_append_,
                              &timestamp_offset_map_[kSourceId]);
 
   // After ResetParserState(), parsing should no longer be in the middle of a
@@ skipping 22 matching lines @@
   //        PTS: 126000 (0x0001ec30)  [= 90 kHz-Timestamp: 0:00:01.4000]
   //        DTS: 123910 (0x0001e406)  [= 90 kHz-Timestamp: 0:00:01.3767]
   // Video: last PES:
   //        PTS: 370155 (0x0005a5eb)  [= 90 kHz-Timestamp: 0:00:04.1128]
   //        DTS: 367152 (0x00059a30)  [= 90 kHz-Timestamp: 0:00:04.0794]
   // Audio: last PES:
   //        PTS: 353788 (0x000565fc)  [= 90 kHz-Timestamp: 0:00:03.9309]
 
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("bear-1280x720.ts");
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendData(kSourceId, buffer->data(), buffer->data_size());
+  ASSERT_TRUE(AppendData(kSourceId, buffer->data(), buffer->data_size()));
 
   // Confirm we're in the middle of parsing a media segment.
   ASSERT_TRUE(demuxer_->IsParsingMediaSegment(kSourceId));
 
   // ResetParserState on the Mpeg2 TS parser triggers the emission of the last
   // video buffer which is pending in the stream parser.
   Ranges<base::TimeDelta> range_before_abort =
       demuxer_->GetBufferedRanges(kSourceId);
   demuxer_->ResetParserState(kSourceId,
                              append_window_start_for_next_append_,
@@ skipping 27 matching lines @@
   //        PTS: 126000 (0x0001ec30)  [= 90 kHz-Timestamp: 0:00:01.4000]
   //        DTS: 123910 (0x0001e406)  [= 90 kHz-Timestamp: 0:00:01.3767]
   // Video: last PES:
   //        PTS: 370155 (0x0005a5eb)  [= 90 kHz-Timestamp: 0:00:04.1128]
   //        DTS: 367152 (0x00059a30)  [= 90 kHz-Timestamp: 0:00:04.0794]
   // Audio: last PES:
   //        PTS: 353788 (0x000565fc)  [= 90 kHz-Timestamp: 0:00:03.9309]
 
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("bear-1280x720.ts");
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
-  AppendData(kSourceId, buffer->data(), buffer->data_size());
+  ASSERT_TRUE(AppendData(kSourceId, buffer->data(), buffer->data_size()));
 
   // Confirm we're in the middle of parsing a media segment.
   ASSERT_TRUE(demuxer_->IsParsingMediaSegment(kSourceId));
 
   // Seek to a time corresponding to buffers that will be emitted during the
   // abort.
   Seek(base::TimeDelta::FromMilliseconds(4110));
 
   // ResetParserState on the Mpeg2 TS parser triggers the emission of the last
   // video buffer which is pending in the stream parser.
@@ skipping 72 matching lines @@
   static_assert(arraysize(kBuffer) == arraysize(kExpectedReturnValues),
       "test arrays out of sync");
   static_assert(arraysize(kBuffer) == sizeof(kBuffer),
       "there should be one byte per index");
 
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)).Times(2);
   EXPECT_MEDIA_LOG(GeneratedSplice(22000, 2000));
   for (size_t i = 0; i < sizeof(kBuffer); i++) {
     DVLOG(3) << "Appending and testing index " << i;
-    AppendData(kBuffer + i, 1);
+    ASSERT_TRUE(AppendData(kBuffer + i, 1));
     bool expected_return_value = kExpectedReturnValues[i];
     EXPECT_EQ(expected_return_value,
               demuxer_->IsParsingMediaSegment(kSourceId));
   }
 }
 
 TEST_F(ChunkDemuxerTest, DurationChange) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   const int kStreamDuration = kDefaultDuration().InMilliseconds();
 
   // Add data leading up to the currently set duration.
-  AppendCluster(GenerateCluster(kStreamDuration - kAudioBlockDuration,
-                                kStreamDuration - kVideoBlockDuration,
-                                2));
+  ASSERT_TRUE(
+      AppendCluster(GenerateCluster(kStreamDuration - kAudioBlockDuration,
+                                    kStreamDuration - kVideoBlockDuration, 2)));
 
   CheckExpectedRanges("{ [201191,201224) }");
 
   // Add data beginning at the currently set duration and expect a new duration
   // to be signaled. Note that the last video block will have a higher end
   // timestamp than the last audio block.
   const int kNewStreamDurationVideo = kStreamDuration + kVideoBlockDuration;
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kNewStreamDurationVideo)));
-  AppendCluster(GenerateCluster(kDefaultDuration().InMilliseconds(), 2));
+  ASSERT_TRUE(
+      AppendCluster(GenerateCluster(kDefaultDuration().InMilliseconds(), 2)));
 
   CheckExpectedRanges("{ [201191,201247) }");
 
   // Add more data to the end of each media type. Note that the last audio block
   // will have a higher end timestamp than the last video block.
   const int kFinalStreamDuration = kStreamDuration + kAudioBlockDuration * 3;
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kFinalStreamDuration)));
-  AppendCluster(GenerateCluster(kStreamDuration + kAudioBlockDuration,
-                                kStreamDuration + kVideoBlockDuration,
-                                3));
+  ASSERT_TRUE(
+      AppendCluster(GenerateCluster(kStreamDuration + kAudioBlockDuration,
+                                    kStreamDuration + kVideoBlockDuration, 3)));
 
   // See that the range has increased appropriately (but not to the full
   // duration of 201293, since there is not enough video appended for that).
   CheckExpectedRanges("{ [201191,201290) }");
 }
 
 TEST_F(ChunkDemuxerTest, DurationChangeTimestampOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   ASSERT_TRUE(SetTimestampOffset(kSourceId, kDefaultDuration()));
   EXPECT_CALL(host_, SetDuration(
       kDefaultDuration() + base::TimeDelta::FromMilliseconds(
           kVideoBlockDuration * 2)));
-  AppendCluster(GenerateCluster(0, 4));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 4)));
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamTruncateDuration) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp)));
   MarkEndOfStream(PIPELINE_OK);
 }
 
 
 TEST_F(ChunkDemuxerTest, ZeroLengthAppend) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendData(NULL, 0);
+  ASSERT_TRUE(AppendData(NULL, 0));
 }
 
 TEST_F(ChunkDemuxerTest, AppendAfterEndOfStream) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   EXPECT_CALL(host_, SetDuration(_))
       .Times(AnyNumber());
 
-  AppendCluster(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
   MarkEndOfStream(PIPELINE_OK);
 
   demuxer_->UnmarkEndOfStream();
 
-  AppendCluster(kDefaultSecondCluster());
+  ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
   MarkEndOfStream(PIPELINE_OK);
 }
 
 // Test receiving a Shutdown() call before we get an Initialize()
 // call. This can happen if video element gets destroyed before
 // the pipeline has a chance to initialize the demuxer.
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeInitialize) {
   demuxer_->Shutdown();
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
   message_loop_.RunUntilIdle();
 }
 
 // Verifies that signaling end of stream while stalled at a gap
 // boundary does not trigger end of stream buffers to be returned.
 TEST_F(ChunkDemuxerTest, EndOfStreamWhileWaitingForGapToBeFilled) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(0, 10);
-  AppendCluster(300, 10);
+  ASSERT_TRUE(AppendCluster(0, 10));
+  ASSERT_TRUE(AppendCluster(300, 10));
   CheckExpectedRanges("{ [0,132) [300,432) }");
 
   GenerateExpectedReads(0, 10);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(138),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(138),
                        &video_read_done));
 
   // Verify that the reads didn't complete
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(438)));
   MarkEndOfStream(PIPELINE_OK);
 
   // Verify that the reads still haven't completed.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   demuxer_->UnmarkEndOfStream();
 
-  AppendCluster(138, 22);
+  ASSERT_TRUE(AppendCluster(138, 22));
 
   message_loop_.RunUntilIdle();
 
   CheckExpectedRanges("{ [0,435) }");
 
   // Verify that the reads have completed.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // Read the rest of the buffers.
@@ skipping 22 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Cancel preroll.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(200);
   demuxer_->CancelPendingSeek(seek_time);
 
   // Initiate the seek to the new location.
   Seek(seek_time);
 
   // Append data to satisfy the seek.
-  AppendCluster(seek_time.InMilliseconds(), 10);
+  ASSERT_TRUE(AppendCluster(seek_time.InMilliseconds(), 10));
 }
 
 TEST_F(ChunkDemuxerTest, SetMemoryLimitType) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Set different memory limits for audio and video.
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 5 * kBlockSize + 1);
 
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(1000);
@@ skipping 330 matching lines @@
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(150);
 
   // Read a WebM file into memory and send the data to the demuxer.  The chunk
   // size has been chosen carefully to ensure the preroll buffer used by the
   // partial append window trim must come from a previous Append() call.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
-  AppendDataInPieces(buffer->data(), buffer->data_size(), 128);
+  ASSERT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 128));
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   CheckExpectedBuffers(stream, "50KP 50K 62K 86K 109K 122K 125K 128K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_AudioConfigUpdateRemovesPreroll) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744), PIPELINE_OK),
       true);
   ASSERT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, HAS_AUDIO));
 
   // Set the append window such that the first file is completely before the
   // append window.
   // Expect duration adjustment since actual duration differs slightly from
   // duration in the init segment.
   const base::TimeDelta duration_1 = base::TimeDelta::FromMilliseconds(2746);
   append_window_start_for_next_append_ = duration_1;
 
   // Read a WebM file into memory and append the data.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
-  AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
+  ASSERT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   CheckExpectedRanges("{ }");
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   AudioDecoderConfig config_1 = stream->audio_decoder_config();
 
   // Read a second WebM with a different config in and append the data.
   scoped_refptr<DecoderBuffer> buffer2 =
       ReadTestDataFile("bear-320x240-audio-only-48khz.webm");
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(21));
   EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
   ASSERT_TRUE(SetTimestampOffset(kSourceId, duration_1));
-  AppendDataInPieces(buffer2->data(), buffer2->data_size(), 512);
+  ASSERT_TRUE(AppendDataInPieces(buffer2->data(), buffer2->data_size(), 512));
   CheckExpectedRanges("{ [2746,5519) }");
 
   Seek(duration_1);
   ExpectConfigChanged(DemuxerStream::AUDIO);
   ASSERT_FALSE(config_1.Matches(stream->audio_decoder_config()));
   CheckExpectedBuffers(stream, "2746K 2767K 2789K 2810K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
   DemuxerStream* text_stream = NULL;
@@ skipping 166 matching lines @@
   CheckExpectedBuffers(text_stream, "275K 325K");
 
   // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160K 180K");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 TEST_F(ChunkDemuxerTest, ClusterWithUnknownSize) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(GenerateCluster(0, 0, 4, true));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 0, 4, true)));
   CheckExpectedRanges("{ [0,46) }");
 
   // A new cluster indicates end of the previous cluster with unknown size.
-  AppendCluster(GenerateCluster(46, 66, 5, true));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(46, 66, 5, true)));
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, CuesBetweenClustersWithUnknownSize) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Add two clusters separated by Cues in a single Append() call.
   std::unique_ptr<Cluster> cluster = GenerateCluster(0, 0, 4, true);
   std::vector<uint8_t> data(cluster->data(), cluster->data() + cluster->size());
   data.insert(data.end(), kCuesHeader, kCuesHeader + sizeof(kCuesHeader));
   cluster = GenerateCluster(46, 66, 5, true);
   data.insert(data.end(), cluster->data(), cluster->data() + cluster->size());
-  AppendData(&*data.begin(), data.size());
+  ASSERT_TRUE(AppendData(&*data.begin(), data.size()));
 
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(GenerateCluster(0, 0, 4));
-  AppendData(kCuesHeader, sizeof(kCuesHeader));
-  AppendCluster(GenerateCluster(46, 66, 5));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(0, 0, 4)));
+  ASSERT_TRUE(AppendData(kCuesHeader, sizeof(kCuesHeader)));
+  ASSERT_TRUE(AppendCluster(GenerateCluster(46, 66, 5)));
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, EvictCodedFramesTest) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 15 * kBlockSize);
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
@@ skipping 36 matching lines @@
   // 80 - 10 + 28 = 98).
   // For video stream 150 + 52 = 202. Video limit is 150 bytes. We need to
   // remove at least 6 blocks to stay under limit.
   CheckExpectedBuffers(audio_stream, "40K 80K 120K 160K 200K 240K 280K");
   CheckExpectedBuffers(video_stream, "60K 70 80K 90 100K 110 120K 130 140K");
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioOnly) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("audio"));
-  AppendCluster(GenerateEmptyCluster(0));
+  ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_VideoOnly) {
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
-  AppendCluster(GenerateEmptyCluster(0));
+  ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("audio"));
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, 0, 10);
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingAudioVideoFrames) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("audio or video"));
-  AppendCluster(GenerateEmptyCluster(0));
+  ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_FirstSegmentMissingKeyframe) {
   // Append V:[n n n][n n K]
   // Expect V:           [K]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(2);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0 10 20");
@@ skipping 172 matching lines @@
       found = true;
       break;
     }
     video_start++;
   }
 
   ASSERT_TRUE(found);
   ASSERT_GT(video_start, 0);
   ASSERT_LT(video_start, cluster->size() - 3);
 
-  AppendData(kSourceId, cluster->data(), video_start);
+  ASSERT_TRUE(AppendData(kSourceId, cluster->data(), video_start));
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,30) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ }");
 
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(30));
 
   // Append the remainder of the cluster
-  AppendData(kSourceId, cluster->data() + video_start,
-             cluster->size() - video_start);
+  ASSERT_TRUE(AppendData(kSourceId, cluster->data() + video_start,
+                         cluster->size() - video_start));
 
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,91) }");
   CheckExpectedRanges("{ [30,90) }");
   CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
   CheckExpectedBuffers(video_stream, "71K 81");
 }
 
 }  // namespace media