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, 72 insertions, 34 deletions

diff --git a/media/base/mock_filter_host.h b/media/base/mock_filter_host.h
index 490587f..3af36ac 100644
--- a/media/base/mock_filter_host.h
+++ b/media/base/mock_filter_host.h
@@ -2,6 +2,11 @@
 // source code is governed by a BSD-style license that can be found in the
 // LICENSE file.
 
+// The corresponding FilterHost implementation for MockPipeline.  Maintains a
+// reference to the parent MockPipeline and a reference to the Filter its
+// hosting.  Common usage is to check if the hosted filter has initialized by
+// calling IsInitialized().
+
 #ifndef MEDIA_BASE_MOCK_FILTER_HOST_H_
 #define MEDIA_BASE_MOCK_FILTER_HOST_H_
 
@@ -16,85 +21,93 @@
 
 namespace media {
 
-template <class Filter, class Source>
+template <class Filter>
 class MockFilterHost : public FilterHost {
  public:
-  MockFilterHost(const MediaFormat* media_format, Source source) {
-    scoped_refptr<FilterFactory> factory = Filter::CreateFactory();
-    filter_ = factory->Create<Filter>(media_format);
-    EXPECT_TRUE(filter_.get());
-    if (filter_.get()) {
-      filter_->SetFilterHost(this);
-      filter_->Initialize(source);
-    }
+  MockFilterHost(MockPipeline* mock_pipeline, Filter* filter)
+      : mock_pipeline_(mock_pipeline),
+        filter_(filter),
+        initialized_(false) {
+    EXPECT_TRUE(mock_pipeline_);
+    EXPECT_TRUE(filter_);
+    filter_->SetFilterHost(this);
   }
 
-  virtual ~MockFilterHost() {
-    filter_->Stop();
-  }
+  virtual ~MockFilterHost() {}
 
   virtual const PipelineStatus* GetPipelineStatus() const {
-    return &mock_pipeline_;
+    return mock_pipeline_;
   }
 
   virtual void SetTimeUpdateCallback(Callback1<base::TimeDelta>::Type* cb) {
-      time_update_callback_.reset(cb);
+    time_update_callback_.reset(cb);
   }
 
   virtual void ScheduleTimeUpdateCallback(base::TimeDelta time) {
-    // TODO(ralphl): Implement MockFilte::ScheduleTimeUpdateCallback.
-    NOTIMPLEMENTED();
+    scheduled_callback_time_ = time;
   }
 
   virtual void InitializationComplete() {
-    EXPECT_FALSE(mock_pipeline_.IsInitialized());
-    mock_pipeline_.SetInitialized(true);
+    EXPECT_FALSE(initialized_);
+    initialized_ = true;
   }
 
   virtual void PostTask(Task* task) {
-    // TODO(ralphl): Implement MockPipeline::PostTask.
-    NOTIMPLEMENTED();
+    mock_pipeline_->PostTask(task);
   }
 
   virtual void Error(PipelineError error) {
-    mock_pipeline_.Error(error);
+    mock_pipeline_->Error(error);
   }
 
   virtual void SetTime(base::TimeDelta time) {
-    mock_pipeline_.SetTime(time);
+    mock_pipeline_->SetTime(time);
   }
 
   virtual void SetDuration(base::TimeDelta duration) {
-    mock_pipeline_.SetDuration(duration);
+    mock_pipeline_->SetDuration(duration);
   }
 
   virtual void SetBufferedTime(base::TimeDelta buffered_time) {
-    mock_pipeline_.SetBufferedTime(buffered_time);
+    mock_pipeline_->SetBufferedTime(buffered_time);
   }
 
   virtual void SetTotalBytes(int64 total_bytes) {
-    mock_pipeline_.SetTotalBytes(total_bytes);
+    mock_pipeline_->SetTotalBytes(total_bytes);
   }
 
   virtual void SetBufferedBytes(int64 buffered_bytes) {
-    mock_pipeline_.SetBufferedBytes(buffered_bytes);
+    mock_pipeline_->SetBufferedBytes(buffered_bytes);
   }
 
-  // Sets the size of the video output in pixel units.
   virtual void SetVideoSize(size_t width, size_t height) {
-    mock_pipeline_.SetVideoSize(width, height);
+    mock_pipeline_->SetVideoSize(width, height);
   }
 
   // Used by unit tests to manipulate the filter.
-  Filter* filter() const { return filter_; }
+  base::TimeDelta GetScheduledCallbackTime() const {
+    return scheduled_callback_time_;
+  }
+
+  Callback1<base::TimeDelta>::Type* GetTimeUpdateCallback() const {
+    return time_update_callback_.get();
+  }
 
-  MockPipeline* mock_pipeline() const { return &mock_pipeline_; }
+  bool IsInitialized() const {
+    return initialized_;
+  }
 
  private:
-  MockPipeline mock_pipeline_;
+  MockPipeline* mock_pipeline_;
   scoped_refptr<Filter> filter_;
   scoped_ptr<Callback1<base::TimeDelta>::Type> time_update_callback_;
 
+  // Keeps track of the time passed into ScheduleTimeUpdateCallback().
+  base::TimeDelta scheduled_callback_time_;
+
+  // Tracks if the filter has executed InitializationComplete().
+  bool initialized_;
+
   DISALLOW_COPY_AND_ASSIGN(MockFilterHost);
 };
 
diff --git a/media/base/mock_pipeline.h b/media/base/mock_pipeline.h
index d353c41..8741cc2 100644
--- a/media/base/mock_pipeline.h
+++ b/media/base/mock_pipeline.h
@@ -2,9 +2,16 @@
 // source code is governed by a BSD-style license that can be found in the
 // LICENSE file.
 
+// Mock implementation of Pipeline.  Simply provides getters/setters for every
+// pipeline state variable and queues all tasks posted to the "pipeline thread."
+// Since there actually isn't a separate thread unit tests can control when
+// they want to execute queued tasks by calling RunAllTasks(), which helps to
+// assert pre- and post-conditions.
+
 #ifndef MEDIA_BASE_MOCK_PIPELINE_H_
 #define MEDIA_BASE_MOCK_PIPELINE_H_
 
+#include <deque>
 #include <string>
 
 #include "media/base/media_format.h"
@@ -117,8 +124,24 @@ class MockPipeline : public media::Pipeline {
     total_bytes_ = 0;
   }
 
-  void SetInitialized(bool init_value) {
-    initialized_ = init_value;
+  // Runs all queued tasks until there are no more.
+  //
+  // Although it is possible for tasks to run indefinitely (executing tasks post
+  // additional tasks), such situations should be treated as a bug.  Since the
+  // pipeline is request/pull-based, only enough tasks to satisfy the request
+  // should ever be executed.
+  void RunAllTasks() {
+    while (!task_queue_.empty()) {
+      Task* task = task_queue_.front();
+      task_queue_.pop_front();
+      task->Run();
+      delete task;
+    }
+  }
+
+  void PostTask(Task* task) {
+    EXPECT_TRUE(task);
+    task_queue_.push_back(task);
   }
 
   void Error(media::PipelineError error) {
@@ -146,7 +169,6 @@ class MockPipeline : public media::Pipeline {
     buffered_bytes_ = buffered_bytes;
   }
 
-  // Sets the size of the video output in pixel units.
   virtual void SetVideoSize(size_t width, size_t height) {
     width_ = width;
     height_ = height;
@@ -165,6 +187,9 @@ class MockPipeline : public media::Pipeline {
   int64 buffered_bytes_;
   int64 total_bytes_;
 
+  typedef std::deque<Task*> TaskQueue;
+  TaskQueue task_queue_;
+
   DISALLOW_COPY_AND_ASSIGN(MockPipeline);
 };