Convert //base to use std::unique_ptr

base/task_scheduler/scheduler_lock.h

 // 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.
 
 #ifndef BASE_TASK_SCHEDULER_SCHEDULER_LOCK_H
 #define BASE_TASK_SCHEDULER_SCHEDULER_LOCK_H
 
+#include <memory>
+
 #include "base/base_export.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/task_scheduler/scheduler_lock_impl.h"
 
 namespace base {
 namespace internal {
 
 // SchedulerLock should be used anywhere a lock would be used in the scheduler.
 // When DCHECK_IS_ON(), lock checking occurs. Otherwise, SchedulerLock is
 // equivalent to base::Lock.
@@ skipping 13 matching lines @@
 //
 // void Acquire()
 //     Acquires the lock.
 //
 // void Release()
 //     Releases the lock.
 //
 // void AssertAcquired().
 //     DCHECKs if the lock is not acquired.
 //
-// scoped_ptr<ConditionVariable> CreateConditionVariable()
+// std::unique_ptr<ConditionVariable> CreateConditionVariable()
 //     Creates a condition variable using this as a lock.
 
 #if DCHECK_IS_ON()
 class SchedulerLock : public SchedulerLockImpl {
  public:
   SchedulerLock() = default;
   explicit SchedulerLock(const SchedulerLock* predecessor)
       : SchedulerLockImpl(predecessor) {}
 };
 #else  // DCHECK_IS_ON()
 class SchedulerLock : public Lock {
  public:
   SchedulerLock() = default;
   explicit SchedulerLock(const SchedulerLock*) {}
 
-  scoped_ptr<ConditionVariable> CreateConditionVariable() {
-    return scoped_ptr<ConditionVariable>(new ConditionVariable(this));
+  std::unique_ptr<ConditionVariable> CreateConditionVariable() {
+    return std::unique_ptr<ConditionVariable>(new ConditionVariable(this));
   }
 };
 #endif  // DCHECK_IS_ON()
 
 // Provides the same functionality as base::AutoLock for SchedulerLock.
 class AutoSchedulerLock {
  public:
   explicit AutoSchedulerLock(SchedulerLock& lock) : lock_(lock) {
     lock_.Acquire();
   }
 
   ~AutoSchedulerLock() {
     lock_.AssertAcquired();
     lock_.Release();
   }
 
  private:
   SchedulerLock& lock_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoSchedulerLock);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_LOCK_H