PipelineError is dead. Long live PipelineStatus!

media/base/composite_filter.cc

 // Copyright (c) 2011 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/composite_filter.h"
 
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "media/base/callback.h"
 
 namespace media {
 
 class CompositeFilter::FilterHostImpl : public FilterHost {
  public:
   FilterHostImpl(CompositeFilter* parent, FilterHost* host);
 
   FilterHost* host();
 
   // media::FilterHost methods.
-  virtual void SetError(PipelineError error);
+  virtual void SetError(PipelineStatus error);
   virtual base::TimeDelta GetTime() const;
   virtual base::TimeDelta GetDuration() const;
   virtual void SetTime(base::TimeDelta time);
   virtual void SetDuration(base::TimeDelta duration);
   virtual void SetBufferedTime(base::TimeDelta buffered_time);
   virtual void SetTotalBytes(int64 total_bytes);
   virtual void SetBufferedBytes(int64 buffered_bytes);
   virtual void SetVideoSize(size_t width, size_t height);
   virtual void SetStreaming(bool streaming);
   virtual void NotifyEnded();
   virtual void SetLoaded(bool loaded);
   virtual void SetNetworkActivity(bool network_activity);
   virtual void DisableAudioRenderer();
   virtual void SetCurrentReadPosition(int64 offset);
   virtual int64 GetCurrentReadPosition();
 
  private:
   CompositeFilter* parent_;
   FilterHost* host_;
 
   DISALLOW_COPY_AND_ASSIGN(FilterHostImpl);
 };
 
 CompositeFilter::CompositeFilter(MessageLoop* message_loop)
     : state_(kCreated),
       sequence_index_(0),
       message_loop_(message_loop),
-      error_(PIPELINE_OK) {
+      status_(PIPELINE_OK) {
   DCHECK(message_loop);
   runnable_factory_.reset(
       new ScopedRunnableMethodFactory<CompositeFilter>(this));
 }
 
 CompositeFilter::~CompositeFilter() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(state_ == kCreated || state_ == kStopped);
 
   filters_.clear();
@@ skipping 162 matching lines @@
   }
 }
 
 void CompositeFilter::ChangeState(State new_state) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   state_ = new_state;
 }
 
 void CompositeFilter::StartSerialCallSequence() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  error_ = PIPELINE_OK;
+  status_ = PIPELINE_OK;
 
   if (!filters_.empty()) {
     sequence_index_ = 0;
     CallFilter(filters_[sequence_index_],
                NewThreadSafeCallback(&CompositeFilter::SerialCallback));
   } else {
     sequence_index_ = 0;
     SerialCallback();
   }
 }
 
 void CompositeFilter::StartParallelCallSequence() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  error_ = PIPELINE_OK;
+  status_ = PIPELINE_OK;
 
   if (!filters_.empty()) {
     sequence_index_ = 0;
     for (size_t i = 0; i < filters_.size(); i++) {
       CallFilter(filters_[i],
                  NewThreadSafeCallback(&CompositeFilter::ParallelCallback));
     }
   } else {
     sequence_index_ = 0;
     ParallelCallback();
@@ skipping 66 matching lines @@
       break;
 
     // default: intentionally left out to catch missing states.
   }
 
   return ret;
 }
 
 void CompositeFilter::SerialCallback() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  if (error_ != PIPELINE_OK) {
+  if (status_ != PIPELINE_OK) {
     // We encountered an error. Terminate the sequence now.
     ChangeState(kError);
-    HandleError(error_);
+    HandleError(status_);
     return;
   }
 
   if (!filters_.empty())
     sequence_index_++;
 
   if (sequence_index_ == filters_.size()) {
     // All filters have been successfully called without error.
     OnCallSequenceDone();
   } else if (GetNextState(state_) == kStopPending) {
     // Abort sequence early and start issuing Stop() calls.
     ChangeState(kStopPending);
     StartSerialCallSequence();
   } else {
     // We aren't done with the sequence. Call the next filter.
     CallFilter(filters_[sequence_index_],
                NewThreadSafeCallback(&CompositeFilter::SerialCallback));
   }
 }
 
 void CompositeFilter::ParallelCallback() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (!filters_.empty())
     sequence_index_++;
 
   if (sequence_index_ == filters_.size()) {
-    if (error_ != PIPELINE_OK) {
+    if (status_ != PIPELINE_OK) {
       // We encountered an error.
       ChangeState(kError);
-      HandleError(error_);
+      HandleError(status_);
       return;
     }
 
     OnCallSequenceDone();
   }
 }
 
 void CompositeFilter::OnCallSequenceDone() {
   State next_state = GetNextState(state_);
 
   if (next_state == kInvalid) {
     // We somehow got into an unexpected state.
     ChangeState(kError);
     HandleError(PIPELINE_ERROR_INVALID_STATE);
   }
 
   ChangeState(next_state);
 
   if (state_ == kStopPending) {
     // Handle a deferred Stop().
     StartSerialCallSequence();
   } else {
     // Call the callback to indicate that the operation has completed.
     DispatchPendingCallback();
   }
 }
 
-void CompositeFilter::SendErrorToHost(PipelineError error) {
+void CompositeFilter::SendErrorToHost(PipelineStatus error) {
   if (host_impl_.get())
     host_impl_.get()->host()->SetError(error);
 }
 
-void CompositeFilter::HandleError(PipelineError error) {
-  if (error != PIPELINE_OK) {
-    SendErrorToHost(error);
-  }
-
+void CompositeFilter::HandleError(PipelineStatus error) {
+  DCHECK_NE(error, PIPELINE_OK);
+  SendErrorToHost(error);
   DispatchPendingCallback();
 }
 
 FilterCallback* CompositeFilter::NewThreadSafeCallback(
     void (CompositeFilter::*method)()) {
   return TaskToCallbackAdapter::NewCallback(
       NewRunnableFunction(&CompositeFilter::OnCallback,
                           message_loop_,
                           runnable_factory_->NewRunnableMethod(method)));
 }
@@ skipping 14 matching lines @@
   }
 
   task->Run();
   delete task;
 }
 
 bool CompositeFilter::CanForwardError() {
   return (state_ == kCreated) || (state_ == kPlaying) || (state_ == kPaused);
 }
 
-void CompositeFilter::SetError(PipelineError error) {
+void CompositeFilter::SetError(PipelineStatus error) {
   // TODO(acolwell): Temporary hack to handle errors that occur
   // during filter initialization. In this case we just forward
   // the error to the host even if it is on the wrong thread. We
   // have to do this because if we defer the call, we can't be
   // sure the host will get the error before the "init done" callback
   // is executed. This will be cleaned up when filter init is refactored.
   if (state_ == kCreated) {
     SendErrorToHost(error);
     return;
   }
 
   if (message_loop_ != MessageLoop::current()) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &CompositeFilter::SetError, error));
     return;
   }
 
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Drop errors recieved while stopping or stopped.
   // This shields the owner of this object from having
   // to deal with errors it can't do anything about.
   if (state_ == kStopPending || state_ == kStopped)
     return;
 
-  error_ = error;
+  status_ = error;
   if (CanForwardError())
     SendErrorToHost(error);
 }
 
 CompositeFilter::FilterHostImpl::FilterHostImpl(CompositeFilter* parent,
                                                 FilterHost* host)
     : parent_(parent),
       host_(host) {
 }
 
 FilterHost* CompositeFilter::FilterHostImpl::host() {
   return host_;
 }
 
 // media::FilterHost methods.
-void CompositeFilter::FilterHostImpl::SetError(PipelineError error) {
+void CompositeFilter::FilterHostImpl::SetError(PipelineStatus error) {
   parent_->SetError(error);
 }
 
 base::TimeDelta CompositeFilter::FilterHostImpl::GetTime() const {
   return host_->GetTime();
 }
 
 base::TimeDelta CompositeFilter::FilterHostImpl::GetDuration() const {
   return host_->GetDuration();
 }
@@ skipping 47 matching lines @@
 
 void CompositeFilter::FilterHostImpl::SetCurrentReadPosition(int64 offset) {
   host_->SetCurrentReadPosition(offset);
 }
 
 int64 CompositeFilter::FilterHostImpl::GetCurrentReadPosition() {
   return host_->GetCurrentReadPosition();
 }
 
 }  // namespace media