Change MediaFilter::Stop() to accept a callback so that Stop() is asynchronous.

media/base/pipeline_impl.h

 // Copyright (c) 2010 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.
 
 #ifndef MEDIA_BASE_PIPELINE_IMPL_H_
 #define MEDIA_BASE_PIPELINE_IMPL_H_
 
 #include <set>
@@ skipping 28 matching lines @@
 //         V                                              |
 //   [ Starting (for each filter) ]                       |
 //         |                                              |
 //         V      Seek()                                  |
 //   [ Started ] --------> [ Pausing (for each filter) ] -'
 //         |                                              |
 //         |   NotifyEnded()                Seek()        |
 //         `-------------> [ Ended ] ---------------------'
 //
 //                  SetError()
-//   [ Any State ] -------------> [ Error ]
-//         |          Stop()
-//         '--------------------> [ Stopped ]
+//   [ Any State ] -------------> [ Stopping (for each filter)]
+//         | Stop()                             |
+//         V                                    V
+//   [ Stopping (for each filter) ]         [ Error ]
+//         |
+//         V
+//   [ Stopped ]
 //
 // Initialization is a series of state transitions from "Created" through each
 // filter initialization state.  When all filter initialization states have
 // completed, we are implicitly in a "Paused" state.  At that point we simulate
 // a Seek() to the beginning of the media to give filters a chance to preroll.
 // From then on the normal Seek() transitions are carried out and we start
 // 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
@@ skipping 46 matching lines @@
     kInitDemuxer,
     kInitAudioDecoder,
     kInitAudioRenderer,
     kInitVideoDecoder,
     kInitVideoRenderer,
     kPausing,
     kSeeking,
     kStarting,
     kStarted,
     kEnded,
+    kStopping,
     kStopped,
     kError,
   };
 
   virtual ~PipelineImpl();
 
   // Reset the state of the pipeline object to the initial state.  This method
   // is used by the constructor, and the Stop() method.
   void ResetState();
 
   // Simple method used to make sure the pipeline is running normally.
   bool IsPipelineOk();
 
   // Helper method to tell whether we are in the state of initializing.
   bool IsPipelineInitializing();
 
-  // Returns true if the given state is one that transitions to the started
-  // state.
-  static bool StateTransitionsToStarted(State state);
+  // Helper method to tell whether we are stopped or in error.
+  bool IsPipelineStopped();
+
+  // Helper method to execute callback from Start() and reset
+  // |filter_factory_|. Called when initialization completes
+  // normally or when pipeline is stopped or error occurs during
+  // initialization.
+  void FinishInitialization();
+
+  // Returns true if the given state is one that transitions to a new state
+  // after iterating through each filter.
+  static bool TransientState(State state);
 
   // Given the current state, returns the next state.
   static State FindNextState(State current);
 
   // FilterHost implementation.
   virtual void SetError(PipelineError error);
   virtual base::TimeDelta GetTime() const;
   virtual base::TimeDelta GetDuration() const;
   virtual void SetTime(base::TimeDelta time);
   virtual void SetDuration(base::TimeDelta duration);
@@ skipping 12 matching lines @@
   // Method called during initialization to insert a mime type into the
   // |rendered_mime_types_| set.
   void InsertRenderedMimeType(const std::string& major_mime_type);
 
   // Method called during initialization to determine if we rendered anything.
   bool HasRenderedMimeTypes() const;
 
   // Callback executed by filters upon completing initialization.
   void OnFilterInitialize();
 
-  // Callback executed by filters upon completing Play(), Pause() or Seek().
+  // Callback executed by filters upon completing Play(), Pause(), Seek(),
+  // or Stop().
   void OnFilterStateTransition();
 
   // 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(FilterFactory* filter_factory,
                  const std::string& url,
                  PipelineCallback* 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
-  // and setting the error code to PIPELINE_STOPPED.
+  // Stops and destroys all filters, placing the pipeline in the kStopped state.
   void StopTask(PipelineCallback* stop_callback);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kError state.
   void ErrorChangedTask(PipelineError 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);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
   void SeekTask(base::TimeDelta time, PipelineCallback* 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();
 
   // Carries out advancing to the next filter during Play()/Pause()/Seek().
   void FilterStateTransitionTask();
 
+  // Carries out stopping filter threads, deleting filters, running
+  // appropriate callbacks, and setting the appropriate pipeline state
+  // depending on whether we performing Stop() or SetError().
+  // Called after all filters have been stopped.
+  void FinishDestroyingFiltersTask();
+
   // Internal methods used in the implementation of the pipeline thread.  All
   // of these methods are only called on the pipeline thread.
 
   // The following template functions make use of the fact that media filter
   // derived interfaces are self-describing in the sense that they all contain
   // the static method filter_type() which returns a FilterType enum that
   // uniquely identifies the filter's interface.  In addition, filters that are
   // specific to audio or video also support a static method major_mime_type()
   // which returns a string of "audio/" or "video/".
   //
@@ skipping 42 matching lines @@
   // stream does not exist.
   template <class Decoder, class Renderer>
   bool CreateRenderer();
 
   // Examine the list of existing filters to find one that supports the
   // specified Filter interface. If one exists, the |filter_out| will contain
   // the filter, |*filter_out| will be NULL.
   template <class Filter>
   void GetFilter(scoped_refptr<Filter>* filter_out) const;
 
-  // Stops every filters, filter host and filter thread and releases all
-  // references to them.
-  void DestroyFilters();
+  // Kicks off stopping filters. Called by StopTask() and ErrorChangedTask().
+  void StartDestroyingFilters();
 
   // Message loop used to execute pipeline tasks.
   MessageLoop* message_loop_;
 
   // Lock used to serialize access for the following data members.
   mutable Lock lock_;
 
   // Whether or not the pipeline is running.
   bool running_;
 
@@ skipping 103 matching lines @@
   // Vector of threads owned by the pipeline and being used by filters.
   typedef std::vector<base::Thread*> FilterThreadVector;
   FilterThreadVector filter_threads_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_