Change EXPECT/ASSERT_DCHECK_DEATH macro to not expose the |regex| parameter.

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"
@@ skipping 569 matching lines @@
 
   // 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_DCHECK_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_DCHECK_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_DCHECK_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_DCHECK_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_DCHECK_DEATH(arrow.target.get(), "");
+  ASSERT_DCHECK_DEATH(arrow.target.get());
 }
 
 }  // namespace base