Convert //remoting to use std::unique_ptr

remoting/protocol/capture_scheduler_unittest.cc

 // Copyright 2015 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 "remoting/protocol/capture_scheduler.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/timer/mock_timer.h"
 #include "remoting/proto/video.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 namespace protocol {
 
 static const int kTestInputs[] = { 100, 50, 30, 20, 10, 30, 60, 80 };
 static const int kMinumumFrameIntervalMs = 50;
 
 class CaptureSchedulerTest : public testing::Test {
  public:
   CaptureSchedulerTest() : capture_called_(false) {}
 
   void InitScheduler() {
     scheduler_.reset(new CaptureScheduler(
         base::Bind(&CaptureSchedulerTest::DoCapture, base::Unretained(this))));
     scheduler_->set_minimum_interval(
         base::TimeDelta::FromMilliseconds(kMinumumFrameIntervalMs));
     tick_clock_ = new base::SimpleTestTickClock();
-    scheduler_->SetTickClockForTest(make_scoped_ptr(tick_clock_));
+    scheduler_->SetTickClockForTest(base::WrapUnique(tick_clock_));
     capture_timer_ = new base::MockTimer(false, false);
-    scheduler_->SetTimerForTest(make_scoped_ptr(capture_timer_));
+    scheduler_->SetTimerForTest(base::WrapUnique(capture_timer_));
     scheduler_->Start();
   }
 
   void DoCapture() {
     capture_called_ = true;
   }
 
   void CheckCaptureCalled() {
     EXPECT_TRUE(capture_called_);
     capture_called_ = false;
   }
 
   void SimulateSingleFrameCapture(
       base::TimeDelta capture_delay,
       base::TimeDelta encode_delay,
       base::TimeDelta expected_delay_between_frames) {
     capture_timer_->Fire();
     CheckCaptureCalled();
     tick_clock_->Advance(capture_delay);
     scheduler_->OnCaptureCompleted();
 
     VideoPacket packet;
     packet.set_encode_time_ms(encode_delay.InMilliseconds());
     scheduler_->OnFrameEncoded(&packet);
 
     scheduler_->OnFrameSent();
 
-    scoped_ptr<VideoAck> ack(new VideoAck());
+    std::unique_ptr<VideoAck> ack(new VideoAck());
     ack->set_frame_id(packet.frame_id());
     scheduler_->ProcessVideoAck(std::move(ack));
 
     EXPECT_TRUE(capture_timer_->IsRunning());
     EXPECT_EQ(std::max(base::TimeDelta(),
                        expected_delay_between_frames - capture_delay),
               capture_timer_->GetCurrentDelay());
   }
 
  protected:
   base::MessageLoop message_loop_;
 
-  scoped_ptr<CaptureScheduler> scheduler_;
+  std::unique_ptr<CaptureScheduler> scheduler_;
 
   // Owned by |scheduler_|.
   base::SimpleTestTickClock* tick_clock_;
   base::MockTimer* capture_timer_;
 
   bool capture_called_;
 };
 
 TEST_F(CaptureSchedulerTest, SingleSampleSameTimes) {
   const int kTestResults[][arraysize(kTestInputs)] = {
@@ skipping 99 matching lines @@
     CheckCaptureCalled();
     scheduler_->OnCaptureCompleted();
     VideoPacket packet;
     scheduler_->OnFrameEncoded(&packet);
     scheduler_->OnFrameSent();
   }
 
   // Next frame should be scheduled, once one of the queued frames is
   // acknowledged.
   EXPECT_FALSE(capture_timer_->IsRunning());
-  scheduler_->ProcessVideoAck(make_scoped_ptr(new VideoAck()));
+  scheduler_->ProcessVideoAck(base::WrapUnique(new VideoAck()));
   EXPECT_TRUE(capture_timer_->IsRunning());
 }
 
 }  // namespace protocol
 }  // namespace remoting