Turned AudioDecoderFactory into a RefCounted thing to use with scoped_refptr.

webrtc/modules/audio_coding/codecs/audio_decoder_factory.h

Index: webrtc/modules/audio_coding/codecs/audio_decoder_factory.h
diff --git a/webrtc/modules/audio_coding/codecs/audio_decoder_factory.h b/webrtc/modules/audio_coding/codecs/audio_decoder_factory.h
index 12b977809187e8bf868a32bd415531f9d49d8e3f..64044b60209827f50738dbbdf8abc242ce1ba059 100644
--- a/webrtc/modules/audio_coding/codecs/audio_decoder_factory.h
+++ b/webrtc/modules/audio_coding/codecs/audio_decoder_factory.h
@@ -14,6 +14,8 @@
 #include <memory>
 #include <vector>
 
+#include "webrtc/base/atomicops.h"
+#include "webrtc/base/refcount.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/codecs/audio_format.h"
 
@@ -21,7 +23,7 @@ namespace webrtc {
 
 // A factory that creates AudioDecoders.
 // NOTE: This class is still under development and may change without notice.
-class AudioDecoderFactory {
+class AudioDecoderFactory : public rtc::RefCountInterface {
  public:
   virtual ~AudioDecoderFactory() = default;
 
@@ -29,6 +31,21 @@ class AudioDecoderFactory {
 
   virtual std::unique_ptr<AudioDecoder> MakeAudioDecoder(
       const SdpAudioFormat& format) = 0;
+
+  int AddRef() const override {

[ossu, 2016/05/18 11:59:56]

Put these in .cc-file?
Pro: cleaner
Con: slower (and most code already uses a template for this)

[kwiberg-webrtc, 2016/05/18 14:03:15]

Slower how? It's a virtual call either way.

[ossu, 2016/05/18 14:42:20]

Yeah, I guess as long as we inherit from rtc::RefCountInterface, the compiler
can't do anything more clever than a virtual call. We don't have to
(rtc::scoped_refptr doesn't enforce it), but I guess it's for documentation, or
something. I'd gladly remove the inheritance and bury AddRef/Release
implementations in the .cc file.

I guess if I made AddRef/Release final, the compiler could just ignore the
virtual call when used with scoped_refptr; the static type would be
AudioDecoderFactory and nothing could change the implementation of
AddRef/Release. At that point, inheriting from rtc::RefCountInterface is 100%
cosmetic. Now it's 99% cosmetic.

[kwiberg-webrtc, 2016/05/18 15:48:27]

Making them final would essentially make them not virtual, so you might as well
do that instead. But that would prevent subclasses from overriding them, so that
e.g. a combined encoder+decoder factory would be impossible.

The thing you ended up doing is the only sane thing, I'd say. Especially since
the compiler will complain if you don't wrap constructor calls in
RefCountedObject.

+    return rtc::AtomicOps::Increment(&ref_count_);
+  }
+
+  int Release() const override {
+    int count = rtc::AtomicOps::Decrement(&ref_count_);
+    if (!count) {
+      delete this;
+    }
+    return count;
+  }
+
+ private:
+  mutable volatile int ref_count_;

[kwiberg-webrtc, 2016/05/18 14:03:15]

Danger, Will Robinson! State in an interface!

This will make it ugly to have an encoder factory and a decoder factory in the
same object.

How about pure virtual AddRef and Release methods, and forcing subclasses to
implement them? Have you considered that? ;-)

[ossu, 2016/05/18 14:42:21]

Oh, right... We'd get two reference counts and everything would blow up, unless
the implementer chose to work around that.

I don't like forcing subclasses to implement this either, since it relies on
everyone getting it right every time (not too difficult) or creating their
factory through RefCountedObject<T>. Neither is very pretty for something that
is really tangential to the matter at hand (implementing a factory for creating
decoders).

It might be the only way to go, though.

 };
 
 }  // namespace webrtc