Remove use of stl_util's STLDeleteContainerPairSecondPointers from content/.

content/browser/indexed_db/indexed_db_backing_store.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 "content/browser/indexed_db/indexed_db_backing_store.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "build/build_config.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
@@ skipping 736 matching lines @@
       active_blob_registry_(this),
       committing_transaction_count_(0) {}
 
 IndexedDBBackingStore::~IndexedDBBackingStore() {
   if (!blob_path_.empty() && !child_process_ids_granted_.empty()) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     for (const auto& pid : child_process_ids_granted_)
       policy->RevokeAllPermissionsForFile(pid, blob_path_);
   }
-  base::STLDeleteContainerPairSecondPointers(incognito_blob_map_.begin(),
-                                             incognito_blob_map_.end());
+  incognito_blob_map_.clear();
   // db_'s destructor uses comparator_. The order of destruction is important.
   db_.reset();
   comparator_.reset();
 }
 
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier(
     const std::string& primary_key,
     int64_t version)
     : primary_key_(primary_key), version_(version) {
   DCHECK(!primary_key.empty());
@@ skipping 1915 matching lines @@
   return journal_transaction->Commit();
 }
 
 leveldb::Status IndexedDBBackingStore::Transaction::GetBlobInfoForRecord(
     int64_t database_id,
     const std::string& object_store_data_key,
     IndexedDBValue* value) {
   BlobChangeRecord* change_record = NULL;
   auto blob_iter = blob_change_map_.find(object_store_data_key);
   if (blob_iter != blob_change_map_.end()) {
-    change_record = blob_iter->second;
+    change_record = blob_iter->second.get();
   } else {
     blob_iter = incognito_blob_map_.find(object_store_data_key);
     if (blob_iter != incognito_blob_map_.end())
-      change_record = blob_iter->second;
+      change_record = blob_iter->second.get();
   }
   if (change_record) {
     // Either we haven't written the blob to disk yet or we're in incognito
     // mode, so we have to send back the one they sent us.  This change record
     // includes the original UUID.
     value->blob_info = change_record->blob_info();
     return leveldb::Status::OK();
   }
 
   BlobEntryKey blob_entry_key;
@@ skipping 1274 matching lines @@
 
   return std::move(cursor);
 }
 
 IndexedDBBackingStore::Transaction::Transaction(
     IndexedDBBackingStore* backing_store)
     : backing_store_(backing_store), database_id_(-1), committing_(false) {
 }
 
 IndexedDBBackingStore::Transaction::~Transaction() {
-  base::STLDeleteContainerPairSecondPointers(blob_change_map_.begin(),
-                                             blob_change_map_.end());
-  base::STLDeleteContainerPairSecondPointers(incognito_blob_map_.begin(),
-                                             incognito_blob_map_.end());
+  blob_change_map_.clear();
+  incognito_blob_map_.clear();
   DCHECK(!committing_);
 }
 
 void IndexedDBBackingStore::Transaction::Begin() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Begin");
   DCHECK(!transaction_.get());
   transaction_ = IndexedDBClassFactory::Get()->CreateLevelDBTransaction(
       backing_store_->db_.get());
 
   // If incognito, this snapshots blobs just as the above transaction_
   // constructor snapshots the leveldb.
   for (const auto& iter : backing_store_->incognito_blob_map_)
-    incognito_blob_map_[iter.first] = iter.second->Clone().release();
+    incognito_blob_map_[iter.first] = iter.second->Clone();
 }
 
 static GURL GetURLFromUUID(const string& uuid) {
   return GURL("blob:uuid/" + uuid);
 }
 
 leveldb::Status IndexedDBBackingStore::Transaction::HandleBlobPreTransaction(
     BlobEntryKeyValuePairVec* new_blob_entries,
     WriteDescriptorVec* new_files_to_write) {
   if (backing_store_->is_incognito())
@@ skipping 204 matching lines @@
     INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
     return s;
   }
 
   if (backing_store_->is_incognito()) {
     if (!blob_change_map_.empty()) {
       auto& target_map = backing_store_->incognito_blob_map_;
       for (auto& iter : blob_change_map_) {
         auto target_record = target_map.find(iter.first);
         if (target_record != target_map.end()) {
-          delete target_record->second;
           target_map.erase(target_record);
         }
         if (iter.second) {
-          target_map[iter.first] = iter.second;
-          iter.second = NULL;
+          target_map[iter.first] = std::move(iter.second);
         }

[ncarter (slow), 2016/08/15 21:51:33]

It seems like this can be further simplified (maybe to the following)

if (backing_store_->is_incognito()) {
  for (auto& iter : blob_change_map_) {
    if (iter.second) {
      backing_store_->incognito_blob_map_[iter.first] = std::move(iter.second);
    } else {
      backing_store_->incognito_blob_map_.erase(iter.first);
    }
  }
}

But it's fine if you want to keep the edits minimal.

[Avi (use Gerrit), 2016/08/15 23:46:49]

Yes, I'm convinced your rewrite is correct; going for it.

       }
     }
     return leveldb::Status::OK();
   }
 
   // Actually delete dead blob files, then remove those entries
   // from the persisted primary journal.
   if (dead_blobs.empty())
     return leveldb::Status::OK();
 
@@ skipping 158 matching lines @@
     ScopedVector<storage::BlobDataHandle>* handles) {
   DCHECK_GT(object_store_data_key.size(), 0UL);
   if (database_id_ < 0)
     database_id_ = database_id;
   DCHECK_EQ(database_id_, database_id);
 
   const auto& it = blob_change_map_.find(object_store_data_key);
   BlobChangeRecord* record = NULL;
   if (it == blob_change_map_.end()) {
     record = new BlobChangeRecord(object_store_data_key, object_store_id);
-    blob_change_map_[object_store_data_key] = record;
+    blob_change_map_[object_store_data_key] = base::WrapUnique(record);
   } else {
-    record = it->second;
+    record = it->second.get();
   }
   DCHECK_EQ(record->object_store_id(), object_store_id);
   record->SetBlobInfo(blob_info);
   record->SetHandles(handles);
   DCHECK(!handles || handles->empty());
 }
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const GURL& url,
     int64_t key,
@@ skipping 20 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content