Convert //chromecast from scoped_ptr to std::unique_ptr

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"
@@ skipping 87 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)
+MediaMessageFifo::MediaMessageFifo(std::unique_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));
@@ skipping 29 matching lines @@
 void MediaMessageFifo::ObserveReadActivity(
     const base::Closure& read_event_cb) {
   read_event_cb_ = read_event_cb;
 }
 
 void MediaMessageFifo::ObserveWriteActivity(
     const base::Closure& write_event_cb) {
   write_event_cb_ = write_event_cb;
 }
 
-scoped_ptr<MediaMemoryChunk> MediaMessageFifo::ReserveMemory(
+std::unique_ptr<MediaMemoryChunk> MediaMessageFifo::ReserveMemory(
     size_t size_to_reserve) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Capture first both the read and write offsets.
   // and exit right away if not enough free space.
   size_t wr_offset = internal_wr_offset();
   size_t rd_offset = current_rd_offset();
   size_t allocated_size = (size_ + wr_offset - rd_offset) % size_;
   size_t free_size = size_ - 1 - allocated_size;
   if (free_size < size_to_reserve)
-    return scoped_ptr<MediaMemoryChunk>();
+    return std::unique_ptr<MediaMemoryChunk>();
   CHECK_LE(MediaMessage::minimum_msg_size(), size_to_reserve);
 
   // Note: in the next 2 conditions, we have:
   // trailing_byte_count < size_to_reserve
   // and since at this stage: size_to_reserve <= free_size
   // we also have trailing_byte_count <= free_size
   // which means that all the trailing bytes are free space in the fifo.
   size_t trailing_byte_count = size_ - wr_offset;
   if (trailing_byte_count < MediaMessage::minimum_msg_size()) {
     // If there is no space to even write the smallest message,
     // skip the trailing bytes and come back to the beginning of the fifo.
     // (no way to insert a padding message).
     if (free_size < trailing_byte_count)
-      return scoped_ptr<MediaMemoryChunk>();
+      return std::unique_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(
+    std::unique_ptr<MediaMemoryChunk> mem(
         ReserveMemoryNoCheck(trailing_byte_count));
-    scoped_ptr<MediaMessage> padding_message(
+    std::unique_ptr<MediaMessage> padding_message(
         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 std::unique_ptr<MediaMemoryChunk>();
 
   return ReserveMemoryNoCheck(size_to_reserve);
 }
 
-scoped_ptr<MediaMessage> MediaMessageFifo::Pop() {
+std::unique_ptr<MediaMessage> MediaMessageFifo::Pop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Capture the read and write offsets.
   size_t rd_offset = internal_rd_offset();
   size_t wr_offset = current_wr_offset();
   size_t allocated_size = (size_ + wr_offset - rd_offset) % size_;
 
   if (allocated_size < MediaMessage::minimum_msg_size())
-    return scoped_ptr<MediaMessage>();
+    return std::unique_ptr<MediaMessage>();
 
   size_t trailing_byte_count = size_ - rd_offset;
   if (trailing_byte_count < MediaMessage::minimum_msg_size()) {
     // If there is no space to even have the smallest message,
     // skip the trailing bytes and come back to the beginning of the fifo.
     // Note: all the trailing bytes correspond to allocated bytes since:
     // trailing_byte_count < MediaMessage::minimum_msg_size() <= allocated_size
     rd_offset = 0;
     allocated_size -= trailing_byte_count;
     trailing_byte_count = size_;
     CommitInternalRead(rd_offset);
   }
 
   // The message should not be longer than the allocated size
   // but since a message is a contiguous area of memory, it should also be
   // smaller than |trailing_byte_count|.
   size_t max_msg_size = std::min(allocated_size, trailing_byte_count);
   if (max_msg_size < MediaMessage::minimum_msg_size())
-    return scoped_ptr<MediaMessage>();
+    return std::unique_ptr<MediaMessage>();
   void* msg_src = static_cast<uint8_t*>(base_) + rd_offset;
 
   // Create a flag to protect the serialized structure of the message
   // 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_)));
+  std::unique_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(std::move(mem)));
+  std::unique_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;
 }
 
 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";
     rd_flags_.front()->Invalidate();
     rd_flags_.pop_front();
   }
 
   // Flush by setting the read pointer to the value of the write pointer.
   // Update first the internal read pointer then the public one.
   CommitInternalRead(wr_offset);
   CommitRead(wr_offset);
 }
 
-scoped_ptr<MediaMemoryChunk> MediaMessageFifo::ReserveMemoryNoCheck(
+std::unique_ptr<MediaMemoryChunk> MediaMessageFifo::ReserveMemoryNoCheck(
     size_t size_to_reserve) {
   size_t wr_offset = internal_wr_offset();
 
   // Memory block corresponding to the serialized structure of the message.
   void* msg_start = static_cast<uint8_t*>(base_) + wr_offset;
   scoped_refptr<MediaMessageFlag> wr_flag(new MediaMessageFlag(wr_offset));
   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_)));
+  std::unique_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;
 }
 
 void MediaMessageFifo::OnWrMemoryReleased() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 98 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