Fix ChunkDemuxer so appending triggers progress events.

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/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/chunk_demuxer_client.h"
 #include "media/webm/cluster_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::NotNull;
 using ::testing::Return;
+using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
 using ::testing::_;
 
 namespace media {
 
 static const uint8 kTracksHeader[] = {
   0x16, 0x54, 0xAE, 0x6B,  // Tracks ID
   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // tracks(size = 0)
 };
 
@@ skipping 65 matching lines @@
 
 class ChunkDemuxerTest : public testing::Test {
  protected:
   enum CodecsIndex {
     AUDIO,
     VIDEO,
     MAX_CODECS_INDEX
   };
 
   ChunkDemuxerTest()
-      : client_(new MockChunkDemuxerClient()),
+      : buffered_bytes_(0),
+        client_(new MockChunkDemuxerClient()),
         demuxer_(new ChunkDemuxer(client_.get())) {
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInfoTracks(bool has_audio, bool has_video,
                         bool video_content_encoded, scoped_array<uint8>* buffer,
                         int* size) {
@@ skipping 59 matching lines @@
 
   ChunkDemuxer::Status AddId() {
     std::vector<std::string> codecs(2);
     codecs[0] = "vp8";
     codecs[1] = "vorbis";
     return demuxer_->AddId(kSourceId, "video/webm", codecs);
   }
 
   bool AppendData(const uint8* data, size_t length) {
     CHECK(length);
-    EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
+    EXPECT_CALL(host_, SetBufferedBytes(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(SaveArg<0>(&buffered_bytes_));
     EXPECT_CALL(host_, SetNetworkActivity(true))
         .Times(AnyNumber());
     return demuxer_->AppendData(kSourceId, data, length);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length) {
     return AppendDataInPieces(data, length, 7);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
     const uint8* start = data;
     const uint8* end = data + length;
     while (start < end) {
+      int64 old_buffered_bytes = buffered_bytes_;
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       if (!AppendData(start, append_size))
         return false;
       start += append_size;
+
+      EXPECT_GT(buffered_bytes_, old_buffered_bytes);
     }
     return true;
   }
 
   bool AppendInfoTracks(bool has_audio, bool has_video,
                         bool video_content_encoded) {
     scoped_array<uint8> info_tracks;
     int info_tracks_size = 0;
     CreateInfoTracks(has_audio, has_video, video_content_encoded,
                      &info_tracks, &info_tracks_size);
@@ skipping 185 matching lines @@
                                &video_read_done));
 
         EXPECT_TRUE(video_read_done);
       }
     }
 
     return true;
   }
 
   MockDemuxerHost host_;
+  int64 buffered_bytes_;
 
   scoped_ptr<MockChunkDemuxerClient> client_;
   scoped_refptr<ChunkDemuxer> demuxer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
   // Test no streams, audio-only, video-only, and audio & video scenarios,
@@ skipping 646 matching lines @@
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
 
   ASSERT_TRUE(AppendInfoTracks(true, true, false));
 }
 
 }  // namespace media