Remove stl_util's STLDeleteContainerPairSecondPointers from storage/.

storage/browser/fileapi/external_mount_points.cc

 // Copyright (c) 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 "storage/browser/fileapi/external_mount_points.h"
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "storage/browser/fileapi/file_system_url.h"
 
 namespace {
 
 // Normalizes file path so it has normalized separators and ends with exactly
 // one separator. Paths have to be normalized this way for use in
 // GetVirtualPath method. Separators cannot be completely stripped, or
 // GetVirtualPath could not working in some edge cases.
 // For example, /a/b/c(1)/d would be erroneously resolved as c/d if the
 // following mount points were registered: "/a/b/c", "/a/b/c(1)". (Note:
@@ skipping 75 matching lines @@
     const std::string& mount_name,
     FileSystemType type,
     const FileSystemMountOption& mount_option,
     const base::FilePath& path_in) {
   base::AutoLock locker(lock_);
 
   base::FilePath path = NormalizeFilePath(path_in);
   if (!ValidateNewMountPoint(mount_name, type, path))
     return false;
 
-  instance_map_[mount_name] = new Instance(type, path, mount_option);
+  instance_map_[mount_name] =
+      base::MakeUnique<Instance>(type, path, mount_option);
   if (!path.empty() && IsOverlappingMountPathForbidden(type))
     path_to_name_map_.insert(std::make_pair(path, mount_name));
   return true;
 }
 
 bool ExternalMountPoints::HandlesFileSystemMountType(
     FileSystemType type) const {
   return type == kFileSystemTypeExternal ||
          type == kFileSystemTypeNativeForPlatformApp;
 }
 
 bool ExternalMountPoints::RevokeFileSystem(const std::string& mount_name) {
   base::AutoLock locker(lock_);
-  NameToInstance::iterator found = instance_map_.find(mount_name);
+  auto found = instance_map_.find(mount_name);
   if (found == instance_map_.end())
     return false;
-  Instance* instance = found->second;
+  Instance* instance = found->second.get();
   if (IsOverlappingMountPathForbidden(instance->type()))
     path_to_name_map_.erase(NormalizeFilePath(instance->path()));
-  delete found->second;
   instance_map_.erase(found);
   return true;
 }
 
 bool ExternalMountPoints::GetRegisteredPath(
     const std::string& filesystem_id, base::FilePath* path) const {
   DCHECK(path);
   base::AutoLock locker(lock_);
-  NameToInstance::const_iterator found = instance_map_.find(filesystem_id);
+  auto found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return false;
   *path = found->second->path();
   return true;
 }
 
 bool ExternalMountPoints::CrackVirtualPath(
     const base::FilePath& virtual_path,
     std::string* mount_name,
     FileSystemType* type,
@@ skipping 14 matching lines @@
     return false;
 
   std::vector<base::FilePath::StringType>::iterator component_iter =
       components.begin();
   std::string maybe_mount_name =
       base::FilePath(*component_iter++).AsUTF8Unsafe();
 
   base::FilePath cracked_path;
   {
     base::AutoLock locker(lock_);
-    NameToInstance::const_iterator found_instance =
-        instance_map_.find(maybe_mount_name);
+    auto found_instance = instance_map_.find(maybe_mount_name);
     if (found_instance == instance_map_.end())
       return false;
 
     *mount_name = maybe_mount_name;
-    const Instance* instance = found_instance->second;
+    const Instance* instance = found_instance->second.get();
     if (type)
       *type = instance->type();
     cracked_path = instance->path();
     *mount_option = instance->mount_option();
   }
 
   for (; component_iter != components.end(); ++component_iter)
     cracked_path = cracked_path.Append(*component_iter);
   *path = cracked_path;
   return true;
@@ skipping 10 matching lines @@
     const GURL& origin,
     FileSystemType type,
     const base::FilePath& path) const {
   return CrackFileSystemURL(FileSystemURL(origin, type, path));
 }
 
 void ExternalMountPoints::AddMountPointInfosTo(
     std::vector<MountPointInfo>* mount_points) const {
   base::AutoLock locker(lock_);
   DCHECK(mount_points);
-  for (NameToInstance::const_iterator iter = instance_map_.begin();
-       iter != instance_map_.end(); ++iter) {
-    mount_points->push_back(MountPointInfo(iter->first, iter->second->path()));
+  for (const auto& pair : instance_map_) {
+    mount_points->push_back(MountPointInfo(pair.first, pair.second->path()));
   }
 }
 
 bool ExternalMountPoints::GetVirtualPath(const base::FilePath& path_in,
                                          base::FilePath* virtual_path) const {
   DCHECK(virtual_path);
 
   base::AutoLock locker(lock_);
 
   base::FilePath path = NormalizeFilePath(path_in);
@@ skipping 22 matching lines @@
       storage::kFileSystemTypeExternal,
       // Avoid using FilePath::Append as path may be an absolute path.
       base::FilePath(CreateVirtualRootPath(mount_name).value() +
                      base::FilePath::kSeparators[0] + path.value()));
 }
 
 void ExternalMountPoints::RevokeAllFileSystems() {
   NameToInstance instance_map_copy;
   {
     base::AutoLock locker(lock_);
-    instance_map_copy = instance_map_;
-    instance_map_.clear();
+    // This swap moves the contents of instance_map_ to the local variable so
+    // they can be freed outside the lock.
+    instance_map_copy.swap(instance_map_);
     path_to_name_map_.clear();
   }
-  base::STLDeleteContainerPairSecondPointers(instance_map_copy.begin(),
-                                             instance_map_copy.end());
 }
 
-ExternalMountPoints::ExternalMountPoints() {}
+ExternalMountPoints::ExternalMountPoints() = default;
 
-ExternalMountPoints::~ExternalMountPoints() {
-  base::STLDeleteContainerPairSecondPointers(instance_map_.begin(),
-                                             instance_map_.end());
-}
+ExternalMountPoints::~ExternalMountPoints() = default;
 
 FileSystemURL ExternalMountPoints::CrackFileSystemURL(
     const FileSystemURL& url) const {
   if (!HandlesFileSystemMountType(url.type()))
     return FileSystemURL();
 
   base::FilePath virtual_path = url.path();
   if (url.type() == kFileSystemTypeNativeForPlatformApp) {
 #if defined(OS_CHROMEOS)
     // On Chrome OS, find a mount point and virtual path for the external fs.
@@ skipping 29 matching lines @@
 bool ExternalMountPoints::ValidateNewMountPoint(const std::string& mount_name,
                                                 FileSystemType type,
                                                 const base::FilePath& path) {
   lock_.AssertAcquired();
 
   // Mount name must not be empty.
   if (mount_name.empty())
     return false;
 
   // Verify there is no registered mount point with the same name.
-  NameToInstance::iterator found = instance_map_.find(mount_name);
+  auto found = instance_map_.find(mount_name);
   if (found != instance_map_.end())
     return false;
 
   // Allow empty paths.
   if (path.empty())
     return true;
 
   // Verify path is legal.
   if (path.ReferencesParent() || !path.IsAbsolute())
     return false;
@@ skipping 16 matching lines @@
           path.IsParent(potential_child->first)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 }  // namespace storage