Checking in media::FFmpegGlue, media::FFmpegDemuxer and tests.

media/base/mock_media_filters.h

 // 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_MEDIA_FILTERS_H_
 #define MEDIA_BASE_MOCK_MEDIA_FILTERS_H_
 
 #include <string>
 
 #include "base/waitable_event.h"
@@ skipping 19 matching lines @@
 };
 
 
 // This class is used by all of the mock filters to change the configuration
 // of the desired pipeline.  The test using this must ensure that the lifetime
 // of the object is at least as long as the lifetime of the filters, as this
 // is typically allocated on the stack.
 struct MockFilterConfig {
   MockFilterConfig()
       : data_source_behavior(MOCK_DATA_SOURCE_NORMAL_INIT),
+        data_source_value('!'),
         has_video(true),
         video_width(1280u),
         video_height(720u),
         video_surface_format(VideoSurface::YV12),
         has_audio(true),
         compressed_audio_mime_type(mime_type::kAACAudio),
         uncompressed_audio_mime_type(mime_type::kUncompressedAudio),
         compressed_video_mime_type(mime_type::kH264AnnexB),
         uncompressed_video_mime_type(mime_type::kUncompressedVideo),
         frame_duration(base::TimeDelta::FromMicroseconds(33333)),
         media_duration(base::TimeDelta::FromSeconds(5)),
         media_total_bytes(media_duration.InMilliseconds() * 250) {
   }
 
   MockDataSourceBehavior data_source_behavior;
+  char data_source_value;
   bool has_video;
   size_t video_width;
   size_t video_height;
   VideoSurface::Format video_surface_format;
   bool has_audio;
   std::string compressed_audio_mime_type;
   std::string uncompressed_audio_mime_type;
   std::string compressed_video_mime_type;
   std::string uncompressed_video_mime_type;
   base::TimeDelta frame_duration;
   base::TimeDelta media_duration;
   int64 media_total_bytes;
 };
 
 
 class MockDataSource : public DataSource {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
      return new FilterFactoryImpl1<MockDataSource,
                                    const MockFilterConfig*>(config);
   }
 
   explicit MockDataSource(const MockFilterConfig* config)
       : config_(config),
-        position_(0) {
+        position_(0),
+        deleted_(NULL) {
+  }
+
+  MockDataSource(const MockFilterConfig* config, bool* deleted)
+      : config_(config),
+        position_(0),
+        deleted_(deleted) {
+    EXPECT_TRUE(deleted);
+    EXPECT_FALSE(*deleted);
   }
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
   // Implementation of DataSource.
   virtual bool Initialize(const std::string& url) {
     media_format_.SetAsString(MediaFormat::kMimeType,
                               mime_type::kApplicationOctetStream);
     media_format_.SetAsString(MediaFormat::kURL, url);
@@ skipping 24 matching lines @@
 
   virtual const MediaFormat* GetMediaFormat() {
     return &media_format_;
   }
 
   virtual size_t Read(uint8* data, size_t size) {
     size_t read = static_cast<size_t>(config_->media_total_bytes - position_);
     if (size < read) {
       read = size;
     }
-    memset(data, 0, read);
+    memset(data, config_->data_source_value, read);
     return read;
   }
 
   virtual bool GetPosition(int64* position_out) {
     *position_out = position_;
     return true;
   }
 
   virtual bool SetPosition(int64 position) {
-    EXPECT_GE(position, 0u);
-    EXPECT_LE(position, config_->media_total_bytes);
     if (position < 0u || position > config_->media_total_bytes) {
       return false;
     }
     position_ = position;
     return true;
   }
 
   virtual bool GetSize(int64* size_out) {
-    *size_out = config_->media_total_bytes;
+    if (config_->media_total_bytes >= 0) {
+      *size_out = config_->media_total_bytes;
+      return true;
+    }
     return false;
   }
 
+  // Simple position getter for unit testing.
+  int64 position() const { return position_; }
+
  private:
-  virtual ~MockDataSource() {}
+  virtual ~MockDataSource() {
+    if (deleted_) {
+      *deleted_ = true;
+    }
+  }
 
   void TaskBehavior() {
     switch (config_->data_source_behavior) {
       case MOCK_DATA_SOURCE_TASK_ERROR_POST_INIT:
       case MOCK_DATA_SOURCE_TASK_ERROR_PRE_INIT:
         host_->Error(PIPELINE_ERROR_NETWORK);
         break;
       case MOCK_DATA_SOURCE_TASK_INIT:
         host_->InitializationComplete();
         break;
       default:
         NOTREACHED();
     }
   }
 
   const MockFilterConfig* config_;
   int64 position_;
   MediaFormat media_format_;
 
+  // Set to true inside the destructor.  Used in FFmpegGlue unit tests for
+  // testing proper reference counting.
+  bool* deleted_;
+
   DISALLOW_COPY_AND_ASSIGN(MockDataSource);
 };
 
 //------------------------------------------------------------------------------
 
 class MockDemuxer : public Demuxer {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
      return new FilterFactoryImpl1<MockDemuxer,
                                    const MockFilterConfig*>(config);
@@ skipping 415 matching lines @@
   base::WaitableEvent event_;
   bool callback_success_status_;
   bool waiting_for_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(InitializationHelper);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_MOCK_MEDIA_FILTERS_H_