Convert //tools to use std::unique_ptr

tools/battor_agent/battor_agent_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 "tools/battor_agent/battor_agent.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/battor_agent/battor_protocol_types.h"
 
 using namespace testing;
 
 using std::vector;
 
 namespace battor {
 
 namespace {
 
 BattOrControlMessageAck kInitAck{BATTOR_CONTROL_MESSAGE_TYPE_INIT, 0};
 BattOrControlMessageAck kSetGainAck{BATTOR_CONTROL_MESSAGE_TYPE_SET_GAIN, 0};
 BattOrControlMessageAck kStartTracingAck{
     BATTOR_CONTROL_MESSAGE_TYPE_START_SAMPLING_SD, 0};
 const char kClockSyncId[] = "MY_MARKER";
 
 // Creates a byte vector copy of the specified object.
 template <typename T>
-scoped_ptr<std::vector<char>> ToCharVector(const T& object) {
-  return scoped_ptr<std::vector<char>>(new std::vector<char>(
+std::unique_ptr<std::vector<char>> ToCharVector(const T& object) {
+  return std::unique_ptr<std::vector<char>>(new std::vector<char>(
       reinterpret_cast<const char*>(&object),
       reinterpret_cast<const char*>(&object) + sizeof(T)));
 }
 
 MATCHER_P2(
     BufferEq,
     expected_buffer,
     expected_buffer_size,
     "Makes sure that the argument has the same contents as the buffer.") {
   return memcmp(reinterpret_cast<const void*>(arg),
                 reinterpret_cast<const void*>(expected_buffer),
                 expected_buffer_size) == 0;
 }
 
-scoped_ptr<vector<char>> CreateFrame(const BattOrFrameHeader& frame_header,
-                                     const RawBattOrSample* samples,
-                                     const size_t& num_samples) {
-  scoped_ptr<vector<char>> bytes(new vector<char>(
+std::unique_ptr<vector<char>> CreateFrame(const BattOrFrameHeader& frame_header,
+                                          const RawBattOrSample* samples,
+                                          const size_t& num_samples) {
+  std::unique_ptr<vector<char>> bytes(new vector<char>(
       sizeof(BattOrFrameHeader) + sizeof(RawBattOrSample) * num_samples));
   memcpy(bytes->data(), &frame_header, sizeof(BattOrFrameHeader));
   memcpy(bytes->data() + sizeof(BattOrFrameHeader), samples,
          sizeof(RawBattOrSample) * num_samples);
 
   return bytes;
 }
 
 class MockBattOrConnection : public BattOrConnection {
  public:
@@ skipping 14 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockBattOrConnection);
 };
 
 }  // namespace
 
 // TestableBattOrAgent uses a fake BattOrConnection to be testable.
 class TestableBattOrAgent : public BattOrAgent {
  public:
   TestableBattOrAgent(BattOrAgent::Listener* listener)
       : BattOrAgent("/dev/test", listener, nullptr, nullptr) {
-    connection_ = scoped_ptr<BattOrConnection>(new MockBattOrConnection(this));
+    connection_ =
+        std::unique_ptr<BattOrConnection>(new MockBattOrConnection(this));
   }
 
   MockBattOrConnection* GetConnection() {
     return static_cast<MockBattOrConnection*>(connection_.get());
   }
 
   void OnActionTimeout() override {}
 };
 
 // BattOrAgentTest provides a BattOrAgent and captures the results of its
@@ skipping 21 matching lines @@
     command_error_ = error;
   }
 
   void OnBytesSent(bool success) {
     agent_->OnBytesSent(success);
     task_runner_->RunUntilIdle();
   }
 
   void OnMessageRead(bool success,
                      BattOrMessageType type,
-                     scoped_ptr<std::vector<char>> bytes) {
+                     std::unique_ptr<std::vector<char>> bytes) {
     agent_->OnMessageRead(success, type, std::move(bytes));
     task_runner_->RunUntilIdle();
   }
 
  protected:
   void SetUp() override {
     agent_.reset(new TestableBattOrAgent(this));
     task_runner_->ClearPendingTasks();
     is_command_complete_ = false;
     command_error_ = BATTOR_ERROR_NONE;
@@ skipping 148 matching lines @@
 
   bool IsCommandComplete() { return is_command_complete_; }
   BattOrError GetCommandError() { return command_error_; }
   std::string GetTrace() { return trace_; }
 
  private:
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   // Needed to support ThreadTaskRunnerHandle::Get() in code under test.
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
 
-  scoped_ptr<TestableBattOrAgent> agent_;
+  std::unique_ptr<TestableBattOrAgent> agent_;
   bool is_command_complete_;
   BattOrError command_error_;
   std::string trace_;
 };
 
 TEST_F(BattOrAgentTest, StartTracing) {
   testing::InSequence s;
   EXPECT_CALL(*GetAgent()->GetConnection(), Open());
 
   BattOrControlMessage reset_msg{BATTOR_CONTROL_MESSAGE_TYPE_RESET, 0, 0};
@@ skipping 397 matching lines @@
 
 TEST_F(BattOrAgentTest, StopTracingFailsIfCalibrationFrameMissingByte) {
   RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
 
   BattOrFrameHeader cal_frame_header{0, 2 * sizeof(RawBattOrSample)};
   RawBattOrSample cal_frame[] = {
       RawBattOrSample{1, 1}, RawBattOrSample{2, 2},
   };
 
   // Remove the last byte from the frame to make it invalid.
-  scoped_ptr<vector<char>> cal_frame_bytes =
+  std::unique_ptr<vector<char>> cal_frame_bytes =
       CreateFrame(cal_frame_header, cal_frame, 2);
   cal_frame_bytes->pop_back();
 
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES, std::move(cal_frame_bytes));
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StopTracingFailsIfDataFrameMissingByte) {
   RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
 
   BattOrFrameHeader cal_frame_header{0, 1 * sizeof(RawBattOrSample)};
   RawBattOrSample cal_frame[] = {
       RawBattOrSample{1, 1},
   };
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES,
                 CreateFrame(cal_frame_header, cal_frame, 1));
 
   BattOrFrameHeader frame_header{1, 1 * sizeof(RawBattOrSample)};
   RawBattOrSample frame[] = {RawBattOrSample{1, 1}};
 
   // Remove the last byte from the frame to make it invalid.
-  scoped_ptr<vector<char>> frame_bytes = CreateFrame(frame_header, frame, 2);
+  std::unique_ptr<vector<char>> frame_bytes =
+      CreateFrame(frame_header, frame, 2);
   frame_bytes->pop_back();
 
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES, std::move(frame_bytes));
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StopTracingFailsIfFrameArrivesOutOfOrder) {
   RunStopTracingTo(BattOrAgentState::CALIBRATION_FRAME_RECEIVED);
@@ skipping 118 matching lines @@
 
   uint32_t current_sample = 1;
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL,
                 ToCharVector(current_sample));
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetCommandError());
 }
 
 }  // namespace battor