Move EXPECT_DCHECK_DEATH from base/task_scheduler and use it in relevant base/ tests

base/threading/non_thread_safe_unittest.cc

 // Copyright (c) 2012 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/threading/non_thread_safe.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/test/gtest_util.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Duplicated from base/threading/non_thread_safe.h so that we can be
 // good citizens there and undef the macro.
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
 #define ENABLE_NON_THREAD_SAFE 1
 #else
 #define ENABLE_NON_THREAD_SAFE 0
 #endif
@@ skipping 78 matching lines @@
   // Verify that the destructor doesn't assert when called on a different thread
   // after a detach.
   non_thread_safe_class->DetachFromThread();
   DeleteNonThreadSafeClassOnThread delete_on_thread(
       non_thread_safe_class.release());
 
   delete_on_thread.Start();
   delete_on_thread.Join();
 }
 
-#if GTEST_HAS_DEATH_TEST || !ENABLE_NON_THREAD_SAFE
-
 void NonThreadSafeClass::MethodOnDifferentThreadImpl() {
   std::unique_ptr<NonThreadSafeClass> non_thread_safe_class(
       new NonThreadSafeClass);
 
   // Verify that DoStuff asserts in debug builds only when called
   // on a different thread.
   CallDoStuffOnThread call_on_thread(non_thread_safe_class.get());
 
   call_on_thread.Start();
   call_on_thread.Join();
 }
 
 #if ENABLE_NON_THREAD_SAFE
 TEST(NonThreadSafeDeathTest, MethodNotAllowedOnDifferentThreadInDebug) {
-  ASSERT_DEATH({
-      NonThreadSafeClass::MethodOnDifferentThreadImpl();
-    }, "");
+  ASSERT_DCHECK_DEATH({ NonThreadSafeClass::MethodOnDifferentThreadImpl(); },
+                      "");
 }
 #else
 TEST(NonThreadSafeTest, MethodAllowedOnDifferentThreadInRelease) {
   NonThreadSafeClass::MethodOnDifferentThreadImpl();
 }
 #endif  // ENABLE_NON_THREAD_SAFE
 
 void NonThreadSafeClass::DestructorOnDifferentThreadImpl() {
   std::unique_ptr<NonThreadSafeClass> non_thread_safe_class(
       new NonThreadSafeClass);
 
   // Verify that the destructor asserts in debug builds only
   // when called on a different thread.
   DeleteNonThreadSafeClassOnThread delete_on_thread(
       non_thread_safe_class.release());
 
   delete_on_thread.Start();
   delete_on_thread.Join();
 }
 
 #if ENABLE_NON_THREAD_SAFE
 TEST(NonThreadSafeDeathTest, DestructorNotAllowedOnDifferentThreadInDebug) {
-  ASSERT_DEATH({
-      NonThreadSafeClass::DestructorOnDifferentThreadImpl();
-    }, "");
+  ASSERT_DCHECK_DEATH(
+      { NonThreadSafeClass::DestructorOnDifferentThreadImpl(); }, "");
 }
 #else

[danakj, 2016/07/20 19:33:45]

For the same reasons as you state in the comment, running the methods that
should dcheck and verifying they dont in release is very O_O. IMO we should drop
the #else for all these tests.

[gab, 2016/07/20 21:21:08]

True, except that these tests don't have undefined behavior when doing so (they
verify that the assertion doesn't trigger in Release but the check itself isn't
what's undefined, it's whatever the typical user of the checker would do based
on this assumption that is).
So I can see an argument for keeping them... and since it's not what I'm aiming
to change I'd rather not remove previously tested things in this CL.

 TEST(NonThreadSafeTest, DestructorAllowedOnDifferentThreadInRelease) {
   NonThreadSafeClass::DestructorOnDifferentThreadImpl();
 }
 #endif  // ENABLE_NON_THREAD_SAFE
 
-#endif  // GTEST_HAS_DEATH_TEST || !ENABLE_NON_THREAD_SAFE
-
 // Just in case we ever get lumped together with other compilation units.
 #undef ENABLE_NON_THREAD_SAFE
 
 }  // namespace base