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

chromecast/media/cma/ipc/media_message_fifo.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_fifo.h"
 
+#include <utility>
+
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/ipc/media_memory_chunk.h"
 #include "chromecast/media/cma/ipc/media_message.h"
@@ skipping 79 matching lines @@
   flag_ = scoped_refptr<MediaMessageFlag>();
   if (!release_msg_cb_.is_null()) {
     if (task_runner_->BelongsToCurrentThread()) {
       release_msg_cb_.Run();
     } else {
       task_runner_->PostTask(FROM_HERE, release_msg_cb_);
     }
   }
 }
 
-MediaMessageFifo::MediaMessageFifo(
-    scoped_ptr<MediaMemoryChunk> mem, bool init)
-  : mem_(mem.Pass()),
-    weak_factory_(this) {
+MediaMessageFifo::MediaMessageFifo(scoped_ptr<MediaMemoryChunk> mem, bool init)
+    : mem_(std::move(mem)), weak_factory_(this) {
   CHECK_EQ(reinterpret_cast<uintptr_t>(mem_->data()) % ALIGNOF(Descriptor),
            0u);
   CHECK_GE(mem_->size(), sizeof(Descriptor));
   Descriptor* desc = static_cast<Descriptor*>(mem_->data());
   base_ = static_cast<void*>(&desc->first_item);
 
   // TODO(damienv): remove cast when atomic size_t is defined in Chrome.
   // Currently, the sign differs.
   rd_offset_ = reinterpret_cast<AtomicSize*>(&(desc->rd_offset));
   wr_offset_ = reinterpret_cast<AtomicSize*>(&(desc->wr_offset));
@@ skipping 63 matching lines @@
       return scoped_ptr<MediaMemoryChunk>();
     wr_offset = 0;
     CommitInternalWrite(wr_offset);
 
   } else if (trailing_byte_count < size_to_reserve) {
     // At this point, we know we have at least the space to write a message.
     // However, to avoid splitting a message, a padding message is needed.
     scoped_ptr<MediaMemoryChunk> mem(
         ReserveMemoryNoCheck(trailing_byte_count));
     scoped_ptr<MediaMessage> padding_message(
-        MediaMessage::CreateMessage(PaddingMediaMsg, mem.Pass()));
+        MediaMessage::CreateMessage(PaddingMediaMsg, std::move(mem)));
   }
 
   // Recalculate the free size and exit if not enough free space.
   wr_offset = internal_wr_offset();
   allocated_size = (size_ + wr_offset - rd_offset) % size_;
   free_size = size_ - 1 - allocated_size;
   if (free_size < size_to_reserve)
     return scoped_ptr<MediaMemoryChunk>();
 
   return ReserveMemoryNoCheck(size_to_reserve);
@@ skipping 34 matching lines @@
   // from being overwritten.
   // The serialized structure starts at offset |rd_offset|.
   scoped_refptr<MediaMessageFlag> rd_flag(new MediaMessageFlag(rd_offset));
   rd_flags_.push_back(rd_flag);
   scoped_ptr<MediaMemoryChunk> mem(
       new FifoOwnedMemory(
           msg_src, max_msg_size, rd_flag,
           base::Bind(&MediaMessageFifo::OnRdMemoryReleased, weak_this_)));
 
   // Create the message which wraps its the serialized structure.
-  scoped_ptr<MediaMessage> message(MediaMessage::MapMessage(mem.Pass()));
+  scoped_ptr<MediaMessage> message(MediaMessage::MapMessage(std::move(mem)));
   CHECK(message);
 
   // Update the internal read pointer.
   rd_offset = (rd_offset + message->size()) % size_;
   CommitInternalRead(rd_offset);
 
-  return message.Pass();
+  return message;
 }
 
 void MediaMessageFifo::Flush() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   size_t wr_offset = current_wr_offset();
 
   // Invalidate every memory region before flushing.
   while (!rd_flags_.empty()) {
     CMALOG(kLogControl) << "Invalidate flag";
@@ skipping 17 matching lines @@
   wr_flags_.push_back(wr_flag);
   scoped_ptr<MediaMemoryChunk> mem(
       new FifoOwnedMemory(
           msg_start, size_to_reserve, wr_flag,
           base::Bind(&MediaMessageFifo::OnWrMemoryReleased, weak_this_)));
 
   // Update the internal write pointer.
   wr_offset = (wr_offset + size_to_reserve) % size_;
   CommitInternalWrite(wr_offset);
 
-  return mem.Pass();
+  return mem;
 }
 
 void MediaMessageFifo::OnWrMemoryReleased() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (wr_flags_.empty()) {
     // Sanity check: when there is no protected memory area,
     // the external write offset has no reason to be different from
     // the internal write offset.
     DCHECK_EQ(current_wr_offset(), internal_wr_offset());
@@ skipping 92 matching lines @@
 void MediaMessageFifo::CommitInternalRead(size_t new_rd_offset) {
   internal_rd_offset_ = new_rd_offset;
 }
 
 void MediaMessageFifo::CommitInternalWrite(size_t new_wr_offset) {
   internal_wr_offset_ = new_wr_offset;
 }
 
 }  // namespace media
 }  // namespace chromecast