PipelineError is dead. Long live PipelineStatus!

media/base/composite_filter.h

 // 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.
 
 #ifndef MEDIA_BASE_COMPOSITE_FILTER_H_
 #define MEDIA_BASE_COMPOSITE_FILTER_H_
 
 #include "base/task.h"
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
@@ skipping 20 matching lines @@
   virtual void Pause(FilterCallback* pause_callback);
   virtual void Flush(FilterCallback* flush_callback);
   virtual void Stop(FilterCallback* stop_callback);
   virtual void SetPlaybackRate(float playback_rate);
   virtual void Seek(base::TimeDelta time, FilterCallback* seek_callback);
   virtual void OnAudioRendererDisabled();
 
  protected:
   virtual ~CompositeFilter();
 
-  void SetError(PipelineError error);
+  void SetError(PipelineStatus error);
 
  private:
   class FilterHostImpl;
 
   enum State {
     kInvalid,
     kCreated,
     kPaused,
     kPlayPending,
     kStopWhilePlayPending,
@@ skipping 30 matching lines @@
   // Filter callback for a serial sequence.
   void SerialCallback();
 
   // Filter callback for a parallel sequence.
   void ParallelCallback();
 
   // Called when a parallel or serial call sequence completes.
   void OnCallSequenceDone();
 
   // Helper function for sending an error to the FilterHost.
-  void SendErrorToHost(PipelineError error);
+  void SendErrorToHost(PipelineStatus error);
 
   // Helper function for handling errors during call sequences.
-  void HandleError(PipelineError error);
+  void HandleError(PipelineStatus error);
 
   // Creates a callback that can be called from any thread, but is guaranteed
   // to call the specified method on the thread associated with this filter.
   FilterCallback* NewThreadSafeCallback(void (CompositeFilter::*method)());
 
   // Helper function used by NewThreadSafeCallback() to make sure the
   // method gets called on the right thread.
   static void OnCallback(MessageLoop* message_loop,
                          CancelableTask* task);
 
@@ skipping 17 matching lines @@
   // The index of the filter currently processing a request.
   unsigned int sequence_index_;
 
   // Message loop passed into the constructor.
   MessageLoop* message_loop_;
 
   // FilterHost implementation passed to Filters owned by this
   // object.
   scoped_ptr<FilterHostImpl> host_impl_;
 
-  // Error passed in the last SetError() call.
-  PipelineError error_;
+  // PIPELINE_OK, or last error passed to SetError().
+  PipelineStatus status_;
 
   scoped_ptr<ScopedRunnableMethodFactory<CompositeFilter> > runnable_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositeFilter);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_COMPOSITE_FILTER_H_