DemuxerFactory is born!

media/base/mock_filters.h

 // 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.
 //
 // A new breed of mock media filters, this time using gmock!  Feel free to add
 // actions if you need interesting side-effects (i.e., copying data to the
 // buffer passed into MockDataSource::Read()).
 //
 // Don't forget you can use StrictMock<> and NiceMock<> if you want the mock
 // filters to fail the test or do nothing when an unexpected method is called.
@@ skipping 79 matching lines @@
  protected:
   virtual ~MockDataSource();
 
  private:
   int64 total_bytes_;
   int64 buffered_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDataSource);
 };
 
-class MockDataSourceFactory : public DataSourceFactory {
- public:
-  MockDataSourceFactory(MockDataSource* data_source);
-
-  void SetError(PipelineError error);
-  void RunBuildCallback(const std::string& url, BuildCallback* callback);
-  void DestroyBuildCallback(const std::string& url, BuildCallback* callback);
-
-  // DataSourceFactory methods.
-  MOCK_METHOD2(Build, void(const std::string& url, BuildCallback* callback));
-  virtual DataSourceFactory* Clone() const;
-
- private:
-  scoped_refptr<MockDataSource> data_source_;
-  PipelineError error_;
-};
-
 class MockDemuxer : public Demuxer {
  public:
   MockDemuxer();
-
   // Filter implementation.
+  virtual void set_host(FilterHost* host);
   MOCK_METHOD1(Stop, void(FilterCallback* callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
   MOCK_METHOD2(Seek, void(base::TimeDelta time, FilterCallback* callback));
   MOCK_METHOD0(OnAudioRendererDisabled, void());
 
   // Demuxer implementation.
   MOCK_METHOD2(Initialize, void(DataSource* data_source,
                                 FilterCallback* callback));
   MOCK_METHOD0(GetNumberOfStreams, size_t());
   MOCK_METHOD1(GetStream, scoped_refptr<DemuxerStream>(int stream_id));
 
+  // Sets the TotalBytes, BufferedBytes, & Duration values to be sent to host()
+  // when set_host() is called.
+  void SetTotalAndBufferedBytesAndDuration(
+      int64 total_bytes, int64 buffered_bytes, const base::TimeDelta& duration);
+
  protected:
   virtual ~MockDemuxer();
 
  private:
+  int64 total_bytes_;
+  int64 buffered_bytes_;
+  base::TimeDelta duration_;
+
   DISALLOW_COPY_AND_ASSIGN(MockDemuxer);
 };
 
+class MockDemuxerFactory : public DemuxerFactory {
+ public:
+  explicit MockDemuxerFactory(MockDemuxer* demuxer);
+  virtual ~MockDemuxerFactory();
+
+  void SetError(PipelineError error);
+  void RunBuildCallback(const std::string& url, BuildCallback* callback);
+  void DestroyBuildCallback(const std::string& url, BuildCallback* callback);
+
+  // DemuxerFactory methods.
+  MOCK_METHOD2(Build, void(const std::string& url, BuildCallback* callback));
+  virtual DemuxerFactory* Clone() const;
+
+ private:
+  scoped_refptr<MockDemuxer> demuxer_;
+  PipelineError error_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockDemuxerFactory);
+};
+
 class MockDemuxerStream : public DemuxerStream {
  public:
   MockDemuxerStream();
 
   // DemuxerStream implementation.
   MOCK_METHOD0(media_format, const MediaFormat&());
   MOCK_METHOD1(Read, void(Callback1<Buffer*>::Type* read_callback));
   MOCK_METHOD1(QueryInterface, void*(const char* interface_id));
   MOCK_METHOD0(EnableBitstreamConverter, void());
 
@@ skipping 113 matching lines @@
 };
 
 // FilterFactory that returns canned instances of mock filters.  You can set
 // expectations on the filters and then pass the collection into a pipeline.
 class MockFilterCollection {
  public:
   MockFilterCollection();
   virtual ~MockFilterCollection();
 
   // Mock accessors.
-  MockDataSource* data_source() const { return data_source_; }
   MockDemuxer* demuxer() const { return demuxer_; }
   MockVideoDecoder* video_decoder() const { return video_decoder_; }
   MockAudioDecoder* audio_decoder() const { return audio_decoder_; }
   MockVideoRenderer* video_renderer() const { return video_renderer_; }
   MockAudioRenderer* audio_renderer() const { return audio_renderer_; }
 
   FilterCollection* filter_collection() const {
     return filter_collection(true, true, PIPELINE_OK);
   }
 
-  FilterCollection* filter_collection(bool include_data_source,
+  FilterCollection* filter_collection(bool include_demuxer,
                                       bool run_build_callback,
                                       PipelineError build_error) const;
 
  private:
-  scoped_refptr<MockDataSource> data_source_;
   scoped_refptr<MockDemuxer> demuxer_;
   scoped_refptr<MockVideoDecoder> video_decoder_;
   scoped_refptr<MockAudioDecoder> audio_decoder_;
   scoped_refptr<MockVideoRenderer> video_renderer_;
   scoped_refptr<MockAudioRenderer> audio_renderer_;
 
   DISALLOW_COPY_AND_ASSIGN(MockFilterCollection);
 };
 
 // Helper gmock functions that immediately executes and destroys the
 // FilterCallback on behalf of the provided filter.  Can be used when mocking
 // the Initialize() and Seek() methods.
 void RunFilterCallback(::testing::Unused, FilterCallback* callback);
+void RunPipelineStatusCallback(PipelineError status,
+                               PipelineStatusCallback* callback);
 void RunFilterCallback3(::testing::Unused, FilterCallback* callback,
                         ::testing::Unused);
 
 // Helper gmock function that immediately destroys the FilterCallback on behalf
 // of the provided filter.  Can be used when mocking the Initialize() and Seek()
 // methods.
 void DestroyFilterCallback(::testing::Unused, FilterCallback* callback);
 
 // Helper gmock function that immediately executes and destroys the
 // FilterCallback on behalf of the provided filter.  Can be used when mocking
@@ skipping 22 matching lines @@
  public:
   MockStatisticsCallback();
   ~MockStatisticsCallback();
 
   MOCK_METHOD1(OnStatistics, void(const media::PipelineStatistics& statistics));
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_MOCK_FILTERS_H_