Remove stl_util's STLDeleteContainerPairSecondPointers from storage/.

storage/browser/fileapi/isolated_context.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 "storage/browser/fileapi/isolated_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "storage/browser/fileapi/file_system_url.h"
 
 namespace storage {
 
 namespace {
 
 base::FilePath::StringType GetRegisterNameForPath(const base::FilePath& path) {
@@ skipping 188 matching lines @@
 
 // static
 bool IsolatedContext::IsIsolatedType(FileSystemType type) {
   return type == kFileSystemTypeIsolated || type == kFileSystemTypeExternal;
 }
 
 std::string IsolatedContext::RegisterDraggedFileSystem(
     const FileInfoSet& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(
-      kFileSystemTypeDragged, files.fileset());
+  instance_map_[filesystem_id] =
+      base::MakeUnique<Instance>(kFileSystemTypeDragged, files.fileset());
   return filesystem_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForPath(
     FileSystemType type,
     const std::string& filesystem_id,
     const base::FilePath& path_in,
     std::string* register_name) {
   base::FilePath path(path_in.NormalizePathSeparators());
   if (path.ReferencesParent() || !path.IsAbsolute())
     return std::string();
   std::string name;
   if (register_name && !register_name->empty()) {
     name = *register_name;
   } else {
     name = base::FilePath(GetRegisterNameForPath(path)).AsUTF8Unsafe();
     if (register_name)
       register_name->assign(name);
   }
 
   base::AutoLock locker(lock_);
   std::string new_id = GetNewFileSystemId();
-  instance_map_[new_id] = new Instance(type, filesystem_id,
-                                       MountPointInfo(name, path),
-                                       Instance::PLATFORM_PATH);
+  instance_map_[new_id] = base::MakeUnique<Instance>(
+      type, filesystem_id, MountPointInfo(name, path), Instance::PLATFORM_PATH);
   path_to_id_map_[path].insert(new_id);
   return new_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForVirtualPath(
     FileSystemType type,
     const std::string& register_name,
     const base::FilePath& cracked_path_prefix) {
   base::AutoLock locker(lock_);
   base::FilePath path(cracked_path_prefix.NormalizePathSeparators());
   if (path.ReferencesParent())
     return std::string();
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(
+  instance_map_[filesystem_id] = base::MakeUnique<Instance>(
       type,
       std::string(),  // filesystem_id
       MountPointInfo(register_name, cracked_path_prefix),
       Instance::VIRTUAL_PATH);
   path_to_id_map_[path].insert(filesystem_id);
   return filesystem_id;
 }
 
 bool IsolatedContext::HandlesFileSystemMountType(FileSystemType type) const {
   return type == kFileSystemTypeIsolated;
 }
 
 bool IsolatedContext::RevokeFileSystem(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   return UnregisterFileSystem(filesystem_id);
 }
 
 bool IsolatedContext::GetRegisteredPath(
     const std::string& filesystem_id, base::FilePath* path) const {
   DCHECK(path);
   base::AutoLock locker(lock_);
-  IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
     return false;
   *path = found->second->file_info().path;
   return true;
 }
 
 bool IsolatedContext::CrackVirtualPath(
     const base::FilePath& virtual_path,
     std::string* id_or_name,
     FileSystemType* type,
@@ skipping 17 matching lines @@
     return false;
   std::vector<base::FilePath::StringType>::iterator component_iter =
       components.begin();
   std::string fsid = base::FilePath(*component_iter++).MaybeAsASCII();
   if (fsid.empty())
     return false;
 
   base::FilePath cracked_path;
   {
     base::AutoLock locker(lock_);
-    IDToInstance::const_iterator found_instance = instance_map_.find(fsid);
+    auto found_instance = instance_map_.find(fsid);
     if (found_instance == instance_map_.end())
       return false;
     *id_or_name = fsid;
-    const Instance* instance = found_instance->second;
+    const Instance* instance = found_instance->second.get();
     if (type)
       *type = instance->type();
     if (cracked_id)
       *cracked_id = instance->filesystem_id();
 
     if (component_iter == components.end()) {
       // The virtual root case.
       path->clear();
       return true;
     }
@@ skipping 20 matching lines @@
 FileSystemURL IsolatedContext::CreateCrackedFileSystemURL(
     const GURL& origin,
     FileSystemType type,
     const base::FilePath& path) const {
   return CrackFileSystemURL(FileSystemURL(origin, type, path));
 }
 
 void IsolatedContext::RevokeFileSystemByPath(const base::FilePath& path_in) {
   base::AutoLock locker(lock_);
   base::FilePath path(path_in.NormalizePathSeparators());
-  PathToID::iterator ids_iter = path_to_id_map_.find(path);
+  auto ids_iter = path_to_id_map_.find(path);
   if (ids_iter == path_to_id_map_.end())
     return;
   std::set<std::string>& ids = ids_iter->second;
-  for (std::set<std::string>::iterator iter = ids.begin();
-       iter != ids.end(); ++iter) {
-    IDToInstance::iterator found = instance_map_.find(*iter);
-    if (found != instance_map_.end()) {
-      delete found->second;
-      instance_map_.erase(found);
-    }
-  }
+  for (auto iter = ids.begin(); iter != ids.end(); ++iter)
+    instance_map_.erase(*iter);
   path_to_id_map_.erase(ids_iter);
 }
 
 void IsolatedContext::AddReference(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   DCHECK(instance_map_.find(filesystem_id) != instance_map_.end());
   instance_map_[filesystem_id]->AddRef();
 }
 
 void IsolatedContext::RemoveReference(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   // This could get called for non-existent filesystem if it has been
   // already deleted by RevokeFileSystemByPath.
-  IDToInstance::iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return;
-  Instance* instance = found->second;
+  Instance* instance = found->second.get();
   DCHECK_GT(instance->ref_counts(), 0);
   instance->RemoveRef();
   if (instance->ref_counts() == 0) {
     bool deleted = UnregisterFileSystem(filesystem_id);
     DCHECK(deleted);
   }
 }
 
 bool IsolatedContext::GetDraggedFileInfo(
     const std::string& filesystem_id,
     std::vector<MountPointInfo>* files) const {
   DCHECK(files);
   base::AutoLock locker(lock_);
-  IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() ||
       found->second->type() != kFileSystemTypeDragged)
     return false;
   files->assign(found->second->files().begin(),
                 found->second->files().end());
   return true;
 }
 
 base::FilePath IsolatedContext::CreateVirtualRootPath(
     const std::string& filesystem_id) const {
   return base::FilePath().AppendASCII(filesystem_id);
 }
 
-IsolatedContext::IsolatedContext() {
-}
+IsolatedContext::IsolatedContext() = default;
 
-IsolatedContext::~IsolatedContext() {
-  base::STLDeleteContainerPairSecondPointers(instance_map_.begin(),
-                                             instance_map_.end());
-}
+IsolatedContext::~IsolatedContext() = default;
 
 FileSystemURL IsolatedContext::CrackFileSystemURL(
     const FileSystemURL& url) const {
   if (!HandlesFileSystemMountType(url.type()))
     return FileSystemURL();
 
   std::string mount_name;
   std::string cracked_mount_name;
   FileSystemType cracked_type;
   base::FilePath cracked_path;
   FileSystemMountOption cracked_mount_option;
   if (!CrackVirtualPath(url.path(), &mount_name, &cracked_type,
                         &cracked_mount_name, &cracked_path,
                         &cracked_mount_option)) {
     return FileSystemURL();
   }
 
   return FileSystemURL(
       url.origin(), url.mount_type(), url.virtual_path(),
       !url.filesystem_id().empty() ? url.filesystem_id() : mount_name,
       cracked_type, cracked_path,
       cracked_mount_name.empty() ? mount_name : cracked_mount_name,
       cracked_mount_option);
 }
 
 bool IsolatedContext::UnregisterFileSystem(const std::string& filesystem_id) {
   lock_.AssertAcquired();
-  IDToInstance::iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return false;
-  Instance* instance = found->second;
+  Instance* instance = found->second.get();
   if (instance->IsSinglePathInstance()) {
-    PathToID::iterator ids_iter = path_to_id_map_.find(
-        instance->file_info().path);
+    auto ids_iter = path_to_id_map_.find(instance->file_info().path);
     DCHECK(ids_iter != path_to_id_map_.end());
     ids_iter->second.erase(filesystem_id);
     if (ids_iter->second.empty())
       path_to_id_map_.erase(ids_iter);
   }
-  delete found->second;
   instance_map_.erase(found);
   return true;
 }
 
 std::string IsolatedContext::GetNewFileSystemId() const {
   // Returns an arbitrary random string which must be unique in the map.
   lock_.AssertAcquired();
   uint32_t random_data[4];
   std::string id;
   do {
     base::RandBytes(random_data, sizeof(random_data));
     id = base::HexEncode(random_data, sizeof(random_data));
   } while (instance_map_.find(id) != instance_map_.end());
   return id;
 }
 
 }  // namespace storage