Clean up Pipeline terminal state logic by merging kError into kStopped state.

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 53 matching lines @@
 struct Pipeline::PipelineInitState {
   scoped_refptr<AudioDecoder> audio_decoder;
   scoped_refptr<VideoDecoder> video_decoder;
 };
 
 Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop->message_loop_proxy()),
       media_log_(media_log),
       running_(false),
       seek_pending_(false),
-      stop_pending_(false),
       tearing_down_(false),
-      error_caused_teardown_(false),
       playback_rate_change_pending_(false),
       did_loading_progress_(false),
       total_bytes_(0),
       natural_size_(0, 0),
       volume_(1.0f),
       playback_rate_(0.0f),
       pending_playback_rate_(0.0f),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
       has_audio_(false),
       has_video_(false),
       state_(kCreated),
       seek_timestamp_(kNoTimestamp()),
       audio_disabled_(false),
       creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
 Pipeline::~Pipeline() {
   base::AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
-  DCHECK(!stop_pending_);
+  DCHECK(stop_cb_.is_null());
   DCHECK(!seek_pending_);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
 void Pipeline::Start(scoped_ptr<FilterCollection> collection,
                      const PipelineStatusCB& ended_cb,
                      const PipelineStatusCB& error_cb,
                      const PipelineStatusCB& start_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
 
   running_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StartTask, this, base::Passed(&collection),
       ended_cb, error_cb, start_cb));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
-  base::AutoLock auto_lock(lock_);
-  CHECK(running_) << "Media pipeline isn't running";
-
-  // Stop the pipeline, which will set |running_| to false on our behalf.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StopTask, this, stop_cb));
 }
 
 void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(running_) << "Media pipeline isn't running";
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::SeekTask, this, time, seek_cb));
 }
 
 bool Pipeline::IsRunning() const {
   base::AutoLock auto_lock(lock_);
   return running_;
 }
 
-bool Pipeline::IsInitialized() const {
-  // TODO(scherkus): perhaps replace this with a bool that is set/get under the
-  // lock, because this is breaching the contract that |state_| is only accessed
-  // on |message_loop_|.
-  base::AutoLock auto_lock(lock_);
-  switch (state_) {
-    case kPausing:
-    case kFlushing:
-    case kSeeking:
-    case kStarting:
-    case kStarted:
-      return true;
-    default:
-      return false;
-  }
-}
-
 bool Pipeline::HasAudio() const {
   base::AutoLock auto_lock(lock_);
   return has_audio_;
 }
 
 bool Pipeline::HasVideo() const {
   base::AutoLock auto_lock(lock_);
   return has_video_;
 }
 
@@ skipping 99 matching lines @@
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
 }
 
 bool Pipeline::IsPipelineOk() {
   base::AutoLock auto_lock(lock_);
   return status_ == PIPELINE_OK;
 }
 
 bool Pipeline::IsPipelineStopped() {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  return state_ == kStopped || state_ == kError;
+  return state_ == kStopped;
 }
 
 bool Pipeline::IsPipelineTearingDown() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   return tearing_down_;
 }
 
 bool Pipeline::IsPipelineStopPending() {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  return stop_pending_;
+  return !stop_cb_.is_null();
 }
 
 bool Pipeline::IsPipelineSeeking() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!seek_pending_)
     return false;
   DCHECK(kSeeking == state_ || kPausing == state_ ||
          kFlushing == state_ || kStarting == state_)
       << "Current state : " << state_;
   return true;
@@ skipping 36 matching lines @@
     // assumption that we never accept Seek() after Stop().
     DCHECK(IsPipelineSeeking() ||
            IsPipelineStopPending() ||
            IsPipelineTearingDown());
     return IsPipelineSeeking() ? kSeeking : kStopping;
   } else if (current == kSeeking) {
     return kStarting;
   } else if (current == kStarting) {
     return kStarted;
   } else if (current == kStopping) {
-    return error_caused_teardown_ ? kError : kStopped;
+    return kStopped;
   } else {
     return current;
   }
 }
 
 void Pipeline::OnDemuxerError(PipelineStatus error) {
   SetError(error);
 }
 
 void Pipeline::SetError(PipelineStatus error) {
@@ skipping 325 matching lines @@
     // Fire a seek request to get the renderers to preroll. We can skip a seek
     // here as the demuxer should be at the start of the stream.
     seek_pending_ = true;
     SetState(kSeeking);
     seek_timestamp_ = demuxer_->GetStartTime();
     DoSeek(seek_timestamp_, true,
            base::Bind(&Pipeline::OnFilterStateTransition, this));
   }
 }
 
-// This method is called as a result of the client calling Pipeline::Stop() or
-// as the result of an error condition.
-// We stop the filters in the reverse order.
-//
-// TODO(scherkus): beware!  this can get posted multiple times since we post
-// Stop() tasks even if we've already stopped.  Perhaps this should no-op for
-// additional calls, however most of this logic will be changing.
 void Pipeline::StopTask(const base::Closure& stop_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!IsPipelineStopPending());
-  DCHECK_NE(state_, kStopped);
+  DCHECK(!stop_cb.is_null());
+
+  if (state_ == kStopped) {
+    stop_cb.Run();
+    return;
+  }
 
   if (video_decoder_) {
     video_decoder_->PrepareForShutdownHack();
     video_decoder_ = NULL;
   }
 
-  if (IsPipelineTearingDown() && error_caused_teardown_) {
+  if (IsPipelineTearingDown() && status_ != PIPELINE_OK) {
     // If we are stopping due to SetError(), stop normally instead of
     // going to error state and calling |error_cb_|. This converts
     // the teardown in progress from an error teardown into one that acts
     // like the error never occurred.
     base::AutoLock auto_lock(lock_);
     status_ = PIPELINE_OK;
-    error_caused_teardown_ = false;
   }
 
   stop_cb_ = stop_cb;
 
-  stop_pending_ = true;
   if (!IsPipelineSeeking() && !IsPipelineTearingDown()) {
     // We will tear down pipeline immediately when there is no seek operation
     // pending and no teardown in progress. This should include the case where
     // we are partially initialized.
     TearDownPipeline();
   }
 }
 
 void Pipeline::ErrorChangedTask(PipelineStatus error) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   // Suppress executing additional error logic. Note that if we are currently
   // performing a normal stop, then we return immediately and continue the
   // normal stop.
   if (IsPipelineStopped() || IsPipelineTearingDown()) {
     return;
   }
 
   base::AutoLock auto_lock(lock_);
   status_ = error;
 
-  error_caused_teardown_ = true;
-
   // Posting TearDownPipeline() to message loop so that we can make sure
   // it runs after any pending callbacks that are already queued.
   // |tearing_down_| is set early here to make sure that pending callbacks
   // don't modify the state before TeadDownPipeline() can run.
   tearing_down_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::TearDownPipeline, this));
 }
 
 void Pipeline::PlaybackRateChangedTask(float playback_rate) {
@@ skipping 199 matching lines @@
 }
 
 void Pipeline::TeardownStateTransitionTask() {
   DCHECK(IsPipelineTearingDown());
   DCHECK(pending_callbacks_.get())
       << "Teardown state transitions must be completed via pending_callbacks_";
   pending_callbacks_.reset();
 
   switch (state_) {
     case kStopping:
-      SetState(error_caused_teardown_ ? kError : kStopped);
+      SetState(kStopped);
       FinishDestroyingFiltersTask();
       break;
     case kPausing:
       SetState(kFlushing);
       DoFlush(base::Bind(&Pipeline::OnTeardownStateTransition, this));
       break;
     case kFlushing:
       SetState(kStopping);
       DoStop(base::Bind(&Pipeline::OnTeardownStateTransition, this));
       break;
 
     case kCreated:
-    case kError:
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoDecoder:
     case kInitVideoRenderer:
     case kSeeking:
     case kStarting:
     case kStopped:
     case kStarted:
       NOTREACHED() << "Unexpected state for teardown: " << state_;
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 void Pipeline::FinishDestroyingFiltersTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(IsPipelineStopped());
 
   audio_renderer_ = NULL;
   video_renderer_ = NULL;
   demuxer_ = NULL;
+  {
+    base::AutoLock l(lock_);
+    running_ = false;
+  }
 
-  if (error_caused_teardown_ && !IsPipelineOk() && !error_cb_.is_null())
+  // We prioritize executing stop callbacks over error callbacks if they're
+  // present.
+  if (!stop_cb_.is_null()) {
+    base::ResetAndReturn(&stop_cb_).Run();
+  } else if (!error_cb_.is_null() && status_ != PIPELINE_OK) {
     error_cb_.Run(status_);
-
-  if (stop_pending_) {
-    stop_pending_ = false;
-    {
-      base::AutoLock l(lock_);
-      running_ = false;
-    }
-
-    // Notify the client that stopping has finished.
-    base::ResetAndReturn(&stop_cb_).Run();
   }
 
   tearing_down_ = false;
-  error_caused_teardown_ = false;
 }
 
 void Pipeline::InitializeDemuxer() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(IsPipelineOk());
 
   demuxer_ = filter_collection_->GetDemuxer();
   if (!demuxer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
@@ skipping 127 matching lines @@
       base::Bind(&Pipeline::SetError, this),
       base::Bind(&Pipeline::GetMediaTime, this),
       base::Bind(&Pipeline::GetMediaDuration, this));
   return true;
 }
 
 void Pipeline::TearDownPipeline() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(kStopped, state_);
 
-  DCHECK(!tearing_down_ ||  // Teardown on Stop().
-         (tearing_down_ && error_caused_teardown_) ||  // Teardown on error.
-         (tearing_down_ && stop_pending_));  // Stop during teardown by error.
+  // We're either...
+  //   1) ...tearing down due to Stop() (it doesn't set tearing_down_)
+  //   2) ...tearing down due to an error (it does set tearing_down_)
+  //   3) ...tearing down due to an error and Stop() was called
+  DCHECK(!tearing_down_ && !stop_cb_.is_null() ||
+         (tearing_down_ && status_ != PIPELINE_OK) ||
+         (tearing_down_ && !stop_cb_.is_null()));
 
   // Mark that we already start tearing down operation.
   tearing_down_ = true;
 
   // Cancel any pending operation so we can proceed with teardown.
   pending_callbacks_.reset();
 
   switch (state_) {
     case kCreated:
-    case kError:
       SetState(kStopped);
       // Need to put this in the message loop to make sure that it comes
       // after any pending callback tasks that are already queued.
       message_loop_->PostTask(FROM_HERE, base::Bind(
           &Pipeline::FinishDestroyingFiltersTask, this));
       break;
 
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
@@ skipping 79 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media