Turned AudioDecoderFactory into a RefCounted thing to use with scoped_refptr.

webrtc/modules/audio_coding/codecs/audio_decoder_factory.h

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_AUDIO_DECODER_FACTORY_H_
 #define WEBRTC_MODULES_AUDIO_CODING_CODECS_AUDIO_DECODER_FACTORY_H_
 
 #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"
 
 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;
 
   virtual std::vector<SdpAudioFormat> GetSupportedFormats() = 0;
 
   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
 
 #endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_AUDIO_DECODER_FACTORY_H_