Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/attachments/task_queue_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 "sync/internal_api/public/attachments/task_queue.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
   }
 
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void Process(const int& task) { dispatched_.push_back(task); }
 
   base::MessageLoop message_loop_;
-  scoped_ptr<TaskQueue<int> > queue_;
+  std::unique_ptr<TaskQueue<int>> queue_;
   std::vector<int> dispatched_;
   base::WeakPtrFactory<TaskQueueTest> weak_ptr_factory_;
 };
 
 // See that at most one task is dispatched at a time.
 TEST_F(TaskQueueTest, AddToQueue_NoConcurrentTasks) {
   queue_->AddToQueue(1);
   queue_->AddToQueue(2);
   RunLoop();
 
@@ skipping 37 matching lines @@
   EXPECT_EQ(2, dispatched_.front());
   dispatched_.clear();
   queue_->MarkAsSucceeded(2);
   RunLoop();
 
   ASSERT_TRUE(dispatched_.empty());
 }
 
 // See that Retry works as expected.
 TEST_F(TaskQueueTest, Retry) {
-  scoped_ptr<base::MockTimer> timer_to_pass(new base::MockTimer(false, false));
+  std::unique_ptr<base::MockTimer> timer_to_pass(
+      new base::MockTimer(false, false));
   base::MockTimer* mock_timer = timer_to_pass.get();
   queue_->SetTimerForTest(std::move(timer_to_pass));
 
   // 1st attempt.
   queue_->AddToQueue(1);
   ASSERT_TRUE(mock_timer->IsRunning());
   ASSERT_EQ(kZero, mock_timer->GetCurrentDelay());
   TimeDelta last_delay = mock_timer->GetCurrentDelay();
   mock_timer->Fire();
   RunLoop();
@@ skipping 77 matching lines @@
   EXPECT_EQ(1, dispatched_.front());
   dispatched_.clear();
   queue_->Cancel(1);
   RunLoop();
 
   ASSERT_TRUE(dispatched_.empty());
 }
 
 // See that ResetBackoff resets the backoff delay.
 TEST_F(TaskQueueTest, ResetBackoff) {
-  scoped_ptr<base::MockTimer> timer_to_pass(new base::MockTimer(false, false));
+  std::unique_ptr<base::MockTimer> timer_to_pass(
+      new base::MockTimer(false, false));
   base::MockTimer* mock_timer = timer_to_pass.get();
   queue_->SetTimerForTest(std::move(timer_to_pass));
 
   // Add an item, mark it as failed, re-add it and see that we now have a
   // backoff delay.
   queue_->AddToQueue(1);
   ASSERT_TRUE(mock_timer->IsRunning());
   ASSERT_EQ(kZero, mock_timer->GetCurrentDelay());
   mock_timer->Fire();
   RunLoop();
@@ skipping 14 matching lines @@
   mock_timer->Fire();
   RunLoop();
   ASSERT_FALSE(mock_timer->IsRunning());
   ASSERT_EQ(1U, dispatched_.size());
   EXPECT_EQ(1, dispatched_.front());
   dispatched_.clear();
   queue_->MarkAsSucceeded(1);
 }
 
 }  // namespace syncer