Remove stl_util's deletion function use from crypto/.

crypto/nss_util.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 "crypto/nss_util.h"
 
 #include <nss.h>
 #include <pk11pub.h>
 #include <plarena.h>
 #include <prerror.h>
@@ skipping 24 matching lines @@
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/cpu.h"
 #include "base/debug/alias.h"
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
-#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "crypto/nss_crypto_module_delegate.h"
 
 namespace crypto {
 
@@ skipping 428 matching lines @@
       // This user already exists in our mapping.
       DVLOG(2) << username_hash << " already initialized.";
       return false;
     }
 
     DVLOG(2) << "Opening NSS DB " << path.value();
     std::string db_name = base::StringPrintf(
         "%s %s", kUserNSSDatabaseName, username_hash.c_str());
     ScopedPK11Slot public_slot(OpenPersistentNSSDBForPath(db_name, path));
     chromeos_user_map_[username_hash] =
-        new ChromeOSUserData(std::move(public_slot));
+        base::MakeUnique<ChromeOSUserData>(std::move(public_slot));
     return true;
   }
 
   bool ShouldInitializeTPMForChromeOSUser(const std::string& username_hash) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(chromeos_user_map_.find(username_hash) != chromeos_user_map_.end());
 
     return !chromeos_user_map_[username_hash]
                 ->private_slot_initialization_started();
   }
@@ skipping 86 matching lines @@
       return ScopedPK11Slot();
     }
 
     DCHECK(chromeos_user_map_.find(username_hash) != chromeos_user_map_.end());
 
     return chromeos_user_map_[username_hash]->GetPrivateSlot(callback);
   }
 
   void CloseChromeOSUserForTesting(const std::string& username_hash) {
     DCHECK(thread_checker_.CalledOnValidThread());
-    ChromeOSUserMap::iterator i = chromeos_user_map_.find(username_hash);
+    auto i = chromeos_user_map_.find(username_hash);
     DCHECK(i != chromeos_user_map_.end());
-    delete i->second;
     chromeos_user_map_.erase(i);
   }
 
   void SetSystemKeySlotForTesting(ScopedPK11Slot slot) {
     // Ensure that a previous value of test_system_slot_ is not overwritten.
     // Unsetting, i.e. setting a nullptr, however is allowed.
     DCHECK(!slot || !test_system_slot_);
     test_system_slot_ = std::move(slot);
     if (test_system_slot_) {
       tpm_slot_.reset(PK11_ReferenceSlot(test_system_slot_.get()));
@@ skipping 128 matching lines @@
     // NSS 3.14.)
     NSS_SetAlgorithmPolicy(SEC_OID_MD5, 0, NSS_USE_ALG_IN_CERT_SIGNATURE);
     NSS_SetAlgorithmPolicy(SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION,
                            0, NSS_USE_ALG_IN_CERT_SIGNATURE);
   }
 
   // NOTE(willchan): We don't actually execute this code since we leak NSS to
   // prevent non-joinable threads from using NSS after it's already been shut
   // down.
   ~NSSInitSingleton() {
-#if defined(OS_CHROMEOS)
-    base::STLDeleteValues(&chromeos_user_map_);

[davidben, 2016/11/03 02:13:48]

rsleevi: Is there a requirement to clear chromeos_user_map_ before root_ and
chaps_module_ are unloaded? I'm not sure. From InitializeTPMForChromeOSUser and
OnInitializedTPMForChromeOSUser, it looks like the ChromeOSUserData's private
slot might reference chaps_module_?

[Avi (use Gerrit), 2016/11/03 02:17:57]

I can totally put

chromeos_user_map_.clear();

back in if we're not sure.

[davidben, 2016/11/03 02:20:29]

Yeah. I figure we may as well see if Ryan knows definitively and, if it's known
to be required, we can put a comment to this effect.

[Ryan Sleevi, 2016/11/03 03:06:41]

We'll never hit this, and with the move to make Singletons leaky by default,
really, we should just delete this code (c.f. lines 750-752 - the fact that
willchan's name is on it says a lot)

That said, yes, we need to free those modules before we get to either 763 or
769, so the .clear() is the semantically correct (but entirely unexecuted)
solution.

-#endif
     tpm_slot_.reset();
     if (root_) {
       SECMOD_UnloadUserModule(root_);
       SECMOD_DestroyModule(root_);
       root_ = nullptr;
     }
     if (chaps_module_) {
       SECMOD_UnloadUserModule(chaps_module_);
       SECMOD_DestroyModule(chaps_module_);
       chaps_module_ = nullptr;
@@ skipping 48 matching lines @@
   }
 
   bool tpm_token_enabled_for_nss_;
   bool initializing_tpm_token_;
   typedef std::vector<base::Closure> TPMReadyCallbackList;
   TPMReadyCallbackList tpm_ready_callback_list_;
   SECMODModule* chaps_module_;
   crypto::ScopedPK11Slot tpm_slot_;
   SECMODModule* root_;
 #if defined(OS_CHROMEOS)
-  typedef std::map<std::string, ChromeOSUserData*> ChromeOSUserMap;
-  ChromeOSUserMap chromeos_user_map_;
+  std::map<std::string, std::unique_ptr<ChromeOSUserData>> chromeos_user_map_;
   ScopedPK11Slot test_system_slot_;
 #endif
   // TODO(davidben): When https://bugzilla.mozilla.org/show_bug.cgi?id=564011
   // is fixed, we will no longer need the lock.
   base::Lock write_lock_;
 
   base::ThreadChecker thread_checker_;
 };
 
 base::LazyInstance<NSSInitSingleton>::Leaky
@@ skipping 146 matching lines @@
   return time.ToInternalValue() - base::Time::UnixEpoch().ToInternalValue();
 }
 
 #if !defined(OS_CHROMEOS)
 PK11SlotInfo* GetPersistentNSSKeySlot() {
   return g_nss_singleton.Get().GetPersistentNSSKeySlot();
 }
 #endif
 
 }  // namespace crypto