PipelineError is dead. Long live PipelineStatus!

media/base/pipeline.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.
 
 // The pipeline is the public API clients use for playing back media.  Clients
 // provide a filter collection containing the filters they want the pipeline to
 // use to render media.
 
 #ifndef MEDIA_BASE_PIPELINE_H_
 #define MEDIA_BASE_PIPELINE_H_
@@ skipping 18 matching lines @@
   }
 
   uint32 audio_bytes_decoded; // Should be uint64?
   uint32 video_bytes_decoded; // Should be uint64?
   uint32 video_frames_decoded;
   uint32 video_frames_dropped;
 };
 
 class FilterCollection;
 
-// Client-provided callbacks for various pipeline operations.  Clients should
-// inspect the Pipeline for errors.
-typedef Callback0::Type PipelineCallback;
-
 class Pipeline : public base::RefCountedThreadSafe<Pipeline> {
  public:
   // Initializes pipeline. Pipeline takes ownership of all callbacks passed
   // into this method.
   // |ended_callback| will be executed when the media reaches the end.
   // |error_callback_| will be executed upon an error in the pipeline.
   // |network_callback_| will be executed when there's a network event.
-  virtual void Init(PipelineCallback* ended_callback,
-                    PipelineCallback* error_callback,
-                    PipelineCallback* network_callback) = 0;
+  virtual void Init(PipelineStatusCallback* ended_callback,
+                    PipelineStatusCallback* error_callback,
+                    PipelineStatusCallback* network_callback) = 0;
 
   // Build a pipeline to render the given URL using the given filter collection
   // to construct a filter chain.  Returns true if successful, false otherwise
   // (i.e., pipeline already started).  Note that a return value of true
   // only indicates that the initialization process has started successfully.
   // Pipeline initialization is an inherently asynchronous process.  Clients can
   // either poll the IsInitialized() method (discouraged) or use the
   // |start_callback| as described below.
   //
   // This method is asynchronous and can execute a callback when completed.
   // If the caller provides a |start_callback|, it will be called when the
-  // pipeline initialization completes.  Clients are expected to call GetError()
-  // to check whether initialization succeeded.
+  // pipeline initialization completes.
   virtual bool Start(FilterCollection* filter_collection,
                      const std::string& url,
-                     PipelineCallback* start_callback) = 0;
+                     PipelineStatusCallback* start_callback) = 0;
 
   // Asynchronously stops the pipeline and resets it to an uninitialized state.
   // If provided, |stop_callback| will be executed when the pipeline has been
   // completely torn down and reset to an uninitialized state.  It is acceptable
   // to call Start() again once the callback has finished executing.
   //
   // Stop() must be called before destroying the pipeline.  Clients can
   // determine whether Stop() must be called by checking IsRunning().
   //
   // TODO(scherkus): ideally clients would destroy the pipeline after calling
   // Stop() and create a new pipeline as needed.
-  virtual void Stop(PipelineCallback* stop_callback) = 0;
+  virtual void Stop(PipelineStatusCallback* stop_callback) = 0;
 
   // Attempt to seek to the position specified by time.  |seek_callback| will be
   // executed when the all filters in the pipeline have processed the seek.
   //
   // Clients are expected to call GetCurrentTime() to check whether the seek
   // succeeded.
-  virtual void Seek(base::TimeDelta time, PipelineCallback* seek_callback) = 0;
+  virtual void Seek(base::TimeDelta time,
+                    PipelineStatusCallback* seek_callback) = 0;
 
   // Returns true if the pipeline has been started via Start().  If IsRunning()
   // returns true, it is expected that Stop() will be called before destroying
   // the pipeline.
   virtual bool IsRunning() const = 0;
 
   // Returns true if the pipeline has been started and fully initialized to a
   // point where playback controls will be respected.  Note that it is possible
   // for a pipeline to be started but not initialized (i.e., an error occurred).
   virtual bool IsInitialized() const = 0;
@@ skipping 55 matching lines @@
   virtual void GetVideoSize(size_t* width_out, size_t* height_out) const = 0;
 
   // If this method returns true, that means the data source is a streaming
   // data source. Seeking may not be possible.
   virtual bool IsStreaming() const = 0;
 
   // If this method returns true, that means the data source has fully loaded
   // the media and that the network is no longer needed.
   virtual bool IsLoaded() const = 0;
 
-  // Gets the current error status for the pipeline.  If the pipeline is
-  // operating correctly, this will return OK.
-  virtual PipelineError GetError() const = 0;
-
   // Gets the current pipeline statistics.
   virtual PipelineStatistics GetStatistics() const = 0;
 
  protected:
   // Only allow ourselves to be deleted by reference counting.
   friend class base::RefCountedThreadSafe<Pipeline>;
   virtual ~Pipeline() {}
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_H_