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

base/task_scheduler/scheduler_lock_unittest.cc

 // Copyright 2016 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/task_scheduler/scheduler_lock.h"
 
 #include <stdlib.h>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 113 matching lines @@
   lock.Release();
   predecessor.Release();
 }
 
 TEST(TaskSchedulerLock, AcquirePredecessorWrongOrder) {
   SchedulerLock predecessor;
   SchedulerLock lock(&predecessor);
   EXPECT_DCHECK_DEATH({
     lock.Acquire();
     predecessor.Acquire();
-  }, "");
+  });
 }
 
 TEST(TaskSchedulerLock, AcquireNonPredecessor) {
   SchedulerLock lock1;
   SchedulerLock lock2;
   EXPECT_DCHECK_DEATH({
     lock1.Acquire();
     lock2.Acquire();
-  }, "");
+  });
 }
 
 TEST(TaskSchedulerLock, AcquireMultipleLocksInOrder) {
   SchedulerLock lock1;
   SchedulerLock lock2(&lock1);
   SchedulerLock lock3(&lock2);
   lock1.Acquire();
   lock2.Acquire();
   lock3.Acquire();
   lock3.Release();
@@ skipping 11 matching lines @@
   lock2.Release();
 }
 
 TEST(TaskSchedulerLock, AcquireMultipleLocksNoTransitivity) {
   SchedulerLock lock1;
   SchedulerLock lock2(&lock1);
   SchedulerLock lock3(&lock2);
   EXPECT_DCHECK_DEATH({
     lock1.Acquire();
     lock3.Acquire();
-  }, "");
+  });
 }
 
 TEST(TaskSchedulerLock, AcquireLocksDifferentThreadsSafely) {
   SchedulerLock lock1;
   SchedulerLock lock2;
   BasicLockAcquireAndWaitThread thread(&lock1);
   thread.Start();
 
   lock2.Acquire();
   thread.WaitForLockAcquisition();
@@ skipping 65 matching lines @@
   predecessor.Release();
 }
 
 TEST(TaskSchedulerLock, SelfReferentialLock) {
   struct SelfReferentialLock {
     SelfReferentialLock() : lock(&lock) {}
 
     SchedulerLock lock;
   };
 
-  EXPECT_DCHECK_DEATH({ SelfReferentialLock lock; }, "");
+  EXPECT_DCHECK_DEATH({ SelfReferentialLock lock; });
 }
 
 TEST(TaskSchedulerLock, PredecessorCycle) {
   struct LockCycle {
     LockCycle() : lock1(&lock2), lock2(&lock1) {}
 
     SchedulerLock lock1;
     SchedulerLock lock2;
   };
 
-  EXPECT_DCHECK_DEATH({ LockCycle cycle; }, "");
+  EXPECT_DCHECK_DEATH({ LockCycle cycle; });
 }
 
 TEST(TaskSchedulerLock, PredecessorLongerCycle) {
   struct LockCycle {
     LockCycle()
         : lock1(&lock5),
           lock2(&lock1),
           lock3(&lock2),
           lock4(&lock3),
           lock5(&lock4) {}
 
     SchedulerLock lock1;
     SchedulerLock lock2;
     SchedulerLock lock3;
     SchedulerLock lock4;
     SchedulerLock lock5;
   };
 
-  EXPECT_DCHECK_DEATH({ LockCycle cycle; }, "");
+  EXPECT_DCHECK_DEATH({ LockCycle cycle; });
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base