Remove stl_util's STLDeleteContainerPairSecondPointers.

content/browser/renderer_host/media/video_capture_host_unittest.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 "content/browser/renderer_host/media/video_capture_host.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/video_capture_messages.h"
 #include "content/public/common/content_switches.h"
@@ skipping 127 matching lines @@
     while (handle) {
       this->OnRendererFinishedWithBuffer(device_id, handle, gpu::SyncToken(),
                                          -1.0);
       handle = GetReceivedDib();
     }
   }
 
   int GetReceivedDib() {
     if (filled_dib_.empty())
       return 0;
-    std::map<int, base::SharedMemory*>::iterator it = filled_dib_.begin();
+    auto it = filled_dib_.begin();
     int h = it->first;
-    delete it->second;
     filled_dib_.erase(it);
 
     return h;
   }
 
  private:
   ~MockVideoCaptureHost() override {
-    base::STLDeleteContainerPairSecondPointers(filled_dib_.begin(),
-                                               filled_dib_.end());
   }
 
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   bool Send(IPC::Message* message) override {
     CHECK(message);
 
     // In this method we dispatch the messages to the according handlers as if
     // we are the renderer.
@@ skipping 10 matching lines @@
     delete message;
     return true;
   }
 
   // These handler methods do minimal things and delegate to the mock methods.
   void OnNewBufferCreatedDispatch(int device_id,
                                   base::SharedMemoryHandle handle,
                                   uint32_t length,
                                   int buffer_id) {
     OnNewBufferCreated(device_id, handle, length, buffer_id);
-    base::SharedMemory* dib = new base::SharedMemory(handle, false);
+    std::unique_ptr<base::SharedMemory> dib =
+        base::MakeUnique<base::SharedMemory>(handle, false);
     dib->Map(length);
-    filled_dib_[buffer_id] = dib;
+    filled_dib_[buffer_id] = std::move(dib);
   }
 
   void OnBufferFreedDispatch(int device_id, int buffer_id) {
     OnBufferFreed(device_id, buffer_id);
 
-    std::map<int, base::SharedMemory*>::iterator it =
-        filled_dib_.find(buffer_id);
+    auto it = filled_dib_.find(buffer_id);
     ASSERT_TRUE(it != filled_dib_.end());
-    delete it->second;
     filled_dib_.erase(it);
   }
 
   void OnBufferFilledDispatch(
       const VideoCaptureMsg_BufferReady_Params& params) {
-    base::SharedMemory* dib = filled_dib_[params.buffer_id];
+    base::SharedMemory* dib = filled_dib_[params.buffer_id].get();
     ASSERT_TRUE(dib != NULL);
     if (dump_video_) {
       if (dumper_.coded_size().IsEmpty())
         dumper_.StartDump(params.coded_size);
       ASSERT_TRUE(dumper_.coded_size() == params.coded_size)
           << "Dump format does not handle variable resolution.";
       dumper_.NewVideoFrame(dib->memory());
     }
 
     OnBufferFilled(params.device_id);
     if (return_buffers_) {
       VideoCaptureHost::OnRendererFinishedWithBuffer(
           params.device_id, params.buffer_id, gpu::SyncToken(), -1.0);
     }
   }
 
   void OnStateChangedDispatch(int device_id, VideoCaptureState state) {
     OnStateChanged(device_id, state);
   }
 
-  std::map<int, base::SharedMemory*> filled_dib_;
+  std::map<int, std::unique_ptr<base::SharedMemory>> filled_dib_;
   bool return_buffers_;
   bool dump_video_;
   media::VideoCaptureFormat format_;
   DumpVideo dumper_;
 };
 
 ACTION_P2(ExitMessageLoop, task_runner, quit_closure) {
   task_runner->PostTask(FROM_HERE, quit_closure);
 }
 
@@ skipping 281 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content