Take advantage of the new Pass() machinery on scoped_ptr{,_malloc}.

media/base/mock_filters.cc

 // 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.
 
 #include "media/base/mock_filters.h"
 
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "media/base/filter_host.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::NotNull;
 
 namespace media {
 
 MockDataSource::MockDataSource()
     : total_bytes_(-1),
@@ skipping 40 matching lines @@
   demuxer_ = NULL;
 
   if (status_ == PIPELINE_OK) {
     callback.Run(PIPELINE_OK, demuxer.get());
     return;
   }
 
   callback.Run(status_, NULL);
 }
 
-DemuxerFactory* MockDemuxerFactory::Clone() const {
-  return new MockDemuxerFactory(demuxer_.get());
+scoped_ptr<DemuxerFactory> MockDemuxerFactory::Clone() const {
+  return scoped_ptr<DemuxerFactory>(reinterpret_cast<DemuxerFactory*>(

[acolwell GONE FROM CHROMIUM, 2012/01/03 19:27:06]

Why is the reinterpret_cast needed here?

[Ami GONE FROM CHROMIUM, 2012/01/03 20:58:34]

Leftover.  Gone now.

+      new MockDemuxerFactory(demuxer_.get())));
 }
 
 MockDemuxer::MockDemuxer()
   : total_bytes_(-1), buffered_bytes_(-1), duration_() {}
 
 MockDemuxer::~MockDemuxer() {}
 
 void MockDemuxer::set_host(DemuxerHost* demuxer_host) {
   Demuxer::set_host(demuxer_host);
 
@@ skipping 37 matching lines @@
 MockFilterCollection::MockFilterCollection()
     : demuxer_(new MockDemuxer()),
       video_decoder_(new MockVideoDecoder()),
       audio_decoder_(new MockAudioDecoder()),
       video_renderer_(new MockVideoRenderer()),
       audio_renderer_(new MockAudioRenderer()) {
 }
 
 MockFilterCollection::~MockFilterCollection() {}
 
-FilterCollection* MockFilterCollection::filter_collection(
+scoped_ptr<FilterCollection> MockFilterCollection::filter_collection(
     bool include_demuxer,
     bool run_build_callback,
     bool run_build,
     PipelineStatus build_status) const {
-  FilterCollection* collection = new FilterCollection();
+  scoped_ptr<FilterCollection> collection(new FilterCollection());
 
-  MockDemuxerFactory* demuxer_factory =
-      new MockDemuxerFactory(include_demuxer ? demuxer_ : NULL);
+  scoped_ptr<MockDemuxerFactory> demuxer_factory(
+      new MockDemuxerFactory(include_demuxer ? demuxer_ : NULL));
 
   if (build_status != PIPELINE_OK)
     demuxer_factory->SetError(build_status);
 
   if (run_build_callback) {
     ON_CALL(*demuxer_factory, Build(_, _)).WillByDefault(Invoke(
-        demuxer_factory, &MockDemuxerFactory::RunBuildCallback));
+        demuxer_factory.get(), &MockDemuxerFactory::RunBuildCallback));
   }  // else ignore Build calls.
 
   if (run_build)
     EXPECT_CALL(*demuxer_factory, Build(_, _));
 
-  collection->SetDemuxerFactory(demuxer_factory);
+  collection->SetDemuxerFactory(scoped_ptr<DemuxerFactory>(
+      demuxer_factory.Pass()));
   collection->AddVideoDecoder(video_decoder_);
   collection->AddAudioDecoder(audio_decoder_);
   collection->AddVideoRenderer(video_renderer_);
   collection->AddAudioRenderer(audio_renderer_);
-  return collection;
+  return collection.Pass();
 }
 
 void RunFilterCallback(::testing::Unused, const base::Closure& callback) {
   callback.Run();
 
 }
 
 void RunFilterStatusCB(::testing::Unused, const FilterStatusCB& cb) {
   cb.Run(PIPELINE_OK);
 }
@@ skipping 15 matching lines @@
 MockFilter::MockFilter() {
 }
 
 MockFilter::~MockFilter() {}
 
 MockStatisticsCallback::MockStatisticsCallback() {}
 
 MockStatisticsCallback::~MockStatisticsCallback() {}
 
 }  // namespace media