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

media/base/pipeline_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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "media/base/pipeline_impl.h"
 
 #include <algorithm>
@@ skipping 80 matching lines @@
                         const PipelineStatusCB& error_callback,
                         const NetworkEventCB& network_callback) {
   DCHECK(!IsRunning())
       << "Init() should be called before the pipeline has started";
   ended_callback_ = ended_callback;
   error_callback_ = error_callback;
   network_callback_ = network_callback;
 }
 
 // Creates the PipelineInternal and calls it's start method.
-bool PipelineImpl::Start(FilterCollection* collection,
+bool PipelineImpl::Start(scoped_ptr<FilterCollection> collection,
                          const std::string& url,
                          const PipelineStatusCB& start_callback) {
   base::AutoLock auto_lock(lock_);
-  scoped_ptr<FilterCollection> filter_collection(collection);
+  scoped_ptr<FilterCollection> filter_collection(collection.Pass());
 
   if (running_) {
     VLOG(1) << "Media pipeline is already running";
     return false;
   }
 
   if (collection->IsEmpty()) {
     return false;
   }
 
   // Kick off initialization!
   running_ = true;
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::StartTask, this,
-                 filter_collection.release(),
+                 base::Passed(&filter_collection),
                  url,
                  start_callback));
   return true;
 }
 
 void PipelineImpl::Stop(const PipelineStatusCB& stop_callback) {
   base::AutoLock auto_lock(lock_);
   if (!running_) {
     VLOG(1) << "Media pipeline has already stopped";
     return;
@@ skipping 487 matching lines @@
 // Called from any thread.
 void PipelineImpl::OnUpdateStatistics(const PipelineStatistics& stats) {
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
   media_log_->QueueStatisticsUpdatedEvent(statistics_);
 }
 
-void PipelineImpl::StartTask(FilterCollection* filter_collection,
+void PipelineImpl::StartTask(scoped_ptr<FilterCollection> filter_collection,
                              const std::string& url,
                              const PipelineStatusCB& start_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(kCreated, state_);
-  filter_collection_.reset(filter_collection);
+  filter_collection_ = filter_collection.Pass();
   url_ = url;
   seek_callback_ = start_callback;
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
   pipeline_init_state_->composite_ = new CompositeFilter(message_loop_);
   pipeline_init_state_->composite_->set_host(this);
 
   SetState(kInitDemuxer);
   InitializeDemuxer();
@@ skipping 779 matching lines @@
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::NotifyCanPlayThrough, this));
 }
 
 void PipelineImpl::NotifyCanPlayThrough() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   NotifyNetworkEventTask(CAN_PLAY_THROUGH);
 }
 
 }  // namespace media