Make kAllowedToAccessOnNonjoinableThread debug-only.

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.
 
 // PLEASE READ: Do you really need a singleton?
 //
 // Singletons make it hard to determine the lifetime of an object, which can
 // lead to buggy code and spurious crashes.
 //
 // Instead of adding another singleton into the mix, try to identify either:
@@ skipping 45 matching lines @@
 
   // Destroys the object.
   static void Delete(Type* x) {
     delete x;
   }
 
   // Set to true to automatically register deletion of the object on process
   // exit. See below for the required call that makes this happen.
   static const bool kRegisterAtExit = true;
 
+#ifndef NDEBUG
   // Set to false to disallow access on a non-joinable thread.  This is
   // different from kRegisterAtExit because StaticMemorySingletonTraits allows
   // access on non-joinable threads, and gracefully handles this.
   static const bool kAllowedToAccessOnNonjoinableThread = false;
+#endif
 };
 
 
 // Alternate traits for use with the Singleton<Type>.  Identical to
 // DefaultSingletonTraits except that the Singleton will not be cleaned up
 // at exit.
 template<typename Type>
 struct LeakySingletonTraits : public DefaultSingletonTraits<Type> {
   static const bool kRegisterAtExit = false;
+#ifndef NDEBUG
   static const bool kAllowedToAccessOnNonjoinableThread = true;
+#endif
 };
 
 
 // Alternate traits for use with the Singleton<Type>.  Allocates memory
 // for the singleton instance from a static buffer.  The singleton will
 // be cleaned up at exit, but can't be revived after destruction unless
 // the Resurrect() method is called.
 //
 // This is useful for a certain category of things, notably logging and
 // tracing, where the singleton instance is of a type carefully constructed to
@@ skipping 186 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_