Make the generated stubs weak. Enable the unittests that had conflicting symbols.

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 "base/singleton.h"
 #include "base/tuple.h"
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
@@ skipping 250 matching lines @@
     factory_ = FFmpegDemuxer::CreateFilterFactory();
     MediaFormat media_format;
     media_format.SetAsString(MediaFormat::kMimeType,
                              mime_type::kApplicationOctetStream);
     demuxer_ = factory_->Create<Demuxer>(media_format);
     DCHECK(demuxer_);
 
     // Prepare a filter host and data source for the demuxer.
     pipeline_.reset(new MockPipeline());
     filter_host_.reset(new MockFilterHost<Demuxer>(pipeline_.get(), demuxer_));
-    MockFilterConfig config;
-    data_source_ = new MockDataSource(&config);
+    old_mocks::MockFilterConfig config;
+    data_source_ = new old_mocks::MockDataSource(&config);
   }
 
   virtual void TearDown() {
     // Call Stop() to shut down internal threads.
     demuxer_->Stop();
   }
 
   // Fixture members.
   scoped_refptr<FilterFactory> factory_;
   scoped_refptr<Demuxer> demuxer_;
   scoped_ptr<MockPipeline> pipeline_;
-  scoped_ptr< MockFilterHost<Demuxer> > filter_host_;
-  scoped_refptr<MockDataSource> data_source_;
+  scoped_ptr<MockFilterHost<Demuxer> > filter_host_;
+  scoped_refptr<old_mocks::MockDataSource> data_source_;
 
  private:
   static void InitializeFFmpegMocks() {
     // Initialize function return codes.
     g_av_open_input_file = 0;
     g_av_find_stream_info = 0;
     g_av_read_frame = 0;
 
     // Initialize AVFormatContext structure.
     memset(&g_format, 0, sizeof(g_format));
@@ skipping 97 matching lines @@
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   EXPECT_TRUE(filter_host_->WaitForInitialized());
   EXPECT_TRUE(filter_host_->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());
+  EXPECT_EQ(2u, demuxer_->GetNumberOfStreams());
 
   // First stream should be video and support FFmpegDemuxerStream interface.
   scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(0);
   AVStreamProvider* av_stream_provider = NULL;
   ASSERT_TRUE(stream);
   std::string mime_type;
   EXPECT_TRUE(
       stream->media_format().GetAsString(MediaFormat::kMimeType, &mime_type));
   EXPECT_STREQ(mime_type::kFFmpegVideo, mime_type.c_str());
   EXPECT_TRUE(stream->QueryInterface(&av_stream_provider));
@@ skipping 38 matching lines @@
   g_streams[2].duration = 10;
   g_streams[2].codec = &g_video_codec;
 
   // Initialize the demuxer.
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   EXPECT_TRUE(filter_host_->WaitForInitialized());
   EXPECT_TRUE(filter_host_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // Verify both streams were created.
-  EXPECT_EQ(2, demuxer_->GetNumberOfStreams());
+  EXPECT_EQ(2u, demuxer_->GetNumberOfStreams());
 
   // Get our streams.
   scoped_refptr<DemuxerStream> audio_stream = demuxer_->GetStream(kAudio);
   scoped_refptr<DemuxerStream> video_stream = demuxer_->GetStream(kVideo);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
 
   // Prepare data packets, which should all get immediately released.
   PacketQueue::get()->Enqueue(kPacketData, kDataSize, audio_data);
   PacketQueue::get()->Enqueue(kPacketData, kDataSize, audio_data);
@@ skipping 175 matching lines @@
   g_streams[0].codec = &g_audio_codec;
   g_audio_codec.codec_id = CODEC_ID_MP3;
 
   // Initialize the demuxer.
   EXPECT_TRUE(demuxer_->Initialize(data_source_.get()));
   EXPECT_TRUE(filter_host_->WaitForInitialized());
   EXPECT_TRUE(filter_host_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
 
   // Verify the stream was created.
-  EXPECT_EQ(1, demuxer_->GetNumberOfStreams());
+  EXPECT_EQ(1u, demuxer_->GetNumberOfStreams());
   scoped_refptr<DemuxerStream> audio_stream = demuxer_->GetStream(kAudio);
   ASSERT_TRUE(audio_stream);
 
   // Prepare our test audio packet.
   PacketQueue::get()->Enqueue(kPacketAudio, kDataSize, audio_data);
 
   // Audio read should perform a deep copy on the packet and instantly release
   // the original packet.  The data pointers should not be the same, but the
   // contents should match.
   scoped_refptr<TestReader> reader = new TestReader();
@@ skipping 11 matching lines @@
   EXPECT_TRUE(PacketQueue::get()->WaitForOutstandingPackets(0));
   EXPECT_EQ(1, g_outstanding_packets_av_new_frame);
 
   // Now release our reference, which should destruct the packet allocated by
   // av_new_packet().
   reader = NULL;
   EXPECT_EQ(0, g_outstanding_packets_av_new_frame);
 }
 
 }  // namespace