Remove stl_util's deletion functions from media/.

media/cdm/aes_decryptor.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 "media/cdm/aes_decryptor.h"
 
 #include <stddef.h>
 #include <list>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/limits.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/cdm/json_web_key.h"
 
 #if defined(USE_PROPRIETARY_CODECS)
 #include "media/cdm/cenc_utils.h"
 #endif
 
 namespace media {
 
 // Keeps track of the session IDs and DecryptionKeys. The keys are ordered by
 // insertion time (last insertion is first). It takes ownership of the
 // DecryptionKeys.
 class AesDecryptor::SessionIdDecryptionKeyMap {
   // Use a std::list to actually hold the data. Insertion is always done
   // at the front, so the "latest" decryption key is always the first one
   // in the list.
-  typedef std::list<std::pair<std::string, DecryptionKey*> > KeyList;
+  using KeyList =
+      std::list<std::pair<std::string, std::unique_ptr<DecryptionKey>>>;
 
  public:
   SessionIdDecryptionKeyMap() {}
-  ~SessionIdDecryptionKeyMap() { base::STLDeleteValues(&key_list_); }
+  ~SessionIdDecryptionKeyMap() {}
 
   // Replaces value if |session_id| is already present, or adds it if not.
   // This |decryption_key| becomes the latest until another insertion or
   // |session_id| is erased.
   void Insert(const std::string& session_id,
               std::unique_ptr<DecryptionKey> decryption_key);
 
   // Deletes the entry for |session_id| if present.
   void Erase(const std::string& session_id);
 
   // Returns whether the list is empty
   bool Empty() const { return key_list_.empty(); }
 
   // Returns the last inserted DecryptionKey.
   DecryptionKey* LatestDecryptionKey() {
     DCHECK(!key_list_.empty());
-    return key_list_.begin()->second;
+    return key_list_.begin()->second.get();
   }
 
   bool Contains(const std::string& session_id) {
     return Find(session_id) != key_list_.end();
   }
 
  private:
   // Searches the list for an element with |session_id|.
   KeyList::iterator Find(const std::string& session_id);
 
   // Deletes the entry pointed to by |position|.
   void Erase(KeyList::iterator position);
 
   KeyList key_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionIdDecryptionKeyMap);
 };
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Insert(
     const std::string& session_id,
     std::unique_ptr<DecryptionKey> decryption_key) {
   KeyList::iterator it = Find(session_id);
   if (it != key_list_.end())
     Erase(it);
-  DecryptionKey* raw_ptr = decryption_key.release();
-  key_list_.push_front(std::make_pair(session_id, raw_ptr));
+  key_list_.push_front(std::make_pair(session_id, std::move(decryption_key)));
 }
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Erase(
     const std::string& session_id) {
   KeyList::iterator it = Find(session_id);
   if (it == key_list_.end())
     return;
   Erase(it);
 }
 
 AesDecryptor::SessionIdDecryptionKeyMap::KeyList::iterator
 AesDecryptor::SessionIdDecryptionKeyMap::Find(const std::string& session_id) {
   for (KeyList::iterator it = key_list_.begin(); it != key_list_.end(); ++it) {
     if (it->first == session_id)
       return it;
   }
   return key_list_.end();
 }
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Erase(
     KeyList::iterator position) {
   DCHECK(position->second);
-  delete position->second;
   key_list_.erase(position);
 }
 
 uint32_t AesDecryptor::next_session_id_ = 1;
 
 enum ClearBytesBufferSel {
   kSrcContainsClearBytes,
   kDstContainsClearBytes
 };
 
@@ skipping 477 matching lines @@
 bool AesDecryptor::DecryptionKey::Init() {
   CHECK(!secret_.empty());
   decryption_key_ =
       crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, secret_);
   if (!decryption_key_)
     return false;
   return true;
 }
 
 }  // namespace media