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

base/task_scheduler/task_tracker_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/task_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 336 matching lines @@
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAfterShutdown) {
   tracker_.Shutdown();
 
   std::unique_ptr<Task> task(CreateTask(GetParam()));
 
   // |task_tracker_| shouldn't allow a task to be posted after shutdown.
   if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
-    EXPECT_DCHECK_DEATH({ tracker_.WillPostTask(task.get()); }, "");
+    EXPECT_DCHECK_DEATH({ tracker_.WillPostTask(task.get()); });
   } else {
     EXPECT_FALSE(tracker_.WillPostTask(task.get()));
   }
 }
 
 // Verify that BLOCK_SHUTDOWN and SKIP_ON_SHUTDOWN tasks can
 // AssertSingletonAllowed() but CONTINUE_ON_SHUTDOWN tasks can't.
 TEST_P(TaskSchedulerTaskTrackerTest, SingletonAllowed) {
   const bool can_use_singletons =
       (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
 
   TaskTracker tracker;
   std::unique_ptr<Task> task(
       new Task(FROM_HERE, Bind(&ThreadRestrictions::AssertSingletonAllowed),
                TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));
   EXPECT_TRUE(tracker.WillPostTask(task.get()));
 
   // Set the singleton allowed bit to the opposite of what it is expected to be
   // when |tracker| runs |task| to verify that |tracker| actually sets the
   // correct value.
   ScopedSetSingletonAllowed scoped_singleton_allowed(!can_use_singletons);
 
   // Running the task should fail iff the task isn't allowed to use singletons.
   if (can_use_singletons) {
     tracker.RunNextTaskInSequence(
         CreateSequenceWithTask(std::move(task)).get());
   } else {
+#if !defined(OS_LINUX)  // http://crbug.com/634552
     EXPECT_DCHECK_DEATH(
         {
           tracker.RunNextTaskInSequence(
               CreateSequenceWithTask(std::move(task)).get());
-        },
-        "");
+        });
+#endif  // !defined(OS_LINUX)
   }
 }
 
 static void RunTaskRunnerHandleVerificationTask(
     TaskTracker* tracker,
     std::unique_ptr<Task> verify_task) {
   // Pretend |verify_task| is posted to respect TaskTracker's contract.
   EXPECT_TRUE(tracker->WillPostTask(verify_task.get()));
 
   // Confirm that the test conditions are right (no TaskRunnerHandles set
@@ skipping 238 matching lines @@
 
   // Unblock shutdown by running |block_shutdown_task|.
   tracker_.RunNextTaskInSequence(
       CreateSequenceWithTask(std::move(block_shutdown_task)).get());
   EXPECT_EQ(kLoadTestNumIterations + 1, NumTasksExecuted());
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 }  // namespace internal
 }  // namespace base