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

media/filters/video_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/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/filters/video_renderer_base.h"
 
 namespace media {
 
@@ skipping 63 matching lines @@
     }
     thread_ = NULL;
   }
 }
 
 void VideoRendererBase::SetPlaybackRate(float playback_rate) {
   AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
-void VideoRendererBase::Seek(base::TimeDelta time) {
+void VideoRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
   AutoLock auto_lock(lock_);
   // We need the first frame in |frames_| to run the VideoRendererBase main
   // loop, but we don't need decoded frames after the first frame since we are
   // at a new time. We should get some new frames so issue reads to compensate
   // for those discarded.
   while (frames_.size() > 1) {
     frames_.pop_back();
     ScheduleRead();
   }
 }
 
-bool VideoRendererBase::Initialize(VideoDecoder* decoder) {
+void VideoRendererBase::Initialize(VideoDecoder* decoder,
+                                   FilterCallback* callback) {
   AutoLock auto_lock(lock_);
+  DCHECK(decoder);
+  DCHECK(callback);
   DCHECK_EQ(state_, UNINITIALIZED);
   state_ = INITIALIZING;
   decoder_ = decoder;
+  initialize_callback_.reset(callback);
 
   // Notify the pipeline of the video dimensions.
   int width = 0;
   int height = 0;
-  if (!ParseMediaFormat(decoder->media_format(), &width, &height))
-    return false;
+  if (!ParseMediaFormat(decoder->media_format(), &width, &height)) {
+    host()->Error(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    initialize_callback_->Run();
+    initialize_callback_.reset();
+    return;
+  }
   host()->SetVideoSize(width, height);
 
   // Initialize the subclass.
   // TODO(scherkus): do we trust subclasses not to do something silly while
   // we're holding the lock?
-  if (!OnInitialize(decoder))
-    return false;
+  if (!OnInitialize(decoder)) {
+    host()->Error(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    initialize_callback_->Run();
+    initialize_callback_.reset();
+    return;
+  }
 
   // Create our video thread.
   if (!PlatformThread::Create(0, this, &thread_)) {
     NOTREACHED() << "Video thread creation failed";
-    return false;
+    host()->Error(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    initialize_callback_->Run();
+    initialize_callback_.reset();
+    return;
   }
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
   ::SetThreadPriority(thread_, THREAD_PRIORITY_ABOVE_NORMAL);
 #endif  // defined(OS_WIN)
 
   // Queue initial reads.
   for (size_t i = 0; i < kMaxFrames; ++i) {
     ScheduleRead();
   }
-
-  return true;
 }
 
 // PlatformThread::Delegate implementation.
 void VideoRendererBase::ThreadMain() {
   PlatformThread::SetName("VideoThread");
 
   // Wait to be initialized so we can notify the first frame is available.
   if (!WaitForInitialized())
     return;
   OnFrameAvailable();
@@ skipping 98 matching lines @@
     DCHECK_LE(frames_.size(), kMaxFrames);
     frame_available_.Signal();
   }
 
   // Check for our initialization condition.
   if (state_ == INITIALIZING &&
       (frames_.size() == kMaxFrames || frame->IsEndOfStream())) {
     if (frames_.empty()) {
       // We should have initialized but there's no decoded frames in the queue.
       // Raise an error.
+      state_ = ERRORED;
       host()->Error(PIPELINE_ERROR_NO_DATA);
+      initialize_callback_->Run();
+      initialize_callback_.reset();
     } else {
       state_ = INITIALIZED;
       current_frame_ = frames_.front();
-      host()->InitializationComplete();
+      initialize_callback_->Run();
+      initialize_callback_.reset();
     }
   }
 }
 
 void VideoRendererBase::ScheduleRead() {
   decoder_->Read(NewCallback(this, &VideoRendererBase::OnReadComplete));
 }
 
 bool VideoRendererBase::WaitForInitialized() {
   // This loop essentially handles preroll.  We wait until we've been fully
   // initialized so we can call OnFrameAvailable() to provide subclasses with
   // the first frame.
   AutoLock auto_lock(lock_);
-  DCHECK_EQ(state_, INITIALIZING);
   while (state_ == INITIALIZING) {
     frame_available_.Wait();
-    if (state_ == STOPPED) {
-      return false;
-    }
+  }
+  if (state_ == STOPPED || state_ == ERRORED) {
+    return false;
   }
   DCHECK_EQ(state_, INITIALIZED);
   DCHECK(current_frame_);
   return true;
 }
 
 }  // namespace media