Convert device to std::unique_ptr

device/serial/data_sink_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 <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #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_sender.h"
 #include "device/serial/data_sink_receiver.h"
 #include "device/serial/data_stream.mojom.h"
@@ skipping 134 matching lines @@
     EventReceived(EVENT_SEND_SUCCESS);
   }
 
   void OnSendError(uint32_t bytes_sent, int32_t error) {
     bytes_sent_ = bytes_sent;
     send_error_ = error;
     has_send_error_ = true;
     EventReceived(EVENT_SEND_ERROR);
   }
 
-  void OnDataToRead(scoped_ptr<ReadOnlyBuffer> buffer) {
+  void OnDataToRead(std::unique_ptr<ReadOnlyBuffer> buffer) {
     read_buffer_ = std::move(buffer);
     read_buffer_contents_ =
         std::string(read_buffer_->GetData(), read_buffer_->GetSize());
     EventReceived(EVENT_READ_BUFFER_READY);
   }
 
   bool Cancel(int32_t error) {
     return sender_->Cancel(
         error, base::Bind(&DataSinkTest::CancelAck, base::Unretained(this)));
   }
 
   void CancelAck() { EventReceived(EVENT_CANCEL_COMPLETE); }
 
   void OnCancel(int32_t error) {
     cancel_error_ = error;
     EventReceived(EVENT_CANCEL_RECEIVED);
   }
 
  protected:
   static const int32_t kFatalError;
   static const uint32_t kBufferSize;
-  scoped_ptr<base::MessageLoop> message_loop_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
   base::Closure stop_run_loop_;
 
   scoped_refptr<DataSinkReceiver> sink_receiver_;
-  scoped_ptr<DataSender> sender_;
+  std::unique_ptr<DataSender> sender_;
 
   uint32_t bytes_sent_;
   int32_t send_error_;
   bool has_send_error_;
   int32_t cancel_error_;
-  scoped_ptr<ReadOnlyBuffer> read_buffer_;
+  std::unique_ptr<ReadOnlyBuffer> read_buffer_;
   std::string read_buffer_contents_;
 
   bool seen_connection_error_;
 
   Event expected_event_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DataSinkTest);
 };
 
@@ skipping 204 matching lines @@
   sender_.reset();
   ExpectSendError(0, kFatalError);
   ExpectSendError(0, kFatalError);
   ExpectCancelResult();
   if (!seen_connection_error_)
     WaitForEvent(EVENT_ERROR);
   EXPECT_TRUE(seen_connection_error_);
 }
 
 }  // namespace device