Implementation of Pipeline and FilterHost interfaces. This is a large change...

media/base/factory.h

 // Copyright (c) 2006-2009 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.
 
 // A filter factory handles the creation of filters given a FilterType (i.e.,
 // FILTER_AUDIO_DECODER) and a MediaFormat.  Generally a filter factory handles
 // creating a single type of filter, with multiple factories combined into a
 // FilterFactoryCollection.  We use some template tricks to enforce type-safety
 // and eliminate casting for callers.
 //
@@ skipping 29 matching lines @@
 class FilterFactoryCollection;
 
 class FilterFactory : public base::RefCountedThreadSafe<FilterFactory> {
  public:
   // Creates a filter implementing the specified interface.  Hides the casting
   // and FilterType constants from the callers and produces cleaner code:
   //   AudioDecoder* filter = NULL;
   //   bool success = Create<AudioDecoder>(media_format, &filter);
   template <class T>
   bool Create(const MediaFormat* media_format, T** filter_out) {
-    return Create(T::kFilterType, media_format,
+    return Create(T::filter_type(), media_format,
                   reinterpret_cast<MediaFilter**>(filter_out));
   }
 
  protected:
   // For accessing the protected version of Create.
   friend class FilterFactoryCollection;
 
   // Attempt to create a filter of the given type using the information stored
   // in |media_format|.  If successful, the filter is assigned to |filter_out|
   // and the method returns true.  If the filter cannot be created for any
   // reason, |filter_out| is assigned NULL and false it returned.
   //
   // It is assumed that |filter_out| can be safely casted to the corresponding
   // interface type (i.e., FILTER_AUDIO_DECODER -> AudioDecoder).
   virtual bool Create(FilterType filter_type, const MediaFormat* media_format,
                       MediaFilter** filter_out) = 0;
 
   friend class base::RefCountedThreadSafe<FilterFactory>;
   virtual ~FilterFactory() {}
 };
 
 
 // Helper template class for implementing trivial filter factories.  If your
 // filter does not require any special handling during creation, you can create
 // a factory for it using this class.  It requires the following static method:
 //   bool Create(MediaFormat* media_format, YourFilterType** filter_out)
 //
 // You can create the filter factory like so:
 //   new TypeFilterFactory<YourFilterType>()
-template <class T>
+template <class Filter>
 class TypeFilterFactory : public FilterFactory {
  public:
   TypeFilterFactory() {}
 
  protected:
   // Attempts to create a filter of the template type.  Assumes a static method
   // Create is declared.
   virtual bool Create(FilterType filter_type, const MediaFormat* media_format,
                       MediaFilter** filter_out) {
-    T* typed_out;
-    if (T::kFilterType == filter_type && T::Create(media_format, &typed_out)) {
-      *filter_out = typed_out;
+    Filter* filter;
+    if (Filter::filter_type() == filter_type &&
+        Filter::Create(media_format, &filter)) {
+      *filter_out = filter;
       return true;
     }
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TypeFilterFactory);
 };
 
 
@@ skipping 24 matching lines @@
  private:
   typedef std::vector< scoped_refptr<FilterFactory> > FactoryVector;
   FactoryVector factories_;
 
   DISALLOW_COPY_AND_ASSIGN(FilterFactoryCollection);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_FACTORY_H_