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

content/common/discardable_shared_memory_heap.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 "content/common/discardable_shared_memory_heap.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/discardable_shared_memory.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_manager.h"
 
 namespace content {
 namespace {
 
@@ skipping 19 matching lines @@
 DiscardableSharedMemoryHeap::Span::~Span() {
 }
 
 DiscardableSharedMemoryHeap::ScopedMemorySegment::ScopedMemorySegment(
     DiscardableSharedMemoryHeap* heap,
     scoped_ptr<base::DiscardableSharedMemory> shared_memory,
     size_t size,
     int32_t id,
     const base::Closure& deleted_callback)
     : heap_(heap),
-      shared_memory_(shared_memory.Pass()),
+      shared_memory_(std::move(shared_memory)),
       size_(size),
       id_(id),
-      deleted_callback_(deleted_callback) {
-}
+      deleted_callback_(deleted_callback) {}
 
 DiscardableSharedMemoryHeap::ScopedMemorySegment::~ScopedMemorySegment() {
   heap_->ReleaseMemory(shared_memory_.get(), size_);
   deleted_callback_.Run();
 }
 
 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsUsed() const {
   return heap_->IsMemoryUsed(shared_memory_.get(), size_);
 }
 
@@ skipping 62 matching lines @@
                reinterpret_cast<size_t>(shared_memory->memory()) / block_size_,
                size / block_size_));
   DCHECK(spans_.find(span->start_) == spans_.end());
   DCHECK(spans_.find(span->start_ + span->length_ - 1) == spans_.end());
   RegisterSpan(span.get());
 
   num_blocks_ += span->length_;
 
   // Start tracking if segment is resident by adding it to |memory_segments_|.
   memory_segments_.push_back(new ScopedMemorySegment(
-      this, shared_memory.Pass(), size, id, deleted_callback));
+      this, std::move(shared_memory), size, id, deleted_callback));
 
-  return span.Pass();
+  return span;
 }
 
 void DiscardableSharedMemoryHeap::MergeIntoFreeLists(scoped_ptr<Span> span) {
   DCHECK(span->shared_memory_);
 
   // First add length of |span| to |num_free_blocks_|.
   num_free_blocks_ += span->length_;
 
   // Merge with previous span if possible.
   SpanMap::iterator prev_it = spans_.find(span->start_ - 1);
@@ skipping 13 matching lines @@
   if (next_it != spans_.end() && IsInFreeList(next_it->second)) {
     scoped_ptr<Span> next = RemoveFromFreeList(next_it->second);
     DCHECK_EQ(next->start_, span->start_ + span->length_);
     UnregisterSpan(next.get());
     if (span->length_ > 1)
       spans_.erase(span->start_ + span->length_ - 1);
     span->length_ += next->length_;
     spans_[span->start_ + span->length_ - 1] = span.get();
   }
 
-  InsertIntoFreeList(span.Pass());
+  InsertIntoFreeList(std::move(span));
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::Split(Span* span, size_t blocks) {
   DCHECK(blocks);
   DCHECK_LT(blocks, span->length_);
 
   scoped_ptr<Span> leftover(new Span(
       span->shared_memory_, span->start_ + blocks, span->length_ - blocks));
   DCHECK(leftover->length_ == 1 ||
          spans_.find(leftover->start_) == spans_.end());
   RegisterSpan(leftover.get());
   spans_[span->start_ + blocks - 1] = span;
   span->length_ = blocks;
-  return leftover.Pass();
+  return leftover;
 }
 
 scoped_ptr<DiscardableSharedMemoryHeap::Span>
 DiscardableSharedMemoryHeap::SearchFreeLists(size_t blocks, size_t slack) {
   DCHECK(blocks);
 
   size_t length = blocks;
   size_t max_length = blocks + slack;
 
   // Search array of free lists for a suitable span.
@@ skipping 85 matching lines @@
   if (extra) {
     scoped_ptr<Span> leftover(
         new Span(serving->shared_memory_, serving->start_ + blocks, extra));
     leftover->set_is_locked(false);
     DCHECK(extra == 1 || spans_.find(leftover->start_) == spans_.end());
     RegisterSpan(leftover.get());
 
     // No need to coalesce as the previous span of |leftover| was just split
     // and the next span of |leftover| was not previously coalesced with
     // |span|.
-    InsertIntoFreeList(leftover.Pass());
+    InsertIntoFreeList(std::move(leftover));
 
     serving->length_ = blocks;
     spans_[serving->start_ + blocks - 1] = serving.get();
   }
 
   // |serving| is no longer in the free list, remove its length from
   // |num_free_blocks_|.
   DCHECK_GE(num_free_blocks_, serving->length_);
   num_free_blocks_ -= serving->length_;
 
-  return serving.Pass();
+  return serving;
 }
 
 void DiscardableSharedMemoryHeap::RegisterSpan(Span* span) {
   spans_[span->start_] = span;
   if (span->length_ > 1)
     spans_[span->start_ + span->length_ - 1] = span;
 }
 
 void DiscardableSharedMemoryHeap::UnregisterSpan(Span* span) {
   DCHECK(spans_.find(span->start_) != spans_.end());
@@ skipping 150 matching lines @@
   ScopedVector<ScopedMemorySegment>::const_iterator it =
       std::find_if(memory_segments_.begin(), memory_segments_.end(),
                    [span](const ScopedMemorySegment* segment) {
                      return segment->ContainsSpan(span);
                    });
   DCHECK(it != memory_segments_.end());
   return (*it)->CreateMemoryAllocatorDump(span, block_size_, name, pmd);
 }
 
 }  // namespace content