Migrate Pipeline & PipelineImpl to PipelineStatusCB.

webkit/glue/media/simple_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/simple_data_source.h"
 
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "media/base/filter_host.h"
 #include "net/base/data_url.h"
@@ skipping 62 matching lines @@
     delete callback;
   }
 
   // Post a task to the render thread to cancel loading the resource.
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &SimpleDataSource::CancelTask));
 }
 
 void SimpleDataSource::Initialize(
     const std::string& url,
-    media::PipelineStatusCallback* callback) {
-  // Reference to prevent destruction while inside the |initialize_callback_|
+    const media::PipelineStatusCB& 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.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, UNINITIALIZED);
-    DCHECK(callback);
+    DCHECK(!callback.is_null());
     state_ = INITIALIZING;
-    initialize_callback_.reset(callback);
+    initialize_cb_ = callback;
 
     // Validate the URL.
     url_ = GURL(url);
     if (!url_.is_valid() || !IsProtocolSupportedForMedia(url_)) {
       DoneInitialization_Locked(false);
       return;
     }
 
     // Post a task to the render thread to start loading the resource.
     render_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &SimpleDataSource::StartTask));
   }
 }
 
 void SimpleDataSource::CancelInitialize() {
   base::AutoLock auto_lock(lock_);
-  DCHECK(initialize_callback_.get());
+  DCHECK(!initialize_cb_.is_null());
   state_ = STOPPED;
-  initialize_callback_.reset();
+  initialize_cb_.Reset();
 
   // Post a task to the render thread to cancel loading the resource.
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &SimpleDataSource::CancelTask));
 }
 
 void SimpleDataSource::Read(int64 position,
                             size_t size,
                             uint8* data,
                             ReadCallback* read_callback) {
@@ skipping 72 matching lines @@
     WebKit::WebURLLoader* loader,
     const char* data,
     int dataLength) {
   NOTIMPLEMENTED();
 }
 
 void SimpleDataSource::didFinishLoading(
     WebKit::WebURLLoader* loader,
     double finishTime) {
   DCHECK(MessageLoop::current() == render_loop_);
-  // 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.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
   {
     base::AutoLock auto_lock(lock_);
     // It's possible this gets called after Stop(), in which case |host_| is no
     // longer valid.
     if (state_ == STOPPED)
       return;
 
     // Otherwise we should be initializing and have created a WebURLLoader.
     DCHECK_EQ(state_, INITIALIZING);
 
     // If we don't get a content length or the request has failed, report it
     // as a network error.
     if (size_ == -1)
       size_ = data_.length();
     DCHECK(static_cast<size_t>(size_) == data_.length());
 
     DoneInitialization_Locked(true);
   }
 }
 
 void SimpleDataSource::didFail(
     WebKit::WebURLLoader* loader,
     const WebKit::WebURLError& error) {
   DCHECK(MessageLoop::current() == render_loop_);
-  // 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.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
   {
     base::AutoLock auto_lock(lock_);
     // It's possible this gets called after Stop(), in which case |host_| is no
     // longer valid.
     if (state_ == STOPPED)
       return;
 
@@ skipping 15 matching lines @@
   return single_origin_;
 }
 
 void SimpleDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
   frame_ = NULL;
 }
 
 void SimpleDataSource::StartTask() {
   DCHECK(MessageLoop::current() == render_loop_);
-  // 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.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
   {
     base::AutoLock auto_lock(lock_);
 
     // We may have stopped.
     if (state_ == STOPPED)
       return;
 
@@ skipping 54 matching lines @@
   if (success) {
     state_ = INITIALIZED;
 
     UpdateHostState();
     status = media::PIPELINE_OK;
   } else {
     state_ = UNINITIALIZED;
     url_loader_.reset();
   }
 
-  scoped_ptr<media::PipelineStatusCallback> initialize_callback(
-      initialize_callback_.release());
-  initialize_callback->Run(status);
+  initialize_cb_.Run(status);
+  initialize_cb_.Reset();
 }
 
 void SimpleDataSource::UpdateHostState() {
   if (host()) {
     host()->SetTotalBytes(size_);
     host()->SetBufferedBytes(size_);
     // If scheme is file or data, say we are loaded.
     host()->SetLoaded(url_.SchemeIsFile() || url_.SchemeIs(kDataScheme));
   }
 }
 
 }  // namespace webkit_glue