Remove use of stl_util in rtc.

content/renderer/media/gpu/rtc_video_decoder.cc

 // Copyright 2013 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/renderer/media/gpu/rtc_video_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
-#include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner_util.h"
 #include "content/renderer/media/webrtc/webrtc_video_frame_adapter.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/webrtc/base/bind.h"
 #include "third_party/webrtc/base/refcount.h"
 #include "third_party/webrtc/modules/video_coding/codecs/h264/include/h264.h"
@@ skipping 59 matching lines @@
       weak_factory_(this) {
   DCHECK(!factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 RTCVideoDecoder::~RTCVideoDecoder() {
   DVLOG(2) << "~RTCVideoDecoder";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DestroyVDA();
 
   // Delete all shared memories.
-  base::STLDeleteElements(&available_shm_segments_);
-  base::STLDeleteValues(&bitstream_buffers_in_decoder_);
-  base::STLDeleteContainerPairFirstPointers(decode_buffers_.begin(),
-                                            decode_buffers_.end());
-  decode_buffers_.clear();
   ClearPendingBuffers();
 }
 
 // static
 std::unique_ptr<RTCVideoDecoder> RTCVideoDecoder::Create(
     webrtc::VideoCodecType type,
     media::GpuVideoAcceleratorFactories* factories) {
   std::unique_ptr<RTCVideoDecoder> decoder;
 // See https://bugs.chromium.org/p/webrtc/issues/detail?id=5717.
 #if defined(OS_WIN)
@@ skipping 377 matching lines @@
     frame->metadata()->SetBoolean(media::VideoFrameMetadata::ALLOW_OVERLAY,
                                   true);
   }
   return frame;
 }
 
 void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32_t id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
-  std::map<int32_t, base::SharedMemory*>::iterator it =
-      bitstream_buffers_in_decoder_.find(id);
+  auto it = bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   {
     base::AutoLock auto_lock(lock_);
-    PutSHM_Locked(std::unique_ptr<base::SharedMemory>(it->second));
+    PutSHM_Locked(std::move(it->second));
   }
   bitstream_buffers_in_decoder_.erase(it);
 
   RequestBufferDecode();
 }
 
 void RTCVideoDecoder::NotifyFlushDone() {
   DVLOG(3) << "NotifyFlushDone";
   NOTREACHED() << "Unexpected flush done notification.";
 }
@@ skipping 38 matching lines @@
 
   while (CanMoreDecodeWorkBeDone()) {
     // Get a buffer and data from the queue.
     std::unique_ptr<base::SharedMemory> shm_buffer;
     BufferData buffer_data;
     {
       base::AutoLock auto_lock(lock_);
       // Do not request decode if VDA is resetting.
       if (decode_buffers_.empty() || state_ == RESETTING)
         return;
-      shm_buffer.reset(decode_buffers_.front().first);
+      shm_buffer = std::move(decode_buffers_.front().first);
       buffer_data = decode_buffers_.front().second;
       decode_buffers_.pop_front();
       // Drop the buffers before Release is called.
       if (!IsBufferAfterReset(buffer_data.bitstream_buffer_id,
                               reset_bitstream_buffer_id_)) {
         PutSHM_Locked(std::move(shm_buffer));
         continue;
       }
     }
 
     // Create a BitstreamBuffer and send to VDA to decode.
     media::BitstreamBuffer bitstream_buffer(
         buffer_data.bitstream_buffer_id, shm_buffer->handle(), buffer_data.size,
         0, base::TimeDelta::FromInternalValue(buffer_data.timestamp));
-    const bool inserted =
-        bitstream_buffers_in_decoder_.insert(
-            std::make_pair(bitstream_buffer.id(), shm_buffer.release())).second;
+    const bool inserted = bitstream_buffers_in_decoder_
+                              .insert(std::make_pair(bitstream_buffer.id(),
+                                                     std::move(shm_buffer)))
+                              .second;
     DCHECK(inserted) << "bitstream_buffer_id " << bitstream_buffer.id()
                      << " existed already in bitstream_buffers_in_decoder_";
     RecordBufferData(buffer_data);
     vda_->Decode(bitstream_buffer);
   }
 }
 
 bool RTCVideoDecoder::CanMoreDecodeWorkBeDone() {
   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
@@ skipping 12 matching lines @@
   if (id_reset == ID_INVALID)
     return id_buffer == 0;
   return id_buffer == ((id_reset + 1) & ID_LAST);
 }
 
 void RTCVideoDecoder::SaveToDecodeBuffers_Locked(
     const webrtc::EncodedImage& input_image,
     std::unique_ptr<base::SharedMemory> shm_buffer,
     const BufferData& buffer_data) {
   memcpy(shm_buffer->memory(), input_image._buffer, input_image._length);
-  std::pair<base::SharedMemory*, BufferData> buffer_pair =
-      std::make_pair(shm_buffer.release(), buffer_data);
 
   // Store the buffer and the metadata to the queue.
-  decode_buffers_.push_back(buffer_pair);
+  decode_buffers_.emplace_back(std::move(shm_buffer), buffer_data);
 }
 
 bool RTCVideoDecoder::SaveToPendingBuffers_Locked(
     const webrtc::EncodedImage& input_image,
     const BufferData& buffer_data) {
   DVLOG(2) << "SaveToPendingBuffers_Locked"
            << ". pending_buffers size=" << pending_buffers_.size()
            << ". decode_buffers_ size=" << decode_buffers_.size()
            << ". available_shm size=" << available_shm_segments_.size();
   // Queued too many buffers. Something goes wrong.
@@ skipping 148 matching lines @@
 void RTCVideoDecoder::DestroyVDA() {
   DVLOG(2) << "DestroyVDA";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (vda_)
     vda_.release()->Destroy();
   DestroyTextures();
 
   base::AutoLock auto_lock(lock_);
 
   // Put the buffers back in case we restart the decoder.
-  for (const auto& buffer : bitstream_buffers_in_decoder_)
-    PutSHM_Locked(std::unique_ptr<base::SharedMemory>(buffer.second));
+  for (auto& buffer : bitstream_buffers_in_decoder_)
+    PutSHM_Locked(std::move(buffer.second));
   bitstream_buffers_in_decoder_.clear();
 
   state_ = UNINITIALIZED;
 }
 
 std::unique_ptr<base::SharedMemory> RTCVideoDecoder::GetSHM_Locked(
     size_t min_size) {
   // Reuse a SHM if possible.
   if (!available_shm_segments_.empty() &&
       available_shm_segments_.back()->mapped_size() >= min_size) {
-    std::unique_ptr<base::SharedMemory> buffer(available_shm_segments_.back());
+    std::unique_ptr<base::SharedMemory> buffer =
+        std::move(available_shm_segments_.back());
     available_shm_segments_.pop_back();
     return buffer;
   }
 
   if (available_shm_segments_.size() != num_shm_buffers_) {
     // Either available_shm_segments_ is empty (and we already have some SHM
     // buffers allocated), or the size of available segments is not large
     // enough. In the former case we need to wait for buffers to be returned,
     // in the latter we need to wait for all buffers to be returned to drop
     // them and reallocate with a new size.
     return NULL;
   }
 
   if (num_shm_buffers_ != 0) {
-    base::STLDeleteElements(&available_shm_segments_);
+    available_shm_segments_.clear();
     num_shm_buffers_ = 0;
   }
 
   // Create twice as large buffers as required, to avoid frequent reallocation.
   factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoDecoder::CreateSHM, weak_factory_.GetWeakPtr(),
                  kNumSharedMemorySegments, min_size * 2));
 
   // We'll be called again after the shared memory is created.
   return NULL;
 }
 
 void RTCVideoDecoder::PutSHM_Locked(
     std::unique_ptr<base::SharedMemory> shm_buffer) {
   lock_.AssertAcquired();
-  available_shm_segments_.push_back(shm_buffer.release());
+  available_shm_segments_.push_back(std::move(shm_buffer));
 }
 
 void RTCVideoDecoder::CreateSHM(size_t count, size_t size) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DVLOG(2) << "CreateSHM. count=" << count << ", size=" << size;
 
   for (size_t i = 0; i < count; i++) {
     std::unique_ptr<base::SharedMemory> shm =
         factories_->CreateSharedMemory(size);
     if (!shm) {
@@ skipping 50 matching lines @@
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
 }  // namespace content