Convert Pass()→std::move() in //chromecast

chromecast/media/cma/ipc/media_message.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 "chromecast/media/cma/ipc/media_message.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/logging.h"
 #include "chromecast/media/cma/ipc/media_memory_chunk.h"
 
 namespace chromecast {
 namespace media {
 
 // static
 scoped_ptr<MediaMessage> MediaMessage::CreateDummyMessage(uint32_t type) {
   return scoped_ptr<MediaMessage>(
@@ skipping 10 matching lines @@
   // Make the message size a multiple of the alignment
   // so that if we have proper alignment for array of messages.
   size_t end_alignment = msg_size % ALIGNOF(SerializedMsg);
   if (end_alignment != 0)
     msg_size += ALIGNOF(SerializedMsg) - end_alignment;
 
   scoped_ptr<MediaMemoryChunk> memory(memory_allocator.Run(msg_size));
   if (!memory)
     return scoped_ptr<MediaMessage>();
 
-  return scoped_ptr<MediaMessage>(new MediaMessage(type, memory.Pass()));
+  return scoped_ptr<MediaMessage>(new MediaMessage(type, std::move(memory)));
 }
 
 // static
 scoped_ptr<MediaMessage> MediaMessage::CreateMessage(
     uint32_t type,
     scoped_ptr<MediaMemoryChunk> memory) {
-  return scoped_ptr<MediaMessage>(new MediaMessage(type, memory.Pass()));
+  return scoped_ptr<MediaMessage>(new MediaMessage(type, std::move(memory)));
 }
 
 // static
 scoped_ptr<MediaMessage> MediaMessage::MapMessage(
     scoped_ptr<MediaMemoryChunk> memory) {
-  return scoped_ptr<MediaMessage>(new MediaMessage(memory.Pass()));
+  return scoped_ptr<MediaMessage>(new MediaMessage(std::move(memory)));
 }
 
 MediaMessage::MediaMessage(uint32_t type, size_t msg_size)
     : is_dummy_msg_(true),
       cached_header_(&cached_msg_.header),
       msg_(&cached_msg_),
       msg_read_only_(&cached_msg_),
       rd_offset_(0) {
   cached_header_->size = msg_size;
   cached_header_->type = type;
   cached_header_->content_size = 0;
 }
 
 MediaMessage::MediaMessage(uint32_t type, scoped_ptr<MediaMemoryChunk> memory)
     : is_dummy_msg_(false),
       cached_header_(&cached_msg_.header),
       msg_(static_cast<SerializedMsg*>(memory->data())),
       msg_read_only_(msg_),
-      mem_(memory.Pass()),
+      mem_(std::move(memory)),
       rd_offset_(0) {
   CHECK(mem_->valid());
   CHECK_GE(mem_->size(), minimum_msg_size());
 
   // Check memory alignment:
   // needed to cast properly |msg_dst| to a SerializedMsg.
   CHECK_EQ(
       reinterpret_cast<uintptr_t>(mem_->data()) % ALIGNOF(SerializedMsg), 0u);
 
   // Make sure that |mem_->data()| + |mem_->size()| is also aligned correctly.
   // This is needed if we append a second serialized message next to this one.
   // The second serialized message must be aligned correctly.
   // It is similar to what a compiler is doing for arrays of structures.
   CHECK_EQ(mem_->size() % ALIGNOF(SerializedMsg), 0u);
 
   cached_header_->size = mem_->size();
   cached_header_->type = type;
   cached_header_->content_size = 0;
   msg_->header = *cached_header_;
 }
 
 MediaMessage::MediaMessage(scoped_ptr<MediaMemoryChunk> memory)
-  : is_dummy_msg_(false),
-    cached_header_(&cached_msg_.header),
-    msg_(NULL),
-    msg_read_only_(static_cast<SerializedMsg*>(memory->data())),
-    mem_(memory.Pass()),
-    rd_offset_(0) {
+    : is_dummy_msg_(false),
+      cached_header_(&cached_msg_.header),
+      msg_(NULL),
+      msg_read_only_(static_cast<SerializedMsg*>(memory->data())),
+      mem_(std::move(memory)),
+      rd_offset_(0) {
   CHECK(mem_->valid());
 
   // Check memory alignment.
   CHECK_EQ(
       reinterpret_cast<uintptr_t>(mem_->data()) % ALIGNOF(SerializedMsg), 0u);
 
   // Cache the message header which cannot be modified while reading.
   CHECK_GE(mem_->size(), minimum_msg_size());
   *cached_header_ = msg_read_only_->header;
   CHECK_GE(cached_header_->size, minimum_msg_size());
@@ skipping 78 matching lines @@
   rd_offset_ += size;
   return rd_ptr;
 }
 
 const void* MediaMessage::GetBuffer(size_t size) {
   return GetWritableBuffer(size);
 }
 
 }  // namespace media
 }  // namespace chromecast