Update AudioRenderer, VideoRenderer, and AudioDecoder Initialize() methods to use PipelineStatusCB.

media/filters/audio_renderer_base.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 "media/filters/audio_renderer_base.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 65 matching lines @@
   // Throw away everything and schedule our reads.
   last_fill_buffer_time_ = base::TimeDelta();
   recieved_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
   // |algorithm_| will request more reads.
   algorithm_->FlushBuffers();
 }
 
 void AudioRendererBase::Initialize(AudioDecoder* decoder,
-                                   const base::Closure& init_callback,
+                                   const PipelineStatusCB& init_callback,
                                    const base::Closure& underflow_callback) {
   DCHECK(decoder);
   DCHECK(!init_callback.is_null());
   DCHECK(!underflow_callback.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
   underflow_callback_ = underflow_callback;
 
   // Create a callback so our algorithm can request more reads.
   base::Closure cb = base::Bind(&AudioRendererBase::ScheduleRead_Locked, this);
 
   // Construct the algorithm.
   algorithm_.reset(new AudioRendererAlgorithmBase());
 
   // Initialize our algorithm with media properties, initial playback rate,
   // and a callback to request more reads from the data source.
   ChannelLayout channel_layout = decoder_->channel_layout();
   int channels = ChannelLayoutToChannelCount(channel_layout);
   int bits_per_channel = decoder_->bits_per_channel();
   int sample_rate = decoder_->samples_per_second();
   algorithm_->Initialize(channels, sample_rate, bits_per_channel, 0.0f, cb);
 
   // Give the subclass an opportunity to initialize itself.
   if (!OnInitialize(bits_per_channel, channel_layout, sample_rate)) {
-    host()->SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
-    init_callback.Run();
+    init_callback.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   // Finally, execute the start callback.
   state_ = kPaused;
-  init_callback.Run();
+  init_callback.Run(PIPELINE_OK);
 }
 
 bool AudioRendererBase::HasEnded() {
   base::AutoLock auto_lock(lock_);
   if (rendered_end_of_stream_) {
     DCHECK(algorithm_->IsQueueEmpty())
         << "Audio queue should be empty if we have rendered end of stream";
   }
   return recieved_end_of_stream_ && rendered_end_of_stream_;
 }
@@ skipping 165 matching lines @@
   base::AutoLock auto_lock(lock_);
   return algorithm_->playback_rate();
 }
 
 bool AudioRendererBase::IsBeforeSeekTime(const scoped_refptr<Buffer>& buffer) {
   return (state_ == kSeeking) && buffer && !buffer->IsEndOfStream() &&
       (buffer->GetTimestamp() + buffer->GetDuration()) < seek_timestamp_;
 }
 
 }  // namespace media