Implements AudioMessageFilter as member in RenderThread

base/memory/singleton.h

 // Copyright (c) 2011 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.
 
 #ifndef BASE_MEMORY_SINGLETON_H_
 #define BASE_MEMORY_SINGLETON_H_
 #pragma once
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
@@ skipping 91 matching lines @@
 
  private:
   static const size_t kBufferSize = (sizeof(Type) +
                                      sizeof(intptr_t) - 1) / sizeof(intptr_t);
   static intptr_t buffer_[kBufferSize];
 
   // Signal the object was already deleted, so it is not revived.
   static base::subtle::Atomic32 dead_;
 };
 
+// Alternate traits for use with the Singleton<Type>.  Identical to
+// DefaultSingletonTraits except that AddRef() will be called on the singleton
+// upon construction and Release() will be called instead of delete when
+// the singleton is destructed.
+template<typename Type>
+struct RefCountedSingletonTraits {
+  // Allocates the reference counted object.
+  static Type* New() {
+    DCHECK(Type::ImplementsThreadSafeReferenceCounting());
+    Type* ptr = new Type();
+    ptr->AddRef();
+    return ptr;
+  }
+
+  // Destroys the reference counted object.
+  static void Delete(Type* x) {
+    DCHECK(Type::ImplementsThreadSafeReferenceCounting());
+    x->Release();
+  }
+
+  static const bool kRegisterAtExit = true;
+  static const bool kAllowedToAccessOnNonjoinableThread = false;
+};
+
 template <typename Type> intptr_t
     StaticMemorySingletonTraits<Type>::buffer_[kBufferSize];
 template <typename Type> base::subtle::Atomic32
     StaticMemorySingletonTraits<Type>::dead_ = 0;
 
 // The Singleton<Type, Traits, DifferentiatingType> class manages a single
 // instance of Type which will be created on first use and will be destroyed at
 // normal process exit). The Trait::Delete function will not be called on
 // abnormal process exit.
 //
@@ skipping 140 matching lines @@
     instance_ = 0;
   }
   static base::subtle::AtomicWord instance_;
 };
 
 template <typename Type, typename Traits, typename DifferentiatingType>
 base::subtle::AtomicWord Singleton<Type, Traits, DifferentiatingType>::
     instance_ = 0;
 
 #endif  // BASE_MEMORY_SINGLETON_H_