Fix incorrect memory barrier usage I previously asked to be introduced.

base/task_scheduler/scheduler_worker_pool_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_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 195 matching lines @@
 
   // SchedulerWorker::Delegate:
   void OnMainEntry(SchedulerWorker* worker,
                    const TimeDelta& detach_duration) override;
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override;
   TimeDelta GetSleepTimeout() override;
   bool CanDetach(SchedulerWorker* worker) override;
 
   void RegisterSingleThreadTaskRunner() {
-    subtle::Barrier_AtomicIncrement(&num_single_threaded_runners_, 1);
+    // No barrier as barriers only affect sequential consistency which is
+    // irrelevant in a single variable use case (they don't force an immediate
+    // flush anymore than atomics do by default).
+    subtle::NoBarrier_AtomicIncrement(&num_single_threaded_runners_, 1);
   }
 
   void UnregisterSingleThreadTaskRunner() {
-    subtle::Barrier_AtomicIncrement(&num_single_threaded_runners_, -1);
+    subtle::NoBarrier_AtomicIncrement(&num_single_threaded_runners_, -1);
   }
 
  private:
   SchedulerWorkerPoolImpl* outer_;
   const ReEnqueueSequenceCallback re_enqueue_sequence_callback_;
 
   // Single-threaded PriorityQueue for the worker.
   PriorityQueue single_threaded_priority_queue_;
 
   // True if the last Sequence returned by GetWork() was extracted from
@@ skipping 302 matching lines @@
 }
 
 TimeDelta SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     GetSleepTimeout() {
   return outer_->suggested_reclaim_time_;
 }
 
 bool SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::CanDetach(
     SchedulerWorker* worker) {
   // It's not an issue if |num_single_threaded_runners_| is incremented after
-  // this because the newly created TaskRunner (from which no task has run yet)
-  // will simply run all its tasks on the next physical thread created by the
-  // worker.
+  // this because the newly created SingleThreadTaskRunner (from which no task
+  // has run yet) will simply run all its tasks on the next physical thread
+  // created by the worker.
   const bool can_detach =
       !idle_start_time_.is_null() &&
       (TimeTicks::Now() - idle_start_time_) > outer_->suggested_reclaim_time_ &&
       worker != outer_->PeekAtIdleWorkersStack() &&
-      !subtle::Acquire_Load(&num_single_threaded_runners_) &&
+      !subtle::NoBarrier_Load(&num_single_threaded_runners_) &&
       outer_->CanWorkerDetachForTesting();
   return can_detach;
 }
 
 SchedulerWorkerPoolImpl::SchedulerWorkerPoolImpl(
     StringPiece name,
     SchedulerWorkerPoolParams::IORestriction io_restriction,
     const TimeDelta& suggested_reclaim_time,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
@@ skipping 85 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base