Remove use of stl_util in rtc.

content/renderer/media/gpu/rtc_video_decoder.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_
 #define CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <utility>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "media/base/bitstream_buffer.h"
@@ skipping 207 matching lines @@
   // The texture target used for decoded pictures.
   uint32_t decoder_texture_target_;
 
   // The format of the decoded pictures.
   media::VideoPixelFormat pixel_format_;
 
   // Metadata of the buffers that have been sent for decode.
   std::list<BufferData> input_buffer_data_;
 
   // A map from bitstream buffer IDs to bitstream buffers that are being
-  // processed by VDA. The map owns SHM buffers.
-  std::map<int32_t, base::SharedMemory*> bitstream_buffers_in_decoder_;
+  // processed by VDA.
+  std::map<int32_t, std::unique_ptr<base::SharedMemory>>
+      bitstream_buffers_in_decoder_;
 
   // A map from picture buffer IDs to texture-backed picture buffers.
   std::map<int32_t, media::PictureBuffer> assigned_picture_buffers_;
 
   // PictureBuffers given to us by VDA via PictureReady, which we sent forward
   // as VideoFrames to be rendered via read_cb_, and which will be returned
   // to us via ReusePictureBuffer.
   typedef std::map<int32_t /* picture_buffer_id */, uint32_t /* texture_id */>
       PictureBufferTextureMap;
   PictureBufferTextureMap picture_buffers_at_display_;
@@ skipping 11 matching lines @@
   State state_;
 
   // Guarded by |lock_|.
   webrtc::DecodedImageCallback* decode_complete_callback_;
 
   // Total number of allocated SHM buffers. Guarded by |lock_|.
   size_t num_shm_buffers_;
 
   // Shared-memory buffer pool.  Since allocating SHM segments requires a
   // round-trip to the browser process, we keep allocation out of the
-  // steady-state of the decoder. The vector owns SHM buffers. Guarded by
-  // |lock_|.
-  std::vector<base::SharedMemory*> available_shm_segments_;
+  // steady-state of the decoder. Guarded by |lock_|.
+  std::vector<std::unique_ptr<base::SharedMemory>> available_shm_segments_;
 
   // A queue storing WebRTC encoding images (and their metadata) that are
   // waiting for the shared memory. Guarded by |lock_|.
   std::deque<std::pair<webrtc::EncodedImage, BufferData>> pending_buffers_;
 
   // A queue storing buffers (and their metadata) that will be sent to VDA for
-  // decode. The queue owns SHM buffers. Guarded by |lock_|.
-  std::deque<std::pair<base::SharedMemory*, BufferData>> decode_buffers_;
+  // decode. Guarded by |lock_|.
+  std::deque<std::pair<std::unique_ptr<base::SharedMemory>, BufferData>>
+      decode_buffers_;
 
   // The id that will be given to the next bitstream buffer. Guarded by |lock_|.
   int32_t next_bitstream_buffer_id_;
 
   // A buffer that has an id less than this should be dropped because Reset or
   // Release has been called. Guarded by |lock_|.
   int32_t reset_bitstream_buffer_id_;
 
   // Minimum and maximum supported resolutions for the current profile/VDA.
   gfx::Size min_resolution_;
   gfx::Size max_resolution_;
 
   // Must be destroyed, or invalidated, on the media thread.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_GPU_RTC_VIDEO_DECODER_H_