Migrate Pipeline & PipelineImpl to PipelineStatusCB.

media/base/pipeline_impl.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.
 
 // Implementation of Pipeline & PipelineStatusNotification (an async-to-sync
 // callback adapter).
 
 #ifndef MEDIA_BASE_PIPELINE_IMPL_H_
 #define MEDIA_BASE_PIPELINE_IMPL_H_
 
@@ skipping 21 matching lines @@
 // |Callback()| to the Pipeline method requiring a callback.  Then Wait() for
 // the callback to get fired and call status() to see what the callback's
 // argument was.  This object is for one-time use; call |Callback()| exactly
 // once.
 class PipelineStatusNotification {
  public:
   PipelineStatusNotification();
   ~PipelineStatusNotification();
 
   // See class-level comment for usage.
-  media::PipelineStatusCallback* Callback();
-  void Notify(media::PipelineStatus status);
+  PipelineStatusCB Callback();
   void Wait();
-  media::PipelineStatus status();
+  PipelineStatus status();
 
  private:
+  void Notify(media::PipelineStatus status);
+
   base::Lock lock_;
   base::ConditionVariable cv_;
   media::PipelineStatus status_;
   bool notified_;
-  scoped_ptr<media::PipelineStatusCallback> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineStatusNotification);
 };
 
 // PipelineImpl runs the media pipeline.  Filters are created and called on the
 // message loop injected into this object. PipelineImpl works like a state
 // machine to perform asynchronous initialization, pausing, seeking and playing.
 //
 // Here's a state diagram that describes the lifetime of this object.
 //
@@ skipping 26 matching lines @@
 // playing the media.
 //
 // If any error ever happens, this object will transition to the "Error" state
 // from any state. If Stop() is ever called, this object will transition to
 // "Stopped" state.
 class PipelineImpl : public Pipeline, public FilterHost {
  public:
   explicit PipelineImpl(MessageLoop* message_loop);
 
   // Pipeline implementation.
-  virtual void Init(PipelineStatusCallback* ended_callback,
-                    PipelineStatusCallback* error_callback,
-                    PipelineStatusCallback* network_callback);
+  virtual void Init(const PipelineStatusCB& ended_callback,
+                    const PipelineStatusCB& error_callback,
+                    const PipelineStatusCB& network_callback);
   virtual bool Start(FilterCollection* filter_collection,
                      const std::string& uri,
-                     PipelineStatusCallback* start_callback);
-  virtual void Stop(PipelineStatusCallback* stop_callback);
+                     const PipelineStatusCB& start_callback);
+  virtual void Stop(const PipelineStatusCB& stop_callback);
   virtual void Seek(base::TimeDelta time,
-                    PipelineStatusCallback* seek_callback);
+                    const PipelineStatusCB& seek_callback);
   virtual bool IsRunning() const;
   virtual bool IsInitialized() const;
   virtual bool IsNetworkActive() const;
   virtual bool HasAudio() const;
   virtual bool HasVideo() const;
   virtual float GetPlaybackRate() const;
   virtual void SetPlaybackRate(float playback_rate);
   virtual float GetVolume() const;
   virtual void SetVolume(float volume);
   virtual void SetPreload(Preload preload);
@@ skipping 97 matching lines @@
   void OnTeardownStateTransition();
 
   // Callback executed by filters to update statistics.
   void OnUpdateStatistics(const PipelineStatistics& stats);
 
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the PipelineInternal's
   // message loop.
   void StartTask(FilterCollection* filter_collection,
                  const std::string& url,
-                 PipelineStatusCallback* start_callback);
+                 const PipelineStatusCB& start_callback);
 
   // InitializeTask() performs initialization in multiple passes. It is executed
   // as a result of calling Start() or InitializationComplete() that advances
   // initialization to the next state. It works as a hub of state transition for
   // initialization.
   void InitializeTask();
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
-  void StopTask(PipelineStatusCallback* stop_callback);
+  void StopTask(const PipelineStatusCB& stop_callback);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kError state.
   void ErrorChangedTask(PipelineStatus error);
 
   // Carries out notifying filters that the playback rate has changed.
   void PlaybackRateChangedTask(float playback_rate);
 
   // Carries out notifying filters that the volume has changed.
   void VolumeChangedTask(float volume);
 
   // Returns media preload value.
   virtual Preload GetPreload() const;
 
   // Carries out notifying filters that the preload value has changed.
   void PreloadChangedTask(Preload preload);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
-  void SeekTask(base::TimeDelta time, PipelineStatusCallback* seek_callback);
+  void SeekTask(base::TimeDelta time, const PipelineStatusCB& seek_callback);
 
   // Carries out handling a notification from a filter that it has ended.
   void NotifyEndedTask();
 
   // Carries out handling a notification of network event.
   void NotifyNetworkEventTask();
 
   // Carries out disabling the audio renderer.
   void DisableAudioRendererTask();
 
@@ skipping 158 matching lines @@
   // TODO(vrk): This is a hack.
   base::TimeDelta max_buffered_time_;
 
   // Filter collection as passed in by Start().
   scoped_ptr<FilterCollection> filter_collection_;
 
   // URL for the data source as passed in by Start().
   std::string url_;
 
   // Callbacks for various pipeline operations.
-  scoped_ptr<PipelineStatusCallback> seek_callback_;
-  scoped_ptr<PipelineStatusCallback> stop_callback_;
-  scoped_ptr<PipelineStatusCallback> ended_callback_;
-  scoped_ptr<PipelineStatusCallback> error_callback_;
-  scoped_ptr<PipelineStatusCallback> network_callback_;
+  PipelineStatusCB seek_callback_;
+  PipelineStatusCB stop_callback_;
+  PipelineStatusCB ended_callback_;
+  PipelineStatusCB error_callback_;
+  PipelineStatusCB network_callback_;
 
   // Reference to the filter(s) that constitute the pipeline.
   scoped_refptr<Filter> pipeline_filter_;
 
   // Renderer references used for setting the volume and determining
   // when playback has finished.
   scoped_refptr<AudioRenderer> audio_renderer_;
   scoped_refptr<VideoRenderer> video_renderer_;
 
   // Demuxer reference used for setting the preload value.
   scoped_refptr<Demuxer> demuxer_;
 
   // Helper class that stores filter references during pipeline
   // initialization.
   class PipelineInitState;
   scoped_ptr<PipelineInitState> pipeline_init_state_;
 
   // Statistics.
   PipelineStatistics statistics_;
 
   FRIEND_TEST_ALL_PREFIXES(PipelineImplTest, GetBufferedTime);
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_