Enable ThreadChecker in non-debug builds if DCHECK_ALWAYS_ON is

base/threading/thread_checker_unittest.cc

 // 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.
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// Duplicated from base/threading/thread_checker.h so that we can be
+// good citizens there and undef the macro.

[joth, 2011/12/21 14:17:16]

yeah the duplication is unfortunate but I can't see a cleaner way (and the test
would fail anyway if this was incorrect... although whether we'd run them in
that failing config is another question!)

FWIW you could simplify it both places to
  #define ENABLE_THREAD_CHECKER (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))

(Personally I think a much better approach would be to have a project wide
define and use that in place of NDEBUG everywhere we care if DCHECK is compiled
in, to avoid this inelegant expression cropping up numerous places. No doubt
sometimes with !OFFICIAL_BUILD sprinkled in too).

+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#define ENABLE_THREAD_CHECKER 1
+#else
+#define ENABLE_THREAD_CHECKER 0
+#endif
+
 namespace base {
 
 // Simple class to exercise the basics of ThreadChecker.
 // Both the destructor and DoStuff should verify that they were
 // called on the same thread as the constructor.
 class ThreadCheckerClass : public ThreadChecker {
  public:
   ThreadCheckerClass() {}
 
   // Verifies that it was called on the same thread as the constructor.
@@ skipping 78 matching lines @@
 
   // Verify that DoStuff doesn't assert when called on a different thread after
   // a call to DetachFromThread.
   thread_checker_class->DetachFromThread();
   CallDoStuffOnThread call_on_thread(thread_checker_class.get());
 
   call_on_thread.Start();
   call_on_thread.Join();
 }
 
-#if GTEST_HAS_DEATH_TEST || NDEBUG
+#if GTEST_HAS_DEATH_TEST || !ENABLE_THREAD_CHECKER
 
 void ThreadCheckerClass::MethodOnDifferentThreadImpl() {
   scoped_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // DoStuff should assert in debug builds only when called on a
   // different thread.
   CallDoStuffOnThread call_on_thread(thread_checker_class.get());
 
   call_on_thread.Start();
   call_on_thread.Join();
 }
 
-#ifndef NDEBUG
+#if ENABLE_THREAD_CHECKER
 TEST(ThreadCheckerDeathTest, MethodNotAllowedOnDifferentThreadInDebug) {
   ASSERT_DEBUG_DEATH({
       ThreadCheckerClass::MethodOnDifferentThreadImpl();
     }, "");
 }
 #else
 TEST(ThreadCheckerTest, MethodAllowedOnDifferentThreadInRelease) {
   ThreadCheckerClass::MethodOnDifferentThreadImpl();
 }
-#endif  // NDEBUG
+#endif  // ENABLE_THREAD_CHECKER
 
 void ThreadCheckerClass::DetachThenCallFromDifferentThreadImpl() {
   scoped_ptr<ThreadCheckerClass> thread_checker_class(
       new ThreadCheckerClass);
 
   // DoStuff doesn't assert when called on a different thread
   // after a call to DetachFromThread.
   thread_checker_class->DetachFromThread();
   CallDoStuffOnThread call_on_thread(thread_checker_class.get());
 
   call_on_thread.Start();
   call_on_thread.Join();
 
   // DoStuff should assert in debug builds only after moving to
   // another thread.
   thread_checker_class->DoStuff();
 }
 
-#ifndef NDEBUG
+#if ENABLE_THREAD_CHECKER
 TEST(ThreadCheckerDeathTest, DetachFromThreadInDebug) {
   ASSERT_DEBUG_DEATH({
     ThreadCheckerClass::DetachThenCallFromDifferentThreadImpl();
     }, "");
 }
 #else
 TEST(ThreadCheckerTest, DetachFromThreadInRelease) {
   ThreadCheckerClass::DetachThenCallFromDifferentThreadImpl();
 }
-#endif  // NDEBUG
+#endif  // ENABLE_THREAD_CHECKER
 
-#endif  // GTEST_HAS_DEATH_TEST || NDEBUG
+#endif  // GTEST_HAS_DEATH_TEST || !ENABLE_THREAD_CHECKER
+
+// Just in case we ever get lumped together with other compilation units.
+#undef ENABLE_THREAD_CHECKER
 
 }  // namespace base