Remove some uses of stl_util's STLDeleteContainerPointers.

content/browser/renderer_host/media/video_capture_controller.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_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
-#include "base/stl_util.h"
 #include "build/build_config.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/media/video_capture_device_client.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/video_frame.h"
 
@@ skipping 156 matching lines @@
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
   // Do nothing if this client has called AddClient before.
   if (FindClient(id, event_handler, controller_clients_))
     return;
 
-  ControllerClient* client = new ControllerClient(
+  std::unique_ptr<ControllerClient> client = base::MakeUnique<ControllerClient>(
       id, event_handler, render_process, session_id, params);
   // If we already have gotten frame_info from the device, repeat it to the new
   // client.
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
-    controller_clients_.push_back(client);
+    controller_clients_.push_back(std::move(client));
     return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::RemoveClient, id " << id;
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
   if (!client)
     return kInvalidMediaCaptureSessionId;
 
   // Take back all buffers held by the |client|.
   for (const auto& buffer : client->active_buffers)
     buffer_pool_->RelinquishConsumerHold(buffer.first, 1);
   client->active_buffers.clear();
 
   int session_id = client->session_id;
-  controller_clients_.remove(client);
-  delete client;
+  controller_clients_.remove_if(
+      [client](const std::unique_ptr<ControllerClient>& ptr) {
+        return ptr.get() == client;
+      });
 
   return session_id;
 }
 
 void VideoCaptureController::PauseClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::PauseClient, id " << id;
 
@@ skipping 25 matching lines @@
   return true;
 }
 
 int VideoCaptureController::GetClientCount() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return controller_clients_.size();
 }
 
 bool VideoCaptureController::HasActiveClient() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  for (ControllerClient* client : controller_clients_) {
+  for (const auto& client : controller_clients_) {
     if (!client->paused)
       return true;
   }
   return false;
 }
 
 bool VideoCaptureController::HasPausedClient() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  for (ControllerClient* client : controller_clients_) {
+  for (const auto& client : controller_clients_) {
     if (client->paused)
       return true;
   }
   return false;
 }
 
 void VideoCaptureController::StopSession(int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::StopSession, id " << session_id;
 
@@ skipping 55 matching lines @@
                             base::Bind(&ReturnVideoFrame, frame, sync_token));
 }
 
 const media::VideoCaptureFormat&
 VideoCaptureController::GetVideoCaptureFormat() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return video_capture_format_;
 }
 
 VideoCaptureController::~VideoCaptureController() {
-  base::STLDeleteContainerPointers(controller_clients_.begin(),
-                                   controller_clients_.end());
 }
 
 void VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread(
     std::unique_ptr<media::VideoCaptureDevice::Client::Buffer> buffer,
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const int buffer_id = buffer->id();
   DCHECK_NE(buffer_id, VideoCaptureBufferPool::kInvalidId);
 
   int count = 0;
@@ skipping 14 matching lines @@
     // Sanity-checks to confirm |frame| is actually being backed by |buffer|.
     DCHECK(frame->storage_type() == media::VideoFrame::STORAGE_SHMEM ||
            (frame->storage_type() ==
                 media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS));
     DCHECK(frame->data(media::VideoFrame::kYPlane) >= buffer->data(0) &&
            (frame->data(media::VideoFrame::kYPlane) <
             (reinterpret_cast<const uint8_t*>(buffer->data(0)) +
              buffer->mapped_size())))
         << "VideoFrame does not appear to be backed by Buffer";
 
-    for (auto* client : controller_clients_) {
+    for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
 
       // On the first use of a buffer on a client, share the memory handles.
       const bool is_new_buffer = client->known_buffers.insert(buffer_id).second;
       if (is_new_buffer)
-        DoNewBufferOnIOThread(client, buffer.get(), frame);
+        DoNewBufferOnIOThread(client.get(), buffer.get(), frame);
 
       client->event_handler->OnBufferReady(client->controller_id, buffer_id,
                                            frame);
       const bool inserted =
           client->active_buffers.insert(std::make_pair(buffer_id, frame))
               .second;
       DCHECK(inserted) << "Unexpected duplicate buffer: " << buffer_id;
       count++;
     }
   }
@@ skipping 15 matching lines @@
     has_received_frames_ = true;
   }
 
   buffer_pool_->HoldForConsumers(buffer_id, count);
 }
 
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_ERROR;
 
-  for (const auto* client : controller_clients_) {
+  for (const auto& client : controller_clients_) {
     if (client->session_closed)
        continue;
     client->event_handler->OnError(client->controller_id);
   }
 }
 
 void VideoCaptureController::DoLogOnIOThread(const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaStreamManager::SendMessageToNativeLog("Video capture: " + message);
 }
 
 void VideoCaptureController::DoBufferDestroyedOnIOThread(
     int buffer_id_to_drop) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  for (auto* client : controller_clients_) {
+  for (const auto& client : controller_clients_) {
     if (client->session_closed)
       continue;
 
     if (client->known_buffers.erase(buffer_id_to_drop)) {
       client->event_handler->OnBufferDestroyed(client->controller_id,
                                                buffer_id_to_drop);
     }
   }
 }
 
@@ skipping 30 matching lines @@
     default:
       NOTREACHED();
       break;
   }
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
-  for (auto* client : clients) {
+  for (const auto& client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
-      return client;
+      return client.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     int session_id,
     const ControllerClients& clients) {
-  for (auto* client : clients) {
+  for (const auto& client : clients) {
     if (client->session_id == session_id)
-      return client;
+      return client.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace content