Convert //base to use std::unique_ptr

base/threading/sequenced_worker_pool_unittest.cc

 // Copyright (c) 2012 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/threading/sequenced_worker_pool.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequence_checker_impl.h"
 #include "base/stl_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/sequenced_task_runner_test_template.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/task_runner_test_template.h"
 #include "base/test/test_timeouts.h"
@@ skipping 261 matching lines @@
     // Clean up the task IDs we added.
     tracker()->ClearCompleteSequence();
   }
 
   int has_work_call_count() const {
     return pool_owner_->has_work_call_count();
   }
 
  private:
   MessageLoop message_loop_;
-  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
+  std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
   const scoped_refptr<TestTracker> tracker_;
 };
 
 // Checks that the given number of entries are in the tasks to complete of
 // the given tracker, and then signals the given event the given number of
 // times. This is used to wake up blocked background threads before blocking
 // on shutdown.
 void EnsureTasksToCompleteCountAndUnblock(scoped_refptr<TestTracker> tracker,
                                           size_t expected_tasks_to_complete,
                                           ThreadBlocker* blocker,
@@ skipping 752 matching lines @@
     // Make sure all tasks are run before shutting down. Delayed tasks are
     // not run, they're simply deleted.
     pool_owner_->pool()->FlushForTesting();
     pool_owner_->pool()->Shutdown();
     // Don't reset |pool_owner_| here, as the test may still hold a
     // reference to the pool.
   }
 
  private:
   MessageLoop message_loop_;
-  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
+  std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPool, TaskRunnerTest,
     SequencedWorkerPoolTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(SequencedWorkerPool, TaskRunnerAffinityTest,
                               SequencedWorkerPoolTaskRunnerTestDelegate);
 
 class SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate {
  public:
@@ skipping 17 matching lines @@
     // Make sure all tasks are run before shutting down. Delayed tasks are
     // not run, they're simply deleted.
     pool_owner_->pool()->FlushForTesting();
     pool_owner_->pool()->Shutdown();
     // Don't reset |pool_owner_| here, as the test may still hold a
     // reference to the pool.
   }
 
  private:
   MessageLoop message_loop_;
-  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
+  std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
   scoped_refptr<TaskRunner> task_runner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolTaskRunner, TaskRunnerTest,
     SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolTaskRunner, TaskRunnerAffinityTest,
     SequencedWorkerPoolTaskRunnerWithShutdownBehaviorTestDelegate);
 
@@ skipping 19 matching lines @@
     // Make sure all tasks are run before shutting down. Delayed tasks are
     // not run, they're simply deleted.
     pool_owner_->pool()->FlushForTesting();
     pool_owner_->pool()->Shutdown();
     // Don't reset |pool_owner_| here, as the test may still hold a
     // reference to the pool.
   }
 
  private:
   MessageLoop message_loop_;
-  scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
+  std::unique_ptr<SequencedWorkerPoolOwner> pool_owner_;
   scoped_refptr<SequencedTaskRunner> task_runner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner, TaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner, TaskRunnerAffinityTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base