Remove stl_util's STLDeleteContainerPairSecondPointers from storage/.

storage/browser/fileapi/obfuscated_file_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 "storage/browser/fileapi/obfuscated_file_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <queue>
 #include <tuple>
 
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.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 "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "storage/browser/fileapi/file_observers.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation_context.h"
 #include "storage/browser/fileapi/native_file_util.h"
@@ skipping 866 matching lines @@
     origin_database_->RemovePathForOrigin(
         storage::GetIdentifierFromOrigin(origin));
   }
   return base::DeleteFile(origin_path, true /* recursive */);
 }
 
 void ObfuscatedFileUtil::CloseFileSystemForOriginAndType(
     const GURL& origin,
     const std::string& type_string) {
   const std::string key_prefix = GetDirectoryDatabaseKey(origin, type_string);
-  for (DirectoryMap::iterator iter = directories_.lower_bound(key_prefix);
+  for (auto iter = directories_.lower_bound(key_prefix);
        iter != directories_.end();) {
     if (!base::StartsWith(iter->first, key_prefix,
                           base::CompareCase::SENSITIVE))
       break;
     DCHECK(type_string.empty() || iter->first == key_prefix);
-    std::unique_ptr<SandboxDirectoryDatabase> database(iter->second);
     directories_.erase(iter++);
   }
 }
 
 ObfuscatedFileUtil::AbstractOriginEnumerator*
 ObfuscatedFileUtil::CreateOriginEnumerator() {
   std::vector<SandboxOriginDatabase::OriginRecord> origins;
 
   InitOriginDatabase(GURL(), false);
   return new ObfuscatedOriginEnumerator(
       origin_database_.get(), file_system_directory_);
 }
 
 void ObfuscatedFileUtil::DestroyDirectoryDatabase(
     const GURL& origin,
     const std::string& type_string) {
   // If |type_string| is empty, delete all filesystem types under |origin|.
   const std::string key_prefix = GetDirectoryDatabaseKey(origin, type_string);
-  for (DirectoryMap::iterator iter = directories_.lower_bound(key_prefix);
+  for (auto iter = directories_.lower_bound(key_prefix);
        iter != directories_.end();) {
     if (!base::StartsWith(iter->first, key_prefix,
                           base::CompareCase::SENSITIVE))
       break;
     DCHECK(type_string.empty() || iter->first == key_prefix);
-    std::unique_ptr<SandboxDirectoryDatabase> database(iter->second);
+    std::unique_ptr<SandboxDirectoryDatabase> database =
+        std::move(iter->second);
     directories_.erase(iter++);
 
     // Continue to destroy databases even if it failed because it doesn't affect
     // the final result.
     database->DestroyDatabase();
   }
 }
 
 // static
 int64_t ObfuscatedFileUtil::ComputeFilePathCost(const base::FilePath& path) {
@@ skipping 14 matching lines @@
   for (size_t i = 0; i < type_strings_to_prepopulate.size(); ++i) {
     const std::string type_string = type_strings_to_prepopulate[i];
     // Only handles known types.
     if (!base::ContainsKey(known_type_strings_, type_string))
       continue;
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = GetDirectoryForOriginAndType(
         origin, type_string, false, &error);
     if (error != base::File::FILE_OK)
       continue;
-    std::unique_ptr<SandboxDirectoryDatabase> db(
-        new SandboxDirectoryDatabase(path, env_override_));
+    std::unique_ptr<SandboxDirectoryDatabase> db =
+        base::MakeUnique<SandboxDirectoryDatabase>(path, env_override_);
     if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) {
-      directories_[GetDirectoryDatabaseKey(origin, type_string)] = db.release();
+      directories_[GetDirectoryDatabaseKey(origin, type_string)] =
+          std::move(db);
       MarkUsed();
       // Don't populate more than one database, as it may rather hurt
       // performance.
       break;
     }
   }
 }
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForURL(
     const FileSystemURL& url,
@@ skipping 175 matching lines @@
 // We may not have quota even to create the database.
 // Ah, in that case don't even get here?
 // Still doesn't answer the quota issue, though.
 SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     const FileSystemURL& url, bool create) {
   std::string key = GetDirectoryDatabaseKey(
       url.origin(), CallGetTypeStringForURL(url));
   if (key.empty())
     return NULL;
 
-  DirectoryMap::iterator iter = directories_.find(key);
+  auto iter = directories_.find(key);
   if (iter != directories_.end()) {
     MarkUsed();
-    return iter->second;
+    return iter->second.get();
   }
 
   base::File::Error error = base::File::FILE_OK;
   base::FilePath path = GetDirectoryForURL(url, create, &error);
   if (error != base::File::FILE_OK) {
     LOG(WARNING) << "Failed to get origin+type directory: "
                  << url.DebugString() << " error:" << error;
     return NULL;
   }
   MarkUsed();
-  SandboxDirectoryDatabase* database =
-      new SandboxDirectoryDatabase(path, env_override_);
-  directories_[key] = database;
-  return database;
+  directories_[key] =
+      base::MakeUnique<SandboxDirectoryDatabase>(path, env_override_);
+  return directories_[key].get();
 }
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create, base::File::Error* error_code) {
   if (!InitOriginDatabase(origin, create)) {
     if (error_code) {
       *error_code = create ?
           base::File::FILE_ERROR_FAILED :
           base::File::FILE_ERROR_NOT_FOUND;
     }
@@ skipping 58 matching lines @@
   } else {
     timer_->Start(FROM_HERE,
                   base::TimeDelta::FromSeconds(db_flush_delay_seconds_),
                   base::Bind(&ObfuscatedFileUtil::DropDatabases,
                              base::Unretained(this)));
   }
 }
 
 void ObfuscatedFileUtil::DropDatabases() {
   origin_database_.reset();
-  base::STLDeleteContainerPairSecondPointers(directories_.begin(),
-                                             directories_.end());
   directories_.clear();
   timer_.reset();
 }
 
 bool ObfuscatedFileUtil::InitOriginDatabase(const GURL& origin_hint,
                                             bool create) {
   if (origin_database_)
     return true;
 
   if (!create && !base::DirectoryExists(file_system_directory_))
@@ skipping 140 matching lines @@
   }
   return file;
 }
 
 bool ObfuscatedFileUtil::HasIsolatedStorage(const GURL& origin) {
   return special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin);
 }
 
 }  // namespace storage