A very basic implementation of a data source, which opens a file. Implementation of the DataSource media filter interface.

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

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

2 files changed, 276 insertions, 0 deletions

diff --git a/media/base/mock_filter_host.h b/media/base/mock_filter_host.h
new file mode 100644
index 0000000..490587f
--- /dev/null
+++ b/media/base/mock_filter_host.h
@@ -0,0 +1,103 @@
+// Copyright (c) 2009 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.
+
+#ifndef MEDIA_BASE_MOCK_FILTER_HOST_H_
+#define MEDIA_BASE_MOCK_FILTER_HOST_H_
+
+#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_pipeline.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+template <class Filter, class Source>
+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);
+    }
+  }
+
+  virtual ~MockFilterHost() {
+    filter_->Stop();
+  }
+
+  virtual const PipelineStatus* GetPipelineStatus() const {
+    return &mock_pipeline_;
+  }
+
+  virtual void SetTimeUpdateCallback(Callback1<base::TimeDelta>::Type* cb) {
+      time_update_callback_.reset(cb);
+  }
+
+  virtual void ScheduleTimeUpdateCallback(base::TimeDelta time) {
+    // TODO(ralphl): Implement MockFilte::ScheduleTimeUpdateCallback.
+    NOTIMPLEMENTED();
+  }
+
+  virtual void InitializationComplete() {
+    EXPECT_FALSE(mock_pipeline_.IsInitialized());
+    mock_pipeline_.SetInitialized(true);
+  }
+
+  virtual void PostTask(Task* task) {
+    // TODO(ralphl): Implement MockPipeline::PostTask.
+    NOTIMPLEMENTED();
+  }
+
+  virtual void Error(PipelineError error) {
+    mock_pipeline_.Error(error);
+  }
+
+  virtual void SetTime(base::TimeDelta time) {
+    mock_pipeline_.SetTime(time);
+  }
+
+  virtual void SetDuration(base::TimeDelta duration) {
+    mock_pipeline_.SetDuration(duration);
+  }
+
+  virtual void SetBufferedTime(base::TimeDelta buffered_time) {
+    mock_pipeline_.SetBufferedTime(buffered_time);
+  }
+
+  virtual void SetTotalBytes(int64 total_bytes) {
+    mock_pipeline_.SetTotalBytes(total_bytes);
+  }
+
+  virtual void SetBufferedBytes(int64 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);
+  }
+
+  // Used by unit tests to manipulate the filter.
+  Filter* filter() const { return filter_; }
+
+  MockPipeline* mock_pipeline() const { return &mock_pipeline_; }
+
+ private:
+  MockPipeline mock_pipeline_;
+  scoped_refptr<Filter> filter_;
+  scoped_ptr<Callback1<base::TimeDelta>::Type> time_update_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockFilterHost);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MOCK_FILTER_HOST_H_
diff --git a/media/base/mock_pipeline.h b/media/base/mock_pipeline.h
new file mode 100644
index 0000000..d353c41
--- /dev/null
+++ b/media/base/mock_pipeline.h
@@ -0,0 +1,173 @@
+// Copyright (c) 2009 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.
+
+#ifndef MEDIA_BASE_MOCK_PIPELINE_H_
+#define MEDIA_BASE_MOCK_PIPELINE_H_
+
+#include <string>
+
+#include "media/base/media_format.h"
+#include "media/base/pipeline.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+class MockPipeline : public media::Pipeline {
+ public:
+  MockPipeline() {
+    Reset(false);
+  }
+
+  virtual ~MockPipeline() {}
+
+  // Implementation of PipelineStatus interface.
+  virtual bool IsInitialized() const {
+    return initialized_;
+  }
+
+  virtual base::TimeDelta GetDuration() const {
+    return duration_;
+  }
+
+  virtual base::TimeDelta GetBufferedTime() const {
+    return buffered_time_;
+  }
+
+  virtual int64 GetTotalBytes() const {
+    return total_bytes_;
+  }
+
+  virtual int64 GetBufferedBytes() const {
+    return buffered_bytes_;
+  }
+
+  virtual void GetVideoSize(size_t* width_out, size_t* height_out) const {
+    *width_out = width_;
+    *height_out = height_;
+  }
+
+  virtual float GetVolume() const {
+    return volume_;
+  }
+
+  virtual float GetPlaybackRate() const {
+    return playback_rate_;
+  }
+
+  virtual base::TimeDelta GetTime() const {
+    return time_;
+  }
+
+  virtual base::TimeDelta GetInterpolatedTime() const {
+    return time_;
+  }
+
+  virtual PipelineError GetError() const {
+    return error_;
+  }
+
+  // Implementation of Pipeline interface.
+  virtual bool Start(FilterFactory* filter_factory,
+                     const std::string& url,
+                     Callback1<bool>::Type* init_complete_callback) {
+    EXPECT_FALSE(initialized_);
+    initialized_ = true;
+    if (init_complete_callback) {
+      init_complete_callback->Run(true);
+      delete init_complete_callback;
+    }
+    return true;
+  }
+
+  virtual void Stop() {
+    EXPECT_TRUE(initialized_ || error_ != media::PIPELINE_OK);
+    Reset(false);
+  }
+
+  virtual void SetPlaybackRate(float playback_rate) {
+    playback_rate_ = playback_rate;
+  }
+
+  virtual void Seek(base::TimeDelta time) {
+    time_ = time;
+  }
+
+  virtual void SetVolume(float volume) {
+    volume_ = volume;
+  }
+
+  // Public methods used by tests and by MockFilterHost to manipulate the
+  // state of the mock pipeline.
+
+  // Set the state to the same as a newly created MockPipeline.  If
+  // |reset_to_initialized| is true then the pipeline's |initialized_| state
+  // will be true when this method returns.
+  void Reset(bool reset_to_initialized) {
+    error_ = media::PIPELINE_OK;
+    volume_ = 1.0f;
+    playback_rate_ = 0.0f;
+    initialized_ = reset_to_initialized;
+    time_ = base::TimeDelta();
+    duration_ = base::TimeDelta();
+    buffered_time_ = base::TimeDelta();
+    width_ = 0;
+    height_ = 0;
+    buffered_bytes_ = 0;
+    total_bytes_ = 0;
+  }
+
+  void SetInitialized(bool init_value) {
+    initialized_ = init_value;
+  }
+
+  void Error(media::PipelineError error) {
+    initialized_ = false;
+    error_ = error;
+  }
+
+  void SetTime(base::TimeDelta time) {
+    time_ = time;
+  }
+
+  virtual void SetDuration(base::TimeDelta duration) {
+    duration_ = duration;
+  }
+
+  virtual void SetBufferedTime(base::TimeDelta buffered_time) {
+    buffered_time = buffered_time;
+  }
+
+  virtual void SetTotalBytes(int64 total_bytes) {
+    total_bytes_ = total_bytes;
+  }
+
+  virtual void SetBufferedBytes(int64 buffered_bytes) {
+    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;
+  }
+
+ private:
+  PipelineError error_;
+  float volume_;
+  float playback_rate_;
+  bool initialized_;
+  base::TimeDelta time_;
+  base::TimeDelta duration_;
+  base::TimeDelta buffered_time_;
+  size_t width_;
+  size_t height_;
+  int64 buffered_bytes_;
+  int64 total_bytes_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockPipeline);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MOCK_PIPELINE_H_