Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/media/cma/base/balanced_media_task_runner_unittest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <list>
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chromecast/media/cma/base/balanced_media_task_runner_factory.h"
 #include "chromecast/media/cma/base/media_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 
@@ skipping 176 matching lines @@
   }
 }
 
 void BalancedMediaTaskRunnerTest::OnTestTimeout() {
   ADD_FAILURE() << "Test timed out";
   if (base::MessageLoop::current())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 TEST_F(BalancedMediaTaskRunnerTest, OneTaskRunner) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   // Timestamps of tasks for the single task runner.
   int timestamps0_ms[] = {0, 10, 20, 30, 40, 30, 50, 60, 20, 30, 70};
   std::vector<std::vector<int> > timestamps_ms(1);
   timestamps_ms[0] = std::vector<int>(
       timestamps0_ms, timestamps0_ms + arraysize(timestamps0_ms));
 
   // Scheduling pattern.
   std::vector<size_t> scheduling_pattern(1);
   scheduling_pattern[0] = 0;
 
   // Expected results.
   int expected_timestamps[] = {0, 10, 20, 30, 40, 50, 60, 70};
   std::vector<int> expected_timestamps_ms(std::vector<int>(
       expected_timestamps,
       expected_timestamps + arraysize(expected_timestamps)));
 
   SetupTest(base::TimeDelta::FromMilliseconds(30),
             timestamps_ms,
             scheduling_pattern,
             expected_timestamps_ms);
   ProcessAllTasks();
   message_loop->Run();
   EXPECT_TRUE(expected_task_timestamps_.empty());
 }
 
 TEST_F(BalancedMediaTaskRunnerTest, TwoTaskRunnerUnbalanced) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   // Timestamps of tasks for the 2 task runners.
   int timestamps0_ms[] = {0, 10, 20, 30, 40, 30, 50, 60, 20, 30, 70};
   int timestamps1_ms[] = {5, 15, 25, 35, 45, 35, 55, 65, 25, 35, 75};
   std::vector<std::vector<int> > timestamps_ms(2);
   timestamps_ms[0] = std::vector<int>(
       timestamps0_ms, timestamps0_ms + arraysize(timestamps0_ms));
   timestamps_ms[1] = std::vector<int>(
       timestamps1_ms, timestamps1_ms + arraysize(timestamps1_ms));
 
@@ skipping 12 matching lines @@
   SetupTest(base::TimeDelta::FromMilliseconds(30),
             timestamps_ms,
             scheduling_pattern,
             expected_timestamps_ms);
   ProcessAllTasks();
   message_loop->Run();
   EXPECT_TRUE(expected_task_timestamps_.empty());
 }
 
 TEST_F(BalancedMediaTaskRunnerTest, TwoStreamsOfDifferentLength) {
-  scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
+  std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 
   std::vector<std::vector<int>> timestamps = {
       // One longer stream and one shorter stream.
       // The longer stream runs first, then the shorter stream begins.
       // After shorter stream ends, it shouldn't block the longer one.
       {0, 20, 40, 60, 80, 100, 120, 140, 160},
       {51, 61, 71, 81},
   };
 
   std::vector<int> expected_timestamps = {
       0, 20, 40, 60, 51, 80, 61, 71, 81, 100, 120, 140, 160};
 
   std::vector<size_t> scheduling_pattern = {
       0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0};
 
   SetupTest(base::TimeDelta::FromMilliseconds(30), timestamps,
             scheduling_pattern, expected_timestamps);
   ProcessAllTasks();
   message_loop->Run();
   EXPECT_TRUE(expected_task_timestamps_.empty());
 }
 
 }  // namespace media
 }  // namespace chromecast