Lots of files touched for a very simple change. Everywhere we used a const M...

media/filters/ffmpeg_demuxer_unittest.cc

 // 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.
 
 #include <deque>
 
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_media_filters.h"
@@ skipping 130 matching lines @@
 
 TEST(FFmpegDemuxerTest, InitializeFailure) {
   InitializeFFmpegMocks();
 
   // Get FFmpegDemuxer's filter factory.
   scoped_refptr<FilterFactory> factory = FFmpegDemuxer::CreateFilterFactory();
 
   // Should only accept application/octet-stream type.
   MediaFormat media_format;
   media_format.SetAsString(MediaFormat::kMimeType, "foo/x-bar");
-  scoped_refptr<Demuxer> demuxer(factory->Create<Demuxer>(&media_format));
+  scoped_refptr<Demuxer> demuxer(factory->Create<Demuxer>(media_format));
   ASSERT_FALSE(demuxer);
   media_format.Clear();
   media_format.SetAsString(MediaFormat::kMimeType,
                            mime_type::kApplicationOctetStream);
-  demuxer = factory->Create<Demuxer>(&media_format);
+  demuxer = factory->Create<Demuxer>(media_format);
   ASSERT_TRUE(demuxer);
 
   // Prepare a filter host and data source for the demuxer.
   MockPipeline pipeline;
   scoped_ptr< MockFilterHost<Demuxer> > filter_host;
   filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
   MockFilterConfig config;
   scoped_refptr<MockDataSource> data_source(new MockDataSource(&config));
 
   // Simulate av_open_input_fail failing.
   g_av_open_input_file = AVERROR_IO;
   g_av_find_stream_info = 0;
   EXPECT_FALSE(demuxer->Initialize(data_source));
   EXPECT_FALSE(filter_host->IsInitialized());
   EXPECT_EQ(DEMUXER_ERROR_COULD_NOT_OPEN, pipeline.GetError());
 
   // Simulate av_find_stream_info failing.
   g_av_open_input_file = 0;
   g_av_find_stream_info = AVERROR_IO;
-  demuxer = factory->Create<Demuxer>(&media_format);
+  demuxer = factory->Create<Demuxer>(media_format);
   filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
   EXPECT_FALSE(demuxer->Initialize(data_source));
   EXPECT_FALSE(filter_host->IsInitialized());
   EXPECT_EQ(DEMUXER_ERROR_COULD_NOT_PARSE, pipeline.GetError());
 
   // Simulate media with no parseable streams.
   InitializeFFmpegMocks();
-  demuxer = factory->Create<Demuxer>(&media_format);
+  demuxer = factory->Create<Demuxer>(media_format);
   filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
   EXPECT_FALSE(demuxer->Initialize(data_source));
   EXPECT_FALSE(filter_host->IsInitialized());
   EXPECT_EQ(DEMUXER_ERROR_NO_SUPPORTED_STREAMS, pipeline.GetError());
 
   // Simulate media with a data stream but no audio or video streams.
   g_format.nb_streams = 1;
   g_format.streams[0] = &g_streams[0];
   g_streams[0].codec = &g_data_codec;
   g_streams[0].duration = 10;
-  demuxer = factory->Create<Demuxer>(&media_format);
+  demuxer = factory->Create<Demuxer>(media_format);
   filter_host.reset(new MockFilterHost<Demuxer>(&pipeline, demuxer));
   EXPECT_FALSE(demuxer->Initialize(data_source));
   EXPECT_FALSE(filter_host->IsInitialized());
   EXPECT_EQ(DEMUXER_ERROR_NO_SUPPORTED_STREAMS, pipeline.GetError());
 }
 
 TEST(FFmpegDemuxerTest, InitializeStreams) {
   // Simulate media with a data stream, a video stream and audio stream.
   InitializeFFmpegMocks();
   g_format.nb_streams = 3;
@@ skipping 13 matching lines @@
   // Create our data source.
   MockFilterConfig config;
   scoped_refptr<MockDataSource> data_source = new MockDataSource(&config);
   MockFilterHost<DataSource> filter_host_a(&pipeline, data_source);
   EXPECT_TRUE(data_source->Initialize("foo"));
   EXPECT_TRUE(filter_host_a.IsInitialized());
 
   // Create our demuxer.
   scoped_refptr<FilterFactory> factory = FFmpegDemuxer::CreateFilterFactory();
   scoped_refptr<Demuxer> demuxer
-      = factory->Create<Demuxer>(data_source->GetMediaFormat());
+      = factory->Create<Demuxer>(data_source->media_format());
   EXPECT_TRUE(demuxer);
   MockFilterHost<Demuxer> filter_host_b(&pipeline, demuxer);
   EXPECT_TRUE(demuxer->Initialize(data_source));
   EXPECT_TRUE(filter_host_b.IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline.GetError());
 
   // Since we ignore data streams, the duration should be equal to the video
   // stream's duration.
   EXPECT_EQ(g_streams[1].duration, pipeline.GetDuration().InMicroseconds());
 
   // Verify that 2 out of 3 streams were created.
   EXPECT_EQ(2, demuxer->GetNumberOfStreams());
 
   // First stream should be video.
   scoped_refptr<DemuxerStream> stream = demuxer->GetStream(0);
   ASSERT_TRUE(stream);
-  const MediaFormat* stream_format = stream->GetMediaFormat();
   std::string mime_type;
   int result;
-  EXPECT_TRUE(stream_format->GetAsString(MediaFormat::kMimeType, &mime_type));
+  EXPECT_TRUE(
+      stream->media_format().GetAsString(MediaFormat::kMimeType, &mime_type));
   EXPECT_STREQ(mime_type::kFFmpegVideo, mime_type.c_str());
-  EXPECT_TRUE(stream_format->GetAsInteger(kFFmpegCodecID, &result));
+  EXPECT_TRUE(
+      stream->media_format().GetAsInteger(kFFmpegCodecID, &result));
   EXPECT_EQ(CODEC_ID_THEORA, static_cast<CodecID>(result));
-  EXPECT_TRUE(stream_format->GetAsInteger(MediaFormat::kHeight, &result));
+  EXPECT_TRUE(
+      stream->media_format().GetAsInteger(MediaFormat::kHeight, &result));
   EXPECT_EQ(g_video_codec.height, result);
-  EXPECT_TRUE(stream_format->GetAsInteger(MediaFormat::kWidth, &result));
+  EXPECT_TRUE(
+      stream->media_format().GetAsInteger(MediaFormat::kWidth, &result));
   EXPECT_EQ(g_video_codec.width, result);
 
   // Second stream should be audio.
   stream = demuxer->GetStream(1);
   ASSERT_TRUE(stream);
-  stream_format = stream->GetMediaFormat();
-  EXPECT_TRUE(stream_format->GetAsString(MediaFormat::kMimeType, &mime_type));
+  EXPECT_TRUE(
+      stream->media_format().GetAsString(MediaFormat::kMimeType, &mime_type));
   EXPECT_STREQ(mime_type::kFFmpegAudio, mime_type.c_str());
-  EXPECT_TRUE(stream_format->GetAsInteger(kFFmpegCodecID, &result));
+  EXPECT_TRUE(
+      stream->media_format().GetAsInteger(kFFmpegCodecID, &result));
   EXPECT_EQ(CODEC_ID_VORBIS, static_cast<CodecID>(result));
-  EXPECT_TRUE(stream_format->GetAsInteger(MediaFormat::kChannels, &result));
+  EXPECT_TRUE(
+      stream->media_format().GetAsInteger(MediaFormat::kChannels, &result));
   EXPECT_EQ(g_audio_codec.channels, result);
-  EXPECT_TRUE(stream_format->GetAsInteger(MediaFormat::kSampleRate, &result));
+  EXPECT_TRUE(
+      stream->media_format().GetAsInteger(MediaFormat::kSampleRate, &result));
   EXPECT_EQ(g_audio_codec.sample_rate, result);
 }
 
 TEST(FFmpegDemuxerTest, Read) {
   // Prepare some test data.
   const int kAudio = 0;
   const int kVideo = 1;
   const size_t kDataSize = 4;
   uint8 audio_data[kDataSize] = {0, 1, 2, 3};
   uint8 video_data[kDataSize] = {4, 5, 6, 7};
@@ skipping 14 matching lines @@
   // Create our data source.
   MockFilterConfig config;
   scoped_refptr<MockDataSource> data_source = new MockDataSource(&config);
   MockFilterHost<DataSource> filter_host_a(&pipeline, data_source);
   EXPECT_TRUE(data_source->Initialize("foo"));
   EXPECT_TRUE(filter_host_a.IsInitialized());
 
   // Create our demuxer.
   scoped_refptr<FilterFactory> factory = FFmpegDemuxer::CreateFilterFactory();
   scoped_refptr<Demuxer> demuxer
-      = factory->Create<Demuxer>(data_source->GetMediaFormat());
+      = factory->Create<Demuxer>(data_source->media_format());
   EXPECT_TRUE(demuxer);
   MockFilterHost<Demuxer> filter_host_b(&pipeline, demuxer);
   EXPECT_TRUE(demuxer->Initialize(data_source));
   EXPECT_TRUE(filter_host_b.IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline.GetError());
 
   // Verify both streams were created.
   EXPECT_EQ(2, demuxer->GetNumberOfStreams());
 
   // Get our streams.
@@ skipping 14 matching lines @@
   g_packet.stream_index = kAudio;
   g_packet.data = audio_data;
   g_packet.size = kDataSize;
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<TestBuffer> buffer(new TestBuffer());
   audio_stream->Read(buffer);
   pipeline.RunAllTasks();
   EXPECT_TRUE(buffer->assigned());
   EXPECT_TRUE(buffer->buffer());
-  EXPECT_EQ(audio_data, (uint8*)buffer->buffer()->GetData());
+  EXPECT_EQ(audio_data, buffer->buffer()->GetData());
   EXPECT_EQ(kDataSize, buffer->buffer()->GetDataSize());
 
   // Prepare our test video packet.
   g_packet.stream_index = kVideo;
   g_packet.data = video_data;
   g_packet.size = kDataSize;
 
   // Attempt a read from the video stream and run the message loop until done.
   buffer = new TestBuffer();
   video_stream->Read(buffer);
   pipeline.RunAllTasks();
   EXPECT_TRUE(buffer->assigned());
   EXPECT_TRUE(buffer->buffer());
-  EXPECT_EQ(video_data, (uint8*)buffer->buffer()->GetData());
+  EXPECT_EQ(video_data, buffer->buffer()->GetData());
   EXPECT_EQ(kDataSize, buffer->buffer()->GetDataSize());
 
   // Simulate end of stream.
   g_av_read_frame = AVERROR_IO;
 
   // Attempt a read from the audio stream and run the message loop until done.
   buffer = new TestBuffer();
   audio_stream->Read(buffer);
   pipeline.RunAllTasks();
   EXPECT_FALSE(buffer->assigned());
   EXPECT_FALSE(buffer->buffer());
 
   // Manually release buffer, which should release any remaining AVPackets.
   buffer = NULL;
   EXPECT_EQ(0, g_oustanding_packets);
 }