Remove use of PipelineStatus from BufferedDataSource and FileDataSource.

webkit/media/buffered_data_source.cc

 // Copyright (c) 2012 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/buffered_data_source.h"
 
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
 
 using WebKit::WebFrame;
 
 namespace {
 
 // BufferedDataSource has an intermediate buffer, this value governs the initial
 // size of that buffer. It is set to 32KB because this is a typical read size
@@ skipping 64 matching lines @@
 
   if (loader_.get()) {
     base::AutoLock auto_lock(lock_);
     UpdateHostState_Locked();
   }
 }
 
 void BufferedDataSource::Initialize(
     const GURL& url,
     BufferedResourceLoader::CORSMode cors_mode,
-    const media::PipelineStatusCB& initialize_cb) {
+    const InitializeCB& init_cb) {
   DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(!initialize_cb.is_null());
+  DCHECK(!init_cb.is_null());
   DCHECK(!loader_.get());
   url_ = url;
   cors_mode_ = cors_mode;
 
-  initialize_cb_ = initialize_cb;
+  init_cb_ = init_cb;
 
   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_.reset(CreateResourceLoader(0, kPositionNotSpecified));
   } else {
     // For all other protocols, assume they support range request. We fetch
     // the full range of the resource to obtain the instance size because
     // we won't be served HTTP headers.
     loader_.reset(CreateResourceLoader(kPositionNotSpecified,
                                        kPositionNotSpecified));
     assume_fully_buffered_ = true;
   }
 
   loader_->Start(
       base::Bind(&BufferedDataSource::StartCallback, this),
       base::Bind(&BufferedDataSource::LoadingStateChangedCallback, this),
       base::Bind(&BufferedDataSource::ProgressCallback, this),
       frame_);
 }
 
 void BufferedDataSource::SetPreload(Preload preload) {
   DCHECK(MessageLoop::current() == render_loop_);
   preload_ = preload;
 }
 
 bool BufferedDataSource::HasSingleOrigin() {
   DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(initialize_cb_.is_null() && loader_.get())
+  DCHECK(init_cb_.is_null() && loader_.get())
       << "Initialize() must complete before calling HasSingleOrigin()";
   return loader_->HasSingleOrigin();
 }
 
 bool BufferedDataSource::DidPassCORSAccessCheck() const {
   return loader_.get() && loader_->DidPassCORSAccessCheck();
 }
 
 void BufferedDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
@@ skipping 86 matching lines @@
 
   // Call to read internal to perform the actual read.
   ReadInternal();
 }
 
 void BufferedDataSource::CleanupTask() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   {
     base::AutoLock auto_lock(lock_);
-    initialize_cb_.Reset();
+    init_cb_.Reset();
     if (stopped_on_render_loop_)
       return;
 
     // Signal that stop task has finished execution.
     // NOTE: it's vital that this be set under lock, as that's how Read() tests
     // before registering a new |read_cb_| (which is cleared below).
     stopped_on_render_loop_ = true;
 
     if (!read_cb_.is_null())
       DoneRead_Locked(kReadError);
@@ skipping 69 matching lines @@
   DCHECK(!read_cb_.is_null());
   DCHECK(bytes_read >= 0 || bytes_read == kReadError);
   lock_.AssertAcquired();
 
   read_cb_.Run(bytes_read);
   read_cb_.Reset();
   read_size_ = 0;
   read_buffer_ = 0;
 }
 
-void BufferedDataSource::DoneInitialization_Locked(
-    media::PipelineStatus status) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(!initialize_cb_.is_null());
-  lock_.AssertAcquired();
-
-  initialize_cb_.Run(status);
-  initialize_cb_.Reset();
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::StartCallback(
     BufferedResourceLoader::Status status) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
-  bool initialize_cb_is_null = false;
+  bool init_cb_is_null = false;
   {
     base::AutoLock auto_lock(lock_);
-    initialize_cb_is_null = initialize_cb_.is_null();
+    init_cb_is_null = init_cb_.is_null();
   }
-  if (initialize_cb_is_null) {
+  if (init_cb_is_null) {
     loader_->Stop();
     return;
   }
 
   // All responses must be successful. Resources that are assumed to be fully
   // buffered must have a known content length.
   bool success = status == BufferedResourceLoader::kOk &&
       (!assume_fully_buffered_ ||
        loader_->instance_size() != kPositionNotSpecified);
 
   if (success) {
     total_bytes_ = loader_->instance_size();
     streaming_ = !assume_fully_buffered_ &&
         (total_bytes_ == kPositionNotSpecified || !loader_->range_supported());
   } else {
     loader_->Stop();
   }
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
   scoped_refptr<BufferedDataSource> destruction_guard(this);
   {
     base::AutoLock auto_lock(lock_);
     if (stop_signal_received_)
       return;
 
-    if (!success) {
-      DoneInitialization_Locked(media::PIPELINE_ERROR_NETWORK);
-      return;
-    }
+    if (success)
+      UpdateHostState_Locked();
 
-    UpdateHostState_Locked();
-    DoneInitialization_Locked(media::PIPELINE_OK);
+    base::ResetAndReturn(&init_cb_).Run(success);
   }
 }
 
 void BufferedDataSource::PartialReadStartCallback(
     BufferedResourceLoader::Status status) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   if (status == BufferedResourceLoader::kOk) {
     // Once the request has started successfully, we can proceed with
@@ skipping 120 matching lines @@
   if (total_bytes_ == kPositionNotSpecified)
     return;
 
   host()->SetTotalBytes(total_bytes_);
 
   if (assume_fully_buffered_)
     host()->AddBufferedByteRange(0, total_bytes_);
 }
 
 }  // namespace webkit_media