Migrate Pipeline & PipelineImpl to PipelineStatusCB.

webkit/glue/media/buffered_data_source.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/glue/media/buffered_data_source.h"
 
 #include "media/base/filter_host.h"
 #include "net/base/net_errors.h"
 #include "webkit/glue/media/web_data_source_factory.h"
 #include "webkit/glue/webkit_glue.h"
@@ skipping 28 matching lines @@
 BufferedDataSource::BufferedDataSource(
     MessageLoop* render_loop,
     WebFrame* frame)
     : total_bytes_(kPositionNotSpecified),
       buffered_bytes_(0),
       loaded_(false),
       streaming_(false),
       frame_(frame),
       loader_(NULL),
       network_activity_(false),
-      initialize_callback_(NULL),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
       stop_signal_received_(false),
       stopped_on_render_loop_(false),
       media_is_paused_(true),
@@ skipping 18 matching lines @@
 }
 
 void BufferedDataSource::set_host(media::FilterHost* host) {
   DataSource::set_host(host);
 
   if (loader_.get())
     UpdateHostState();
 }
 
 void BufferedDataSource::Initialize(const std::string& url,
-                                    media::PipelineStatusCallback* callback) {
+                                    const media::PipelineStatusCB& callback) {
   // Saves the url.
   url_ = GURL(url);
 
   // This data source doesn't support data:// protocol so reject it.
   if (url_.SchemeIs(kDataScheme)) {
-    callback->Run(media::DATASOURCE_ERROR_URL_NOT_SUPPORTED);
-    delete callback;
+    callback.Run(media::DATASOURCE_ERROR_URL_NOT_SUPPORTED);
     return;
   } else if (!IsProtocolSupportedForMedia(url_)) {
-    callback->Run(media::PIPELINE_ERROR_NETWORK);
-    delete callback;
+    callback.Run(media::PIPELINE_ERROR_NETWORK);
     return;
   }
 
-  DCHECK(callback);
-  initialize_callback_.reset(callback);
+  DCHECK(!callback.is_null());
+  initialize_cb_ = callback;
 
   // Post a task to complete the initialization task.
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::InitializeTask));
 }
 
 void BufferedDataSource::CancelInitialize() {
   base::AutoLock auto_lock(lock_);
-  DCHECK(initialize_callback_.get());
+  DCHECK(!initialize_cb_.is_null());
 
-  initialize_callback_.reset();
+  initialize_cb_.Reset();
 
   render_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &BufferedDataSource::CleanupTask));
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // media::Filter implementation.
 void BufferedDataSource::Stop(media::FilterCallback* callback) {
   {
     base::AutoLock auto_lock(lock_);
@@ skipping 69 matching lines @@
 
   CleanupTask();
   frame_ = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Render thread tasks.
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
-  if (stopped_on_render_loop_ || !initialize_callback_.get())
+  if (stopped_on_render_loop_ || initialize_cb_.is_null())
     return;
 
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
     // Do an unbounded range request starting at the beginning.  If the server
     // responds with 200 instead of 206 we'll fall back into a streaming mode.
     loader_ = CreateResourceLoader(0, kPositionNotSpecified);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
         NewCallback(this, &BufferedDataSource::NetworkEventCallback),
         frame_);
@@ skipping 156 matching lines @@
 
   read_callback_.reset();
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = 0;
 }
 
 void BufferedDataSource::DoneInitialization_Locked(
     media::PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(initialize_callback_.get());
+  DCHECK(!initialize_cb_.is_null());
   lock_.AssertAcquired();
 
-  scoped_ptr<media::PipelineStatusCallback> initialize_callback(
-      initialize_callback_.release());
-  initialize_callback->Run(status);
+  initialize_cb_.Run(status);
+  initialize_cb_.Reset();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::HttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   int64 instance_size = loader_->instance_size();
   bool success = error == net::OK;
 
-  if (!initialize_callback_.get()) {
+  if (initialize_cb_.is_null()) {
     loader_->Stop();
     return;
   }
 
   if (success) {
     // TODO(hclam): Needs more thinking about supporting servers without range
     // request or their partial response is not complete.
     total_bytes_ = instance_size;
     loaded_ = false;
     streaming_ = (instance_size == kPositionNotSpecified) ||
         !loader_->range_supported();
   } else {
     // TODO(hclam): In case of failure, we can retry several times.
     loader_->Stop();
   }
 
   if (error == net::ERR_INVALID_RESPONSE && using_range_request_) {
     // Assuming that the Range header was causing the problem. Retry without
     // the Range header.
     using_range_request_ = false;
     loader_ = CreateResourceLoader(kPositionNotSpecified,
                                    kPositionNotSpecified);
     loader_->Start(
         NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
         NewCallback(this, &BufferedDataSource::NetworkEventCallback),
         frame_);
     return;
   }
 
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
   //       w/o the lock.
   scoped_refptr<BufferedDataSource> destruction_guard(this);
   {
     // We need to prevent calling to filter host and running the callback if
     // we have received the stop signal. We need to lock down the whole callback
     // method to prevent bad things from happening. The reason behind this is
     // that we cannot guarantee tasks on render thread have completely stopped
@@ skipping 12 matching lines @@
 
     UpdateHostState();
     DoneInitialization_Locked(media::PIPELINE_OK);
   }
 }
 
 void BufferedDataSource::NonHttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
-  if (!initialize_callback_.get()) {
+  if (initialize_cb_.is_null()) {
     loader_->Stop();
     return;
   }
 
   int64 instance_size = loader_->instance_size();
   bool success = error == net::OK && instance_size != kPositionNotSpecified;
 
   if (success) {
     total_bytes_ = instance_size;
     buffered_bytes_ = total_bytes_;
     loaded_ = true;
   } else {
     loader_->Stop();
   }
 
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
   //       w/o the lock.
   scoped_refptr<BufferedDataSource> destruction_guard(this);
   {
     // We need to prevent calling to filter host and running the callback if
     // we have received the stop signal. We need to lock down the whole callback
     // method to prevent bad things from happening. The reason behind this is
     // that we cannot guarantee tasks on render thread have completely stopped
     // when we receive the Stop() method call. The only way to solve this is to
     // let tasks on render thread to run but make sure they don't call outside
     // this object when Stop() method is ever called. Locking this method is
     // safe because |lock_| is only acquired in tasks on render thread.
     base::AutoLock auto_lock(lock_);
-    if (stop_signal_received_ || !initialize_callback_.get())
+    if (stop_signal_received_ || initialize_cb_.is_null())
       return;
 
     if (!success) {
       DoneInitialization_Locked(media::PIPELINE_ERROR_NETWORK);
       return;
     }
 
     UpdateHostState();
     DoneInitialization_Locked(media::PIPELINE_OK);
   }
@@ skipping 120 matching lines @@
 
   if (streaming_) {
     filter_host->SetStreaming(true);
   } else {
     filter_host->SetTotalBytes(total_bytes_);
     filter_host->SetBufferedBytes(buffered_bytes_);
   }
 }
 
 }  // namespace webkit_glue