Revert "Remove scopedvector in //components/discardable_memory/"

components/discardable_memory/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 "components/discardable_memory/common/discardable_shared_memory_heap.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/format_macros.h"
@@ skipping 113 matching lines @@
       new Span(shared_memory.get(),
                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(base::MakeUnique<ScopedMemorySegment>(
+  memory_segments_.push_back(new ScopedMemorySegment(
       this, std::move(shared_memory), size, id, deleted_callback));
 
   return span;
 }
 
 void DiscardableSharedMemoryHeap::MergeIntoFreeLists(
     std::unique_ptr<Span> span) {
   DCHECK(span->shared_memory_);
 
   // First add length of |span| to |num_free_blocks_|.
@@ skipping 74 matching lines @@
       return Carve(span, blocks);
   }
 
   return nullptr;
 }
 
 void DiscardableSharedMemoryHeap::ReleaseFreeMemory() {
   // Erase all free segments after rearranging the segments in such a way
   // that used segments precede all free segments.
   memory_segments_.erase(
-      std::partition(memory_segments_.begin(), memory_segments_.end(),
-                     [](const std::unique_ptr<ScopedMemorySegment>& segment) {
-                       return segment->IsUsed();
-                     }),
+      std::partition(
+          memory_segments_.begin(), memory_segments_.end(),
+          [](const ScopedMemorySegment* segment) { return segment->IsUsed(); }),
       memory_segments_.end());
 }
 
 void DiscardableSharedMemoryHeap::ReleasePurgedMemory() {
   // Erase all purged segments after rearranging the segments in such a way
   // that resident segments precede all purged segments.
   memory_segments_.erase(
       std::partition(memory_segments_.begin(), memory_segments_.end(),
-                     [](const std::unique_ptr<ScopedMemorySegment>& segment) {
+                     [](const ScopedMemorySegment* segment) {
                        return segment->IsResident();
                      }),
       memory_segments_.end());
 }
 
 size_t DiscardableSharedMemoryHeap::GetSize() const {
   return num_blocks_ * block_size_;
 }
 
 size_t DiscardableSharedMemoryHeap::GetSizeOfFreeLists() const {
   return num_free_blocks_ * block_size_;
 }
 
 bool DiscardableSharedMemoryHeap::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd) {
   std::for_each(memory_segments_.begin(), memory_segments_.end(),
-                [pmd](const std::unique_ptr<ScopedMemorySegment>& segment) {
+                [pmd](const ScopedMemorySegment* segment) {
                   segment->OnMemoryDump(pmd);
                 });
   return true;
 }
 
 void DiscardableSharedMemoryHeap::InsertIntoFreeList(
     std::unique_ptr<DiscardableSharedMemoryHeap::Span> span) {
   DCHECK(!IsInFreeList(span.get()));
   size_t index = std::min(span->length_, arraysize(free_spans_)) - 1;
   free_spans_[index].Append(span.release());
@@ skipping 191 matching lines @@
     const char* name,
     base::trace_event::ProcessMemoryDump* pmd) const {
   if (!span->shared_memory()) {
     base::trace_event::MemoryAllocatorDump* dump =
         pmd->CreateAllocatorDump(name);
     dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                     base::trace_event::MemoryAllocatorDump::kUnitsBytes, 0u);
     return dump;
   }
 
-  auto it =
+  ScopedVector<ScopedMemorySegment>::const_iterator it =
       std::find_if(memory_segments_.begin(), memory_segments_.end(),
-                   [span](const std::unique_ptr<ScopedMemorySegment>& segment) {
+                   [span](const ScopedMemorySegment* segment) {
                      return segment->ContainsSpan(span);
                    });
   DCHECK(it != memory_segments_.end());
   return (*it)->CreateMemoryAllocatorDump(span, block_size_, name, pmd);
 }
 
 }  // namespace discardable_memory