First patch in making destructors of refcounted objects private.

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 64 matching lines @@
  public:
   FilterFactoryCollection() {}
 
   // Adds a factory to the end of the collection.
   void AddFactory(FilterFactory* factory) {
     factories_.push_back(factory);
   }
 
  protected:
   // Attempts to create a filter by walking down the list of filter factories.
   MediaFilter* Create(FilterType filter_type, const MediaFormat& media_format) {

[M-A Ruel, 2009/11/05 20:31:28]

virtual

     MediaFilter* filter = NULL;
     for (FactoryVector::iterator factory = factories_.begin();
          !filter && factory != factories_.end();
          ++factory) {
       filter = (*factory)->Create(filter_type, media_format);
     }
     return filter;
   }
 
  private:
+  ~FilterFactoryCollection() {}

[M-A Ruel, 2009/11/05 20:31:28]

virtual

[jam, 2009/11/05 21:52:37]

no child classes.  if they get added in the future, they'll get a compile time
error and can mark this as non-virtual.  before there was no destructor
specified anyways, so this matches the same behavior

+
   typedef std::vector< scoped_refptr<FilterFactory> > FactoryVector;
   FactoryVector factories_;
 
   DISALLOW_COPY_AND_ASSIGN(FilterFactoryCollection);
 };
 
 //-----------------------------------------------------------------------------
 
 // This template is used by classes to implement a type-safe filter factory.
 // If the derived class needs to examine the |media_format| passed to the
@@ skipping 10 matching lines @@
                               const MediaFormat& media_format) {
     Filter* filter = NULL;
     if (Filter::filter_type() == filter_type &&
         Filter::IsMediaFormatSupported(media_format)) {
       filter = new Filter();
     }
     return filter;
   }
 
  private:
+  ~FilterFactoryImpl0() {}

[M-A Ruel, 2009/11/05 20:31:28]

virtual

+
   DISALLOW_COPY_AND_ASSIGN(FilterFactoryImpl0);
 };
 
 // This template can be used by classes that need to be constructed with a
 // parameter that needs to be used in the construction of the actual filter.
 // This would usually be a "parent" object which the instantiated filter needs
 // to communicate with.  The class's CreateFactory method would look like:
 //   static FilterFactory* CreateFactory(MyRequiredParentClass* parent) {
 //      return new FilterFactoryImpl1<MyClass>(parent);
 //   }
 // The class would be constructed with the same pointer passed to the
 // CreateFactory method.
 template <class Filter, class A>
 class FilterFactoryImpl1 : public FilterFactory {
  public:
   explicit FilterFactoryImpl1(A a) : a_(a) {}
 
  protected:
   virtual MediaFilter* Create(FilterType filter_type,
                               const MediaFormat& media_format) {
     Filter* filter = NULL;
     if (Filter::filter_type() == filter_type &&
         Filter::IsMediaFormatSupported(media_format)) {
       filter = new Filter(a_);
     }
     return filter;
   }
 
  private:
+   ~FilterFactoryImpl1() {}
+
   A const a_;
   DISALLOW_COPY_AND_ASSIGN(FilterFactoryImpl1);
 };
 
 template <class Filter, class A, class B>
 class FilterFactoryImpl2 : public FilterFactory {
  public:
   FilterFactoryImpl2(A a, B b) : a_(a), b_(b) {}
 
  protected:
   virtual MediaFilter* Create(FilterType filter_type,
                               const MediaFormat& media_format) {
     Filter* filter = NULL;
     if (Filter::filter_type() == filter_type &&
         Filter::IsMediaFormatSupported(media_format)) {
       filter = new Filter(a_, b_);
     }
     return filter;
   }
 
  private:
+  ~FilterFactoryImpl2() {}
+
   A const a_;
   B const b_;
 
   DISALLOW_COPY_AND_ASSIGN(FilterFactoryImpl2);
 };
 
 //------------------------------------------------------------------------------
 
 // This specialized factory is typically used by test programs that create
 // a filter instance, and want to return that specific instance of the test
@@ skipping 21 matching lines @@
         create_called_ = true;
         return filter_;
       } else {
         NOTREACHED();
       }
     }
     return NULL;
   }
 
  private:
+  ~InstanceFilterFactory() {}
+
   scoped_refptr<Filter> filter_;
   bool create_called_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceFilterFactory);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_FACTORY_H_