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

webkit/media/webmediaplayer_impl.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 "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 177 matching lines @@
   // A sophisticated data source that does memory caching.
   scoped_ptr<media::DataSourceFactory> buffered_data_source_factory(
       BufferedDataSource::CreateFactory(MessageLoop::current(), frame,
                                         media_log_,
                                         proxy_->GetBuildObserver()));
 
   scoped_ptr<media::CompositeDataSourceFactory> data_source_factory(
       new media::CompositeDataSourceFactory());
 
   if (use_simple_data_source) {
-    data_source_factory->AddFactory(simple_data_source_factory.release());
-    data_source_factory->AddFactory(buffered_data_source_factory.release());
+    data_source_factory->AddFactory(simple_data_source_factory.Pass());
+    data_source_factory->AddFactory(buffered_data_source_factory.Pass());
   } else {
-    data_source_factory->AddFactory(buffered_data_source_factory.release());
-    data_source_factory->AddFactory(simple_data_source_factory.release());
+    data_source_factory->AddFactory(buffered_data_source_factory.Pass());
+    data_source_factory->AddFactory(simple_data_source_factory.Pass());
   }
 
   scoped_ptr<media::DemuxerFactory> demuxer_factory(
-      new media::FFmpegDemuxerFactory(data_source_factory.release(),
-                                      pipeline_message_loop));
+      // TODO(fischman): replace the extra scoped_ptr+release() with Pass() when
+      // http://crbug.com/109026 is fixed.
+      new media::FFmpegDemuxerFactory(scoped_ptr<media::DataSourceFactory>(
+          data_source_factory.release()), pipeline_message_loop));
 
   std::string source_url = GetClient()->sourceURL().spec();
 
   if (!source_url.empty()) {
     demuxer_factory.reset(
         new media::ChunkDemuxerFactory(source_url,
-                                       demuxer_factory.release(),
+                                       demuxer_factory.Pass(),
                                        proxy_));
   }
-  filter_collection_->SetDemuxerFactory(demuxer_factory.release());
+  filter_collection_->SetDemuxerFactory(demuxer_factory.Pass());
 
   // Add in the default filter factories.
   filter_collection_->AddAudioDecoder(new media::FFmpegAudioDecoder(
       message_loop_factory_->GetMessageLoop("AudioDecoderThread")));
   filter_collection_->AddVideoDecoder(new media::FFmpegVideoDecoder(
       message_loop_factory_->GetMessageLoop("VideoDecoderThread")));
   filter_collection_->AddAudioRenderer(new media::NullAudioRenderer());
 
   return true;
 }
@@ skipping 64 matching lines @@
       filter_collection_->AddVideoDecoder(new_decoder.get());
       has_video = true;
     }
 
     // TODO(wjia): add audio decoder handling when it's available.
     if (has_video || has_audio) {
       // TODO(vrk/wjia): Setting true for local_source is under the assumption
       // that the MediaStream represents a local webcam. This will need to
       // change in the future when GetVideoDecoder is no longer hardcoded to
       // only return CaptureVideoDecoders.
-      filter_collection_->SetDemuxerFactory(
-          new media::DummyDemuxerFactory(has_video, has_audio, true));
+      filter_collection_->SetDemuxerFactory(scoped_ptr<media::DemuxerFactory>(
+          new media::DummyDemuxerFactory(has_video, has_audio, true)));
     }
   }
 
   // Handle any volume changes that occured before load().
   setVolume(GetClient()->volume());
   // Get the preload value.
   setPreload(GetClient()->preload());
 
   // Initialize the pipeline.
   SetNetworkState(WebKit::WebMediaPlayer::Loading);
   SetReadyState(WebKit::WebMediaPlayer::HaveNothing);
   pipeline_->Start(
-      filter_collection_.release(),
+      filter_collection_.Pass(),
       url.spec(),
       base::Bind(&WebMediaPlayerProxy::PipelineInitializationCallback,
                  proxy_.get()));
 
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 }
 
 void WebMediaPlayerImpl::cancelLoad() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 }
@@ skipping 607 matching lines @@
   return client_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media