Convert //tools to use std::unique_ptr

tools/battor_agent/battor_connection_impl_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_connection_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/serial/serial.mojom.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/battor_agent/battor_protocol_types.h"
 
 namespace {
 
@@ skipping 22 matching lines @@
                                  public BattOrConnection::Listener {
  public:
   BattOrConnectionImplTest()
       : task_runner_(new base::TestSimpleTaskRunner()),
         thread_task_runner_handle_(task_runner_) {}
 
   void OnConnectionOpened(bool success) override { open_success_ = success; };
   void OnBytesSent(bool success) override { send_success_ = success; }
   void OnMessageRead(bool success,
                      BattOrMessageType type,
-                     scoped_ptr<std::vector<char>> bytes) override {
+                     std::unique_ptr<std::vector<char>> bytes) override {
     is_read_complete_ = true;
     read_success_ = success;
     read_type_ = type;
     read_bytes_ = std::move(bytes);
   }
 
  protected:
   void SetUp() override {
     connection_.reset(new TestableBattOrConnection(this));
     task_runner_->ClearPendingTasks();
   }
 
   void OpenConnection() {
     connection_->Open();
     task_runner_->RunUntilIdle();
   }
 
   void ReadMessage(BattOrMessageType type) {
     is_read_complete_ = false;
     connection_->ReadMessage(type);
     task_runner_->RunUntilIdle();
   }
 
   // Reads the specified number of bytes directly from the serial connection.
   scoped_refptr<net::IOBuffer> ReadMessageRaw(int bytes_to_read) {
     scoped_refptr<net::IOBuffer> buffer(
         new net::IOBuffer((size_t)bytes_to_read));
 
-    connection_->GetIoHandler()->Read(make_scoped_ptr(new device::ReceiveBuffer(
-        buffer, bytes_to_read, base::Bind(&NullReadCallback))));
+    connection_->GetIoHandler()->Read(
+        base::WrapUnique(new device::ReceiveBuffer(
+            buffer, bytes_to_read, base::Bind(&NullReadCallback))));
     task_runner_->RunUntilIdle();
 
     return buffer;
   }
 
   void SendControlMessage(BattOrControlMessageType type,
                           uint16_t param1,
                           uint16_t param2) {
     BattOrControlMessage msg{type, param1, param2};
     connection_->SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
                            reinterpret_cast<char*>(&msg), sizeof(msg));
     task_runner_->RunUntilIdle();
   }
 
   // Writes the specified bytes directly to the serial connection.
   void SendBytesRaw(const char* data, uint16_t bytes_to_send) {
     std::vector<char> data_vector(data, data + bytes_to_send);
-    connection_->GetIoHandler()->Write(make_scoped_ptr(
+    connection_->GetIoHandler()->Write(base::WrapUnique(
         new device::SendBuffer(data_vector, base::Bind(&NullWriteCallback))));
     task_runner_->RunUntilIdle();
   }
 
   bool GetOpenSuccess() { return open_success_; }
   bool GetSendSuccess() { return send_success_; }
   bool IsReadComplete() { return is_read_complete_; }
   bool GetReadSuccess() { return read_success_; }
   BattOrMessageType GetReadType() { return read_type_; }
   std::vector<char>* GetReadMessage() { return read_bytes_.get(); }
 
  private:
-  scoped_ptr<TestableBattOrConnection> connection_;
+  std::unique_ptr<TestableBattOrConnection> connection_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
 
   // Result from the last connect command.
   bool open_success_;
   // Result from the last send command.
   bool send_success_;
   // Results from the last read command.
   bool is_read_complete_;
   bool read_success_;
   BattOrMessageType read_type_;
-  scoped_ptr<std::vector<char>> read_bytes_;
+  std::unique_ptr<std::vector<char>> read_bytes_;
 };
 
 TEST_F(BattOrConnectionImplTest, InitSendsCorrectBytes) {
   OpenConnection();
   ASSERT_TRUE(GetOpenSuccess());
 
   SendControlMessage(BATTOR_CONTROL_MESSAGE_TYPE_INIT, 0, 0);
 
   const char expected_data[] = {
       BATTOR_CONTROL_BYTE_START,  BATTOR_MESSAGE_TYPE_CONTROL,
@@ skipping 251 matching lines @@
       BATTOR_CONTROL_BYTE_END,
   };
   SendBytesRaw(data, 3);
   ReadMessage(BATTOR_MESSAGE_TYPE_PRINT);
 
   ASSERT_TRUE(IsReadComplete());
   ASSERT_FALSE(GetReadSuccess());
 }
 
 }  // namespace battor