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

mojo/edk/system/channel.cc

 // Copyright 2013 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/channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 107 matching lines @@
     // There must not be an endpoint with that ID already.
     DCHECK(local_id_to_endpoint_map_.find(local_id) ==
            local_id_to_endpoint_map_.end());
 
     local_id_to_endpoint_map_[local_id] = endpoint;
   }
 
   endpoint->AttachAndRun(this, local_id, remote_id);
 }
 
-bool Channel::WriteMessage(scoped_ptr<MessageInTransit> message) {
+bool Channel::WriteMessage(std::unique_ptr<MessageInTransit> message) {
   MutexLocker locker(&mutex_);
   if (!is_running_) {
     // TODO(vtl): I think this is probably not an error condition, but I should
     // think about it (and the shutdown sequence) more carefully.
     LOG(WARNING) << "WriteMessage() after shutdown";
     return false;
   }
 
   DLOG_IF(WARNING, is_shutting_down_) << "WriteMessage() while shutting down";
-  return raw_channel_->WriteMessage(message.Pass());
+  return raw_channel_->WriteMessage(std::move(message));
 }
 
 bool Channel::IsWriteBufferEmpty() {
   MutexLocker locker(&mutex_);
   if (!is_running_)
     return true;
   return raw_channel_->IsWriteBufferEmpty();
 }
 
 void Channel::DetachEndpoint(ChannelEndpoint* endpoint,
@@ skipping 235 matching lines @@
             "Received a message for nonexistent local destination ID %u",
             static_cast<unsigned>(local_id.value())).c_str());
     // This is strongly indicative of some problem. However, it's not a fatal
     // error, since it may indicate a buggy (or hostile) remote process. Don't
     // die even for Debug builds, since handling this properly needs to be
     // tested (TODO(vtl)).
     DLOG(ERROR) << "This should not happen under normal operation.";
     return;
   }
 
-  scoped_ptr<MessageInTransit> message(new MessageInTransit(message_view));
+  std::unique_ptr<MessageInTransit> message(new MessageInTransit(message_view));
   if (message_view.transport_data_buffer_size() > 0) {
     DCHECK(message_view.transport_data_buffer());
     message->SetDispatchers(TransportData::DeserializeDispatchers(
         message_view.transport_data_buffer(),
         message_view.transport_data_buffer_size(), platform_handles.Pass(),
         this));
   }
 
-  endpoint->OnReadMessage(message.Pass());
+  endpoint->OnReadMessage(std::move(message));
 }
 
 void Channel::OnReadMessageForChannel(
     const MessageInTransit::View& message_view,
     embedder::ScopedPlatformHandleVectorPtr platform_handles) {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(message_view.type(), MessageInTransit::Type::CHANNEL);
 
   // Currently, no channel messages take platform handles.
   if (platform_handles) {
@@ skipping 203 matching lines @@
   return remote_id;
 }
 
 bool Channel::SendControlMessage(MessageInTransit::Subtype subtype,
                                  ChannelEndpointId local_id,
                                  ChannelEndpointId remote_id,
                                  uint32_t num_bytes,
                                  const void* bytes) {
   DVLOG(2) << "Sending channel control message: subtype " << subtype
            << ", local ID " << local_id << ", remote ID " << remote_id;
-  scoped_ptr<MessageInTransit> message(new MessageInTransit(
+  std::unique_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::CHANNEL, subtype, num_bytes, bytes));
   message->set_source_id(local_id);
   message->set_destination_id(remote_id);
-  return WriteMessage(message.Pass());
+  return WriteMessage(std::move(message));
 }
 
 }  // namespace system
 }  // namespace mojo