Fixed up MockFilterHost and MockPipeline to support tasks and callbacks.

I changed the constructor to MockFilterHost to *not* create and initialize filters to allow for testing for conditions where create/initialize would fail.  Also multiple MockFilterHosts can now share a common MockPipeline, which simulates how it is supposed to work.

Finally, updated the VideoRendererBase tests to be deterministic and completely mocked and fixing failing unittests.

BUG=8379

Review URL: http://codereview.chromium.org/39234

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@11085 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 64 insertions, 72 deletions

diff --git a/media/filters/file_data_source_unittest.cc b/media/filters/file_data_source_unittest.cc
index 3eb5262..3bce493 100644
--- a/media/filters/file_data_source_unittest.cc
+++ b/media/filters/file_data_source_unittest.cc
@@ -17,11 +17,13 @@
 #include "media/base/factory.h"
 #include "media/base/filter_host.h"
 #include "media/base/mock_filter_host.h"
+#include "media/base/mock_pipeline.h"
 #include "media/filters/file_data_source.h"
 #include "media/base/mock_media_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using media::FileDataSource;
+using media::FilterFactory;
 using media::FilterFactoryCollection;
 using media::InitializationHelper;
 using media::MediaFormat;
@@ -30,6 +32,7 @@ using media::MockAudioDecoder;
 using media::MockAudioRenderer;
 using media::MockFilterConfig;
 using media::MockFilterHost;
+using media::MockPipeline;
 using media::PipelineImpl;
 
 namespace {
@@ -84,25 +87,34 @@ TEST(FileDataSourceTest, ReadData) {
   std::string url = TestFileURL();
   url_format.SetAsString(MediaFormat::kMimeType, media::mime_type::kURL);
   url_format.SetAsString(MediaFormat::kURL, url);
-  MockFilterHost<FileDataSource, std::string> mock_host(&url_format, url);
 
-  EXPECT_TRUE(mock_host.filter()->GetSize(&size));
+  // Create our data source.
+  scoped_refptr<FilterFactory> factory = FileDataSource::CreateFactory();
+  FileDataSource* filter = factory->Create<FileDataSource>(&url_format);
+  EXPECT_TRUE(filter);
+
+  // Create our mock pipeline and filter host and initialize the data source.
+  MockPipeline pipeline;
+  MockFilterHost<FileDataSource> mock_host(&pipeline, filter);
+  EXPECT_TRUE(filter->Initialize(url));
+
+  EXPECT_TRUE(filter->GetSize(&size));
   EXPECT_EQ(10, size);
 
-  EXPECT_TRUE(mock_host.filter()->GetPosition(&position));
+  EXPECT_TRUE(filter->GetPosition(&position));
   EXPECT_EQ(0, position);
 
-  EXPECT_EQ(10u, mock_host.filter()->Read(ten_bytes, sizeof(ten_bytes)));
+  EXPECT_EQ(10u, filter->Read(ten_bytes, sizeof(ten_bytes)));
   EXPECT_EQ('0', ten_bytes[0]);
   EXPECT_EQ('5', ten_bytes[5]);
   EXPECT_EQ('9', ten_bytes[9]);
-  EXPECT_TRUE(mock_host.filter()->GetPosition(&position));
+  EXPECT_TRUE(filter->GetPosition(&position));
   EXPECT_EQ(10, position);
-  EXPECT_EQ(0u, mock_host.filter()->Read(ten_bytes, sizeof(ten_bytes)));
+  EXPECT_EQ(0u, filter->Read(ten_bytes, sizeof(ten_bytes)));
 
-  EXPECT_TRUE(mock_host.filter()->SetPosition(5));
-  EXPECT_EQ(5u, mock_host.filter()->Read(ten_bytes, sizeof(ten_bytes)));
+  EXPECT_TRUE(filter->SetPosition(5));
+  EXPECT_EQ(5u, filter->Read(ten_bytes, sizeof(ten_bytes)));
   EXPECT_EQ('5', ten_bytes[0]);
-  EXPECT_TRUE(mock_host.filter()->GetPosition(&position));
+  EXPECT_TRUE(filter->GetPosition(&position));
   EXPECT_EQ(10, position);
 }
diff --git a/media/filters/video_renderer_unittest.cc b/media/filters/video_renderer_unittest.cc
index e1f3f49..96c04f1 100644
--- a/media/filters/video_renderer_unittest.cc
+++ b/media/filters/video_renderer_unittest.cc
@@ -2,79 +2,59 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <string>
-
 #include "media/base/factory.h"
-#include "media/base/filter_host.h"
 #include "media/base/filters.h"
-#include "media/base/media_format.h"
 #include "media/base/mock_media_filters.h"
-#include "media/base/pipeline_impl.h"
+#include "media/base/mock_filter_host.h"
 #include "media/filters/test_video_renderer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using media::FilterFactoryCollection;
-using media::InstanceFilterFactory;
-using media::MockAudioDecoder;
-using media::MockAudioRenderer;
-using media::MockDataSource;
-using media::MockDemuxer;
+using media::FilterFactory;
 using media::MockFilterConfig;
+using media::MockFilterHost;
+using media::MockPipeline;
 using media::MockVideoDecoder;
-using media::PipelineImpl;
 using media::TestVideoRenderer;
-using media::VideoFrame;
 
-TEST(VideoRenderer, DISABLED_CreateTestRenderer) {
-  base::TimeDelta test_time = base::TimeDelta::FromMilliseconds(500);
-  std::string url("");
-  PipelineImpl p;
-  scoped_refptr<TestVideoRenderer> test_renderer = new TestVideoRenderer();
+TEST(VideoRenderer, CreateAndPlay) {
+  // Prepare test data.
   MockFilterConfig config;
-  scoped_refptr<FilterFactoryCollection> c = new FilterFactoryCollection();
-  c->AddFactory(MockDataSource::CreateFactory(&config));
-  c->AddFactory(MockDemuxer::CreateFactory(&config));
-  c->AddFactory(MockAudioDecoder::CreateFactory(&config));
-  c->AddFactory(MockAudioRenderer::CreateFactory(&config));
-  c->AddFactory(MockVideoDecoder::CreateFactory(&config));
-  c->AddFactory(new InstanceFilterFactory<TestVideoRenderer>(test_renderer));
-  media::InitializationHelper h;
-  h.Start(&p, c, url);
-  h.Wait();
-  EXPECT_TRUE(p.IsInitialized());
-  p.SetPlaybackRate(1.0f);
-  PlatformThread::Sleep(static_cast<int>(test_time.InMilliseconds()));
-  p.Stop();
-  // Allow a decent amount of variability here.  We expect 15 or 16 frames
-  // but for now make sure it's within a reasonable range.
-  // TODO(ralphl): This test is now DISABLED because sometimes on linux we
-  // only get the first frame.  Investigate why, but for now disabled.
-  int64 num_expected_frames = test_time / config.frame_duration;
-  EXPECT_GT(test_renderer->unique_frames(), num_expected_frames - 3);
-  EXPECT_LT(test_renderer->unique_frames(), num_expected_frames + 3);
-}
+  scoped_refptr<FilterFactory> factory
+      = MockVideoDecoder::CreateFactory(&config);
+  scoped_refptr<MockVideoDecoder> decoder
+      = factory->Create<MockVideoDecoder>(NULL);
+  scoped_refptr<TestVideoRenderer> renderer = new TestVideoRenderer();
 
-TEST(VideoRenderer, SingleVideoFrame) {
-  base::TimeDelta test_time = base::TimeDelta::FromMilliseconds(100);
-  std::string url("");
-  PipelineImpl p;
-  scoped_refptr<TestVideoRenderer> test_renderer = new TestVideoRenderer();
-  MockFilterConfig config;
-  config.media_duration = config.frame_duration;
-  scoped_refptr<FilterFactoryCollection> c = new FilterFactoryCollection();
-  c->AddFactory(MockDataSource::CreateFactory(&config));
-  c->AddFactory(MockDemuxer::CreateFactory(&config));
-  c->AddFactory(MockAudioDecoder::CreateFactory(&config));
-  c->AddFactory(MockAudioRenderer::CreateFactory(&config));
-  c->AddFactory(MockVideoDecoder::CreateFactory(&config));
-  c->AddFactory(new InstanceFilterFactory<TestVideoRenderer>(test_renderer));
-  media::InitializationHelper h;
-  h.Start(&p, c, url);
-  h.TimedWait(base::TimeDelta::FromSeconds(1));
-  EXPECT_TRUE(p.IsInitialized());
-  p.SetPlaybackRate(1.0f);
-  PlatformThread::Sleep(static_cast<int>(test_time.InMilliseconds()));
-  p.Stop();
-  EXPECT_EQ(test_renderer->unique_frames(), 1u);
-  EXPECT_EQ(test_renderer->paint_called(), 1u);
+  // Setup our mock pipeline.
+  MockPipeline pipeline;
+  MockFilterHost<MockVideoDecoder> filter_host_a(&pipeline, decoder);
+  MockFilterHost<TestVideoRenderer> filter_host_b(&pipeline, renderer);
+
+  // Initialize the video renderer and run pending tasks.  It should set its
+  // time update callback and scheduled its first callback time.
+  EXPECT_TRUE(renderer->Initialize(decoder));
+  EXPECT_FALSE(filter_host_b.IsInitialized());
+  pipeline.RunAllTasks();
+  EXPECT_TRUE(filter_host_b.IsInitialized());
+  EXPECT_TRUE(filter_host_b.GetTimeUpdateCallback());
+  EXPECT_NE(0, filter_host_b.GetScheduledCallbackTime().InMicroseconds());
+
+  // We also expect one unique frame due to the preroll paint.
+  EXPECT_EQ(1u, renderer->unique_frames());
+
+  // Now lets simulate playing 10 frames...
+  for (int i = 0; i < 10; ++i) {
+    base::TimeDelta previous_time = filter_host_b.GetScheduledCallbackTime();
+    size_t previous_unique_frames = renderer->unique_frames();
+
+    // Advance time to the callback time and execute.
+    pipeline.SetTime(previous_time);
+    filter_host_b.GetTimeUpdateCallback()->Run(previous_time);
+    pipeline.RunAllTasks();
+
+    // Renderer should have scheduled a new callback time and painted a frame.
+    EXPECT_GT(filter_host_b.GetScheduledCallbackTime().InMicroseconds(),
+              previous_time.InMicroseconds());
+    EXPECT_EQ(previous_unique_frames + 1, renderer->unique_frames());
+  }
 }