Merge 105121 - Numerous fixes to audio/video buffered resource loading.

media/filters/ffmpeg_demuxer_unittest.cc

 // Copyright (c) 2011 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 <deque>
 
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
@@ skipping 42 matching lines @@
   virtual ~FFmpegDemuxerTest() {
     // Call Stop() to shut down internal threads.
     demuxer_->Stop(NewExpectedCallback());
 
     // Finish up any remaining tasks.
     message_loop_.RunAllPending();
     // Release the reference to the demuxer.
     demuxer_ = NULL;
   }
 
-  scoped_refptr<DataSource> CreateDataSource(const std::string& name) {
+  scoped_refptr<FileDataSource> CreateDataSource(const std::string& name) {
+    return CreateDataSource(name, false);
+  }
+
+  scoped_refptr<FileDataSource> CreateDataSource(const std::string& name,
+                                                 bool disable_file_size) {
     FilePath file_path;
     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
 
     file_path = file_path.Append(FILE_PATH_LITERAL("media"))
         .Append(FILE_PATH_LITERAL("test"))
         .Append(FILE_PATH_LITERAL("data"))
         .AppendASCII(name);
 
-    scoped_refptr<FileDataSource> data_source = new FileDataSource();
+    scoped_refptr<FileDataSource> data_source = new FileDataSource(
+        disable_file_size);
 
     EXPECT_EQ(PIPELINE_OK, data_source->Initialize(file_path.MaybeAsASCII()));
 
     return data_source.get();
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
   // Initializes FFmpegDemuxer.
   void InitializeDemuxer(const scoped_refptr<DataSource>& data_source) {
@@ skipping 11 matching lines @@
     std::string location_str;
     location.Write(true, false, &location_str);
     location_str += "\n";
     SCOPED_TRACE(location_str);
     EXPECT_TRUE(buffer.get() != NULL);
     EXPECT_EQ(size, buffer->GetDataSize());
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(timestampInMicroseconds),
               buffer->GetTimestamp());
   }
 
+  // Creates a data source with the given |file_name|. If |disable_file_size|
+  // then the data source pretends it does not know the file size (e.g. often
+  // when streaming video). Uses this data source to initialize a demuxer, then
+  // returns true if the bitrate is valid, false otherwise.
+  bool VideoHasValidBitrate(
+      const std::string& file_name, bool disable_file_size) {
+    scoped_refptr<FileDataSource> data_source =
+        CreateDataSource(file_name, disable_file_size);
+    InitializeDemuxer(data_source);
+    return demuxer_->GetBitrate() > 0;
+  }
+
   // Fixture members.
   scoped_refptr<FFmpegDemuxer> demuxer_;
   StrictMock<MockFilterHost> host_;
   MessageLoop message_loop_;
 
   int64 current_read_position_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
 };
@@ skipping 377 matching lines @@
 
   // Third read will get an end-of-file error, which is represented as zero.
   EXPECT_EQ(0, demuxer->Read(512, kBuffer));
 
   // This read complete signal is generated when demuxer is stopped.
   EXPECT_CALL(*demuxer, SignalReadCompleted(DataSource::kReadError));
   demuxer->Stop(NewExpectedCallback());
   message_loop_.RunAllPending();
 }
 
+TEST_F(FFmpegDemuxerTest, GetBitrate_SetInContainer) {
+  EXPECT_TRUE(VideoHasValidBitrate("bear.ogv", false));
+}
+
+TEST_F(FFmpegDemuxerTest, GetBitrate_UnsetInContainer_KnownSize) {
+  EXPECT_TRUE(VideoHasValidBitrate("bear-320x240.webm", false));
+}
+
+TEST_F(FFmpegDemuxerTest, GetBitrate_SetInContainer_NoFileSize) {
+  EXPECT_TRUE(VideoHasValidBitrate("bear.ogv", true));
+}
+
+TEST_F(FFmpegDemuxerTest, GetBitrate_UnsetInContainer_NoFileSize) {
+  EXPECT_FALSE(VideoHasValidBitrate("bear-320x240.webm", true));
+}
+
 TEST_F(FFmpegDemuxerTest, ProtocolGetSetPosition) {
   scoped_refptr<DataSource> data_source = CreateDataSource("bear-320x240.webm");
   InitializeDemuxer(data_source);
 
   InSequence s;
 
   int64 size;
   int64 position;
   EXPECT_TRUE(demuxer_->GetSize(&size));
   EXPECT_TRUE(demuxer_->GetPosition(&position));
@@ skipping 21 matching lines @@
 
 TEST_F(FFmpegDemuxerTest, ProtocolIsStreaming) {
   scoped_refptr<DataSource> data_source = CreateDataSource("bear-320x240.webm");
   InitializeDemuxer(data_source);
 
   EXPECT_FALSE(data_source->IsStreaming());
   EXPECT_FALSE(demuxer_->IsStreaming());
 }
 
 }  // namespace media