Convert device to std::unique_ptr

device/serial/serial_connection_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 "device/serial/serial_connection.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "device/serial/data_receiver.h"
 #include "device/serial/data_sender.h"
@@ skipping 48 matching lines @@
         expected_event_(EVENT_NONE) {}
 
   void SetUp() override {
     message_loop_.reset(new base::MessageLoop);
     mojo::InterfacePtr<serial::SerialService> service;
     new SerialServiceImpl(
         new SerialConnectionFactory(
             base::Bind(&SerialConnectionTest::CreateIoHandler,
                        base::Unretained(this)),
             base::ThreadTaskRunnerHandle::Get()),
-        scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator),
+        std::unique_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator),
         mojo::GetProxy(&service));
     service.set_connection_error_handler(base::Bind(
         &SerialConnectionTest::OnConnectionError, base::Unretained(this)));
     mojo::InterfacePtr<serial::DataSink> sink;
     mojo::InterfacePtr<serial::DataSource> source;
     mojo::InterfacePtr<serial::DataSourceClient> source_client;
     mojo::InterfaceRequest<serial::DataSourceClient> source_client_request =
         mojo::GetProxy(&source_client);
     service->Connect("device", serial::ConnectionOptions::New(),
                      mojo::GetProxy(&connection_), mojo::GetProxy(&sink),
@@ skipping 69 matching lines @@
     send_error_ = serial::SendError::NONE;
     EventReceived(EVENT_DATA_SENT);
   }
 
   void OnSendError(uint32_t bytes_sent, int32_t error) {
     bytes_sent_ += bytes_sent;
     send_error_ = static_cast<serial::SendError>(error);
     EventReceived(EVENT_SEND_ERROR);
   }
 
-  void OnDataReceived(scoped_ptr<ReadOnlyBuffer> buffer) {
+  void OnDataReceived(std::unique_ptr<ReadOnlyBuffer> buffer) {
     data_received_ += std::string(buffer->GetData(), buffer->GetSize());
     buffer->Done(buffer->GetSize());
     receive_error_ = serial::ReceiveError::NONE;
     EventReceived(EVENT_DATA_RECEIVED);
   }
 
   void OnReceiveError(int32_t error) {
     receive_error_ = static_cast<serial::ReceiveError>(error);
     EventReceived(EVENT_RECEIVE_ERROR);
   }
 
   void OnConnectionError() {
     EventReceived(EVENT_ERROR);
     FAIL() << "Connection error";
   }
 
   mojo::Array<serial::DeviceInfoPtr> devices_;
   serial::ConnectionInfoPtr info_;
   serial::DeviceControlSignalsPtr signals_;
   bool connected_;
   bool success_;
   int bytes_sent_;
   serial::SendError send_error_;
   serial::ReceiveError receive_error_;
   std::string data_received_;
   Event expected_event_;
 
-  scoped_ptr<base::MessageLoop> message_loop_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
   base::Closure stop_run_loop_;
   mojo::InterfacePtr<serial::Connection> connection_;
-  scoped_ptr<DataSender> sender_;
+  std::unique_ptr<DataSender> sender_;
   scoped_refptr<DataReceiver> receiver_;
   scoped_refptr<TestSerialIoHandler> io_handler_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SerialConnectionTest);
 };
 
 const uint32_t SerialConnectionTest::kBufferSize = 10;
 
 TEST_F(SerialConnectionTest, GetInfo) {
@@ skipping 122 matching lines @@
   WaitForEvent(EVENT_DATA_SENT);
   EXPECT_EQ(serial::SendError::NONE, send_error_);
   EXPECT_EQ(4, bytes_sent_);
   ASSERT_NO_FATAL_FAILURE(Receive());
   WaitForEvent(EVENT_DATA_RECEIVED);
   EXPECT_EQ("data", data_received_);
   EXPECT_EQ(serial::ReceiveError::NONE, receive_error_);
 }
 
 }  // namespace device