Fix SchedulerLock unittests to actually generate a DCHECK, not an exception

base/task_scheduler/scheduler_lock_impl.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_impl.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <vector>
 
@@ skipping 49 matching lines @@
   void AssertSafeAcquire(const SchedulerLockImpl* const lock) {
     const LockVector* acquired_locks = GetAcquiredLocksOnCurrentThread();
 
     // If the thread currently holds no locks, this is inherently safe.
     if (acquired_locks->empty())
       return;
 
     // Otherwise, make sure that the previous lock acquired is an allowed
     // predecessor.
     AutoLock auto_lock(allowed_predecessor_map_lock_);
+    // Using at() is exception-safe here as |lock| was registered already.
     const SchedulerLockImpl* allowed_predecessor =
         allowed_predecessor_map_.at(lock);
     DCHECK_EQ(acquired_locks->back(), allowed_predecessor);
   }
 
+  // Asserts that |lock|'s registered predecessor is safe. Because
+  // SchedulerLocks are registered at construction time and any predecessor
+  // specified on a SchedulerLock must already exist, the first registered
+  // SchedulerLock in a potential chain must have a null predecessor and is thus
+  // cycle-free. Any subsequent SchedulerLock with a predecessor must come from
+  // the set of registered SchedulerLocks. Since the registered SchedulerLocks
+  // only contain cycle-free SchedulerLocks, this subsequent SchedulerLock is
+  // itself cycle-free and may be safely added to the registered SchedulerLock
+  // set.
   void AssertSafePredecessor(const SchedulerLockImpl* lock) const {
     allowed_predecessor_map_lock_.AssertAcquired();
-    for (const SchedulerLockImpl* predecessor =
-             allowed_predecessor_map_.at(lock);
-         predecessor != nullptr;
-         predecessor = allowed_predecessor_map_.at(predecessor)) {
-      DCHECK_NE(predecessor, lock) <<
-          "Scheduler lock predecessor cycle detected.";
+    // Using at() is exception-safe here as |lock| was registered already.
+    const SchedulerLockImpl* predecessor = allowed_predecessor_map_.at(lock);
+    if (predecessor) {
+      DCHECK(allowed_predecessor_map_.find(predecessor) !=
+             allowed_predecessor_map_.end())
+          << "SchedulerLock was registered before its predecessor. "
+          << "Potential cycle detected";
     }
   }
 
   LockVector* GetAcquiredLocksOnCurrentThread() {
     if (!tls_acquired_locks_.Get())
       tls_acquired_locks_.Set(new LockVector);
 
     return reinterpret_cast<LockVector*>(tls_acquired_locks_.Get());
   }
 
@@ skipping 43 matching lines @@
   lock_.AssertAcquired();
 }
 
 std::unique_ptr<ConditionVariable>
 SchedulerLockImpl::CreateConditionVariable() {
   return std::unique_ptr<ConditionVariable>(new ConditionVariable(&lock_));
 }
 
 }  // namespace internal
 }  // base