Remove stl_util's deletion functions from media/.

media/filters/vpx_video_decoder.cc

 // Copyright (c) 2012 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 "media/filters/vpx_video_decoder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 183 matching lines @@
   ~MemoryPool() override;
 
   // Gets the next available frame buffer for use by libvpx.
   VP9FrameBuffer* GetFreeFrameBuffer(size_t min_size);
 
   // Method that gets called when a VideoFrame that references this pool gets
   // destroyed.
   void OnVideoFrameDestroyed(VP9FrameBuffer* frame_buffer);
 
   // Frame buffers to be used by libvpx for VP9 Decoding.
-  std::vector<VP9FrameBuffer*> frame_buffers_;
+  std::vector<std::unique_ptr<VP9FrameBuffer>> frame_buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryPool);
 };
 
 VpxVideoDecoder::MemoryPool::MemoryPool() {
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "VpxVideoDecoder", base::ThreadTaskRunnerHandle::Get());
 }
 
 VpxVideoDecoder::MemoryPool::~MemoryPool() {
-  base::STLDeleteElements(&frame_buffers_);
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 VpxVideoDecoder::MemoryPool::VP9FrameBuffer*
 VpxVideoDecoder::MemoryPool::GetFreeFrameBuffer(size_t min_size) {
   // Check if a free frame buffer exists.
   size_t i = 0;
   for (; i < frame_buffers_.size(); ++i) {
     if (frame_buffers_[i]->ref_cnt == 0)
       break;
   }
 
   if (i == frame_buffers_.size()) {
     // Create a new frame buffer.
-    frame_buffers_.push_back(new VP9FrameBuffer());
+    frame_buffers_.push_back(base::MakeUnique<VP9FrameBuffer>());
   }
 
   // Resize the frame buffer if necessary.
   if (frame_buffers_[i]->data.size() < min_size)
     frame_buffers_[i]->data.resize(min_size);
-  return frame_buffers_[i];
+  return frame_buffers_[i].get();
 }
 
 int32_t VpxVideoDecoder::MemoryPool::GetVP9FrameBuffer(
     void* user_priv,
     size_t min_size,
     vpx_codec_frame_buffer* fb) {
   DCHECK(user_priv);
   DCHECK(fb);
 
   VpxVideoDecoder::MemoryPool* memory_pool =
@@ skipping 40 matching lines @@
   base::trace_event::MemoryAllocatorDump* memory_dump =
       pmd->CreateAllocatorDump("media/vpx/memory_pool");
   base::trace_event::MemoryAllocatorDump* used_memory_dump =
       pmd->CreateAllocatorDump("media/vpx/memory_pool/used");
 
   pmd->AddSuballocation(memory_dump->guid(),
                         base::trace_event::MemoryDumpManager::GetInstance()
                             ->system_allocator_pool_name());
   size_t bytes_used = 0;
   size_t bytes_reserved = 0;
-  for (const VP9FrameBuffer* frame_buffer : frame_buffers_) {
+  for (const auto& frame_buffer : frame_buffers_) {
     if (frame_buffer->ref_cnt)
       bytes_used += frame_buffer->data.size();
     bytes_reserved += frame_buffer->data.size();
   }
 
   memory_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                          base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                          bytes_reserved);
   used_memory_dump->AddScalar(
       base::trace_event::MemoryAllocatorDump::kNameSize,
@@ skipping 495 matching lines @@
       (*video_frame)->visible_data(VideoFrame::kUPlane),
       (*video_frame)->stride(VideoFrame::kUPlane),
       (*video_frame)->visible_data(VideoFrame::kVPlane),
       (*video_frame)->stride(VideoFrame::kVPlane), coded_size.width(),
       coded_size.height());
 
   return true;
 }
 
 }  // namespace media