EDK: Convert remaining scoped_ptr -> std::unique_ptr in //mojo/edk/system.

mojo/edk/system/raw_channel.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 "mojo/edk/system/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 204 matching lines @@
     *set_on_shutdown_ = true;
     set_on_shutdown_ = nullptr;
   }
   write_stopped_ = true;
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   OnShutdownNoLock(std::move(read_buffer_), std::move(write_buffer_));
 }
 
 // Reminder: This must be thread-safe.
-bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
+bool RawChannel::WriteMessage(std::unique_ptr<MessageInTransit> message) {
   DCHECK(message);
 
   MutexLocker locker(&write_mutex_);
   if (write_stopped_)
     return false;
 
   if (!write_buffer_->message_queue_.IsEmpty()) {
-    EnqueueMessageNoLock(message.Pass());
+    EnqueueMessageNoLock(std::move(message));
     return true;
   }
 
-  EnqueueMessageNoLock(message.Pass());
+  EnqueueMessageNoLock(std::move(message));
   DCHECK_EQ(write_buffer_->data_offset_, 0u);
 
   size_t platform_handles_written = 0;
   size_t bytes_written = 0;
   IOResult io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   if (io_result == IO_PENDING)
     return true;
 
   bool result = OnWriteCompletedNoLock(io_result, platform_handles_written,
                                        bytes_written);
@@ skipping 176 matching lines @@
     did_fail = !OnWriteCompletedNoLock(io_result, platform_handles_written,
                                        bytes_written);
   }
 
   if (did_fail) {
     CallOnError(Delegate::ERROR_WRITE);
     return;  // |this| may have been destroyed in |CallOnError()|.
   }
 }
 
-void RawChannel::EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) {
+void RawChannel::EnqueueMessageNoLock(
+    std::unique_ptr<MessageInTransit> message) {
   write_mutex_.AssertHeld();
-  write_buffer_->message_queue_.AddMessage(message.Pass());
+  write_buffer_->message_queue_.AddMessage(std::move(message));
 }
 
 bool RawChannel::OnReadMessageForRawChannel(
     const MessageInTransit::View& message_view) {
   // No non-implementation specific |RawChannel| control messages.
   LOG(ERROR) << "Invalid control message (subtype " << message_view.subtype()
              << ")";
   return false;
 }
 
@@ skipping 57 matching lines @@
 
   write_stopped_ = true;
   write_buffer_->message_queue_.Clear();
   write_buffer_->platform_handles_offset_ = 0;
   write_buffer_->data_offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo