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

base/memory/weak_ptr_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/memory/weak_ptr.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/gtest_util.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 WeakPtr<int> PassThru(WeakPtr<int> ptr) {
   return ptr;
 }
 
@@ skipping 531 matching lines @@
   // Main thread creates an arrow referencing the Target.
   Arrow* arrow = new Arrow();
   arrow->target = target.AsWeakPtr();
 
   // Background can delete arrow (as well as the WeakPtr inside).
   BackgroundThread background;
   background.Start();
   background.DeleteArrow(arrow);
 }
 
-#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST
-
 TEST(WeakPtrDeathTest, WeakPtrCopyDoesNotChangeThreadBinding) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
   BackgroundThread background;
   background.Start();
 
   // Main thread creates a Target object.
   Target target;
   // Main thread creates an arrow referencing the Target.
   Arrow arrow;
   arrow.target = target.AsWeakPtr();
 
   // Background copies the WeakPtr.
   Arrow* arrow_copy;
   background.CreateArrowFromArrow(&arrow_copy, &arrow);
 
   // The copy is still bound to main thread so I can deref.
   EXPECT_EQ(arrow.target.get(), arrow_copy->target.get());
 
   // Although background thread created the copy, it can not deref the copied
   // WeakPtr.
-  ASSERT_DEATH(background.DeRef(arrow_copy), "");
+  ASSERT_DCHECK_DEATH(background.DeRef(arrow_copy), "");
 
   background.DeleteArrow(arrow_copy);
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadDereferencesWeakPtrAfterReference) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
   // Main thread creates a Target object.
   Target target;
 
   // Main thread creates an arrow referencing the Target (so target's
   // thread ownership can not be implicitly moved).
   Arrow arrow;
   arrow.target = target.AsWeakPtr();
   arrow.target.get();
 
   // Background thread tries to deref target, which violates thread ownership.
   BackgroundThread background;
   background.Start();
-  ASSERT_DEATH(background.DeRef(&arrow), "");
+  ASSERT_DCHECK_DEATH(background.DeRef(&arrow), "");
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadDeletesWeakPtrAfterReference) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
   std::unique_ptr<Target> target(new Target());
 
   // Main thread creates an arrow referencing the Target.
   Arrow arrow;
   arrow.target = target->AsWeakPtr();
 
   // Background thread tries to deref target, binding it to the thread.
   BackgroundThread background;
   background.Start();
   background.DeRef(&arrow);
 
   // Main thread deletes Target, violating thread binding.
-  ASSERT_DEATH(target.reset(), "");
+  ASSERT_DCHECK_DEATH(target.reset(), "");
 
   // |target.reset()| died so |target| still holds the object, so we
   // must pass it to the background thread to teardown.
   background.DeleteTarget(target.release());
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadDeletesObjectAfterReference) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
   std::unique_ptr<Target> target(new Target());
 
   // Main thread creates an arrow referencing the Target, and references it, so
   // that it becomes bound to the thread.
   Arrow arrow;
   arrow.target = target->AsWeakPtr();
   arrow.target.get();
 
   // Background thread tries to delete target, volating thread binding.
   BackgroundThread background;
   background.Start();
-  ASSERT_DEATH(background.DeleteTarget(target.release()), "");
+  ASSERT_DCHECK_DEATH(background.DeleteTarget(target.release()), "");
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadReferencesObjectAfterDeletion) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
   std::unique_ptr<Target> target(new Target());
 
   // Main thread creates an arrow referencing the Target.
   Arrow arrow;
   arrow.target = target->AsWeakPtr();
 
   // Background thread tries to delete target, binding the object to the thread.
   BackgroundThread background;
   background.Start();
   background.DeleteTarget(target.release());
 
   // Main thread attempts to dereference the target, violating thread binding.
-  ASSERT_DEATH(arrow.target.get(), "");
+  ASSERT_DCHECK_DEATH(arrow.target.get(), "");
 }
 
-#endif
-
 }  // namespace base