Splitting media filter's Initialize() into Create() + callback and Seek() + callback.

media/filters/audio_renderer_base.cc

 // Copyright (c) 2009 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/base/filter_host.h"
 #include "media/filters/audio_renderer_base.h"
 
 namespace media {
 
 // The maximum size of the queue, which also acts as the number of initial reads
@@ skipping 20 matching lines @@
 }
 
 void AudioRendererBase::Stop() {
   OnStop();
 
   AutoLock auto_lock(lock_);
   queue_.clear();
   stopped_ = true;
 }
 
-void AudioRendererBase::Seek(base::TimeDelta time) {
+void AudioRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
   AutoLock auto_lock(lock_);
   last_fill_buffer_time_ = base::TimeDelta();
 
   // Clear the queue of decoded packets and release the buffers. Fire as many
   // reads as buffers released. It is safe to schedule reads here because
   // demuxer and decoders should have received the seek signal.
   // TODO(hclam): we should preform prerolling again after each seek to avoid
   // glitch or clicking of audio.
   while (!queue_.empty()) {
     queue_.pop_front();
     ScheduleRead();
   }
 }
 
-bool AudioRendererBase::Initialize(AudioDecoder* decoder) {
+void AudioRendererBase::Initialize(AudioDecoder* decoder,
+                                   FilterCallback* callback) {
   DCHECK(decoder);
+  DCHECK(callback);
   decoder_ = decoder;
+  initialize_callback_.reset(callback);
 
   // Schedule our initial reads.
   for (size_t i = 0; i < max_queue_size_; ++i) {
     ScheduleRead();
   }
 
   // Defer initialization until all scheduled reads have completed.
-  return OnInitialize(decoder_->media_format());
+  if (!OnInitialize(decoder_->media_format())) {
+    host()->Error(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    initialize_callback_->Run();
+    initialize_callback_.reset();
+  }
 }
 
 void AudioRendererBase::OnReadComplete(Buffer* buffer_in) {
   bool initialization_complete = false;
   {
     AutoLock auto_lock(lock_);
     // If we have stopped don't enqueue, same for end of stream buffer since
     // it has no data.
     if (!stopped_ && !buffer_in->IsEndOfStream()) {
       queue_.push_back(buffer_in);
       DCHECK(queue_.size() <= max_queue_size_);
     }
 
     if (!initialized_) {
       // We have completed the initialization when we preroll enough and hit
       // the target queue size or the stream has ended.
       if (queue_.size() == max_queue_size_ || buffer_in->IsEndOfStream())
         initialization_complete = true;
     }
   }
 
   if (initialization_complete) {
     if (queue_.empty()) {
       // If we say we have initialized but buffer queue is empty, raise an
       // error.
       host()->Error(PIPELINE_ERROR_NO_DATA);
     } else {
       initialized_ = true;
-      host()->InitializationComplete();
     }
+    initialize_callback_->Run();
+    initialize_callback_.reset();
   }
 }
 
 // TODO(scherkus): clean up FillBuffer().. it's overly complex!!
 size_t AudioRendererBase::FillBuffer(uint8* dest,
                                      size_t dest_len,
                                      float rate,
                                      const base::TimeDelta& playback_delay) {
   size_t buffers_released = 0;
   size_t dest_written = 0;
@@ skipping 121 matching lines @@
   // TODO(scherkus): might be handy to support NULL parameters.
   std::string mime_type;
   return media_format.GetAsString(MediaFormat::kMimeType, &mime_type) &&
       media_format.GetAsInteger(MediaFormat::kChannels, channels_out) &&
       media_format.GetAsInteger(MediaFormat::kSampleRate, sample_rate_out) &&
       media_format.GetAsInteger(MediaFormat::kSampleBits, sample_bits_out) &&
       mime_type.compare(mime_type::kUncompressedAudio) == 0;
 }
 
 }  // namespace media