DO NOT COMMIT -- Very confusing patch...

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 93 matching lines @@
   const Action action_;
   const bool expect_post_succeeds_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingAndRunningTask);
 };
 
 class ScopedSetSingletonAllowed {
  public:
   ScopedSetSingletonAllowed(bool singleton_allowed)
       : previous_value_(
-            ThreadRestrictions::SetSingletonAllowed(singleton_allowed)) {}
+            ThreadRestrictions::SetIOAllowed(singleton_allowed)) {}
   ~ScopedSetSingletonAllowed() {
-    ThreadRestrictions::SetSingletonAllowed(previous_value_);
+    ThreadRestrictions::SetIOAllowed(previous_value_);
   }
 
  private:
   const bool previous_value_;
 };
 
 class TaskSchedulerTaskTrackerTest
     : public testing::TestWithParam<TaskShutdownBehavior> {
  protected:
   TaskSchedulerTaskTrackerTest() = default;
@@ skipping 234 matching lines @@
 }
 
 // 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),
+      new Task(FROM_HERE, Bind(&ThreadRestrictions::AssertIOAllowed),
                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