Remove stl_util's deletion functions from net/cookies/ and net/extras/.

net/extras/sqlite/sqlite_persistent_cookie_store.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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
+#include <iterator>
 #include <map>
 #include <memory>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 84 matching lines @@
 
   // Creates or loads the SQLite database.
   void Load(const LoadedCallback& loaded_callback);
 
   // Loads cookies for the domain key (eTLD+1).
   void LoadCookiesForKey(const std::string& domain,
                          const LoadedCallback& loaded_callback);
 
   // Steps through all results of |smt|, makes a cookie from each, and adds the
   // cookie to |cookies|. This method also updates |num_cookies_read_|.
-  void MakeCookiesFromSQLStatement(std::vector<CanonicalCookie*>* cookies,
-                                   sql::Statement* statement);
+  void MakeCookiesFromSQLStatement(
+      std::vector<std::unique_ptr<CanonicalCookie>>* cookies,
+      sql::Statement* statement);
 
   // Batch a cookie addition.
   void AddCookie(const CanonicalCookie& cc);
 
   // Batch a cookie access time update.
   void UpdateCookieAccessTime(const CanonicalCookie& cc);
 
   // Batch a cookie deletion.
   void DeleteCookie(const CanonicalCookie& cc);
 
   // Commit pending operations as soon as possible.
   void Flush(const base::Closure& callback);
 
   // Commit any pending operations and close the database.  This must be called
   // before the object is destructed.
   void Close(const base::Closure& callback);
 
   // Post background delete of all cookies that match |cookies|.
   void DeleteAllInList(const std::list<CookieOrigin>& cookies);
 
  private:
   friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;
 
   // You should call Close() before destructing this object.
   ~Backend() {
     DCHECK(!db_.get()) << "Close should have already been called.";
     DCHECK_EQ(0u, num_pending_);
     DCHECK(pending_.empty());
-
-    for (CanonicalCookie* cookie : cookies_) {
-      delete cookie;
-    }
   }
 
   // Database upgrade statements.
   bool EnsureDatabaseVersion();
 
   class PendingOperation {
    public:
     enum OperationType {
       COOKIE_ADD,
       COOKIE_UPDATEACCESS,
@@ skipping 92 matching lines @@
 
   typedef std::list<PendingOperation*> PendingOperationsList;
   PendingOperationsList pending_;
   PendingOperationsList::size_type num_pending_;
   // Guard |cookies_|, |pending_|, |num_pending_|.
   base::Lock lock_;
 
   // Temporary buffer for cookies loaded from DB. Accumulates cookies to reduce
   // the number of messages sent to the client runner. Sent back in response to
   // individual load requests for domain keys or when all loading completes.
-  // Ownership of the cookies in this vector is transferred to the client in
-  // response to individual load requests or when all loading completes.
-  std::vector<CanonicalCookie*> cookies_;
+  std::vector<std::unique_ptr<CanonicalCookie>> cookies_;
 
   // Map of domain keys(eTLD+1) to domains/hosts that are to be loaded from DB.
   std::map<std::string, std::set<std::string>> keys_to_load_;
 
   // Indicates if DB has been initialized.
   bool initialized_;
 
   // Indicates if the kill-database callback has been scheduled.
   bool corruption_detected_;
 
@@ skipping 343 matching lines @@
 
   if (load_success)
     ReportMetrics();
 }
 
 void SQLitePersistentCookieStore::Backend::Notify(
     const LoadedCallback& loaded_callback,
     bool load_success) {
   DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
 
-  std::vector<CanonicalCookie*> cookies;
+  std::vector<std::unique_ptr<CanonicalCookie>> cookies;
   {
     base::AutoLock locked(lock_);
     cookies.swap(cookies_);
   }
 
-  loaded_callback.Run(cookies);
+  loaded_callback.Run(std::move(cookies));
 }
 
 bool SQLitePersistentCookieStore::Backend::InitializeDatabase() {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
   if (initialized_ || corruption_detected_) {
     // Return false if we were previously initialized but the DB has since been
     // closed, or if corruption caused a database reset during initialization.
     return db_ != NULL;
   }
@@ skipping 145 matching lines @@
         "has_expires, persistent, priority FROM cookies WHERE host_key = ? "
         "AND persistent = 1"));
   }
   if (!smt.is_valid()) {
     smt.Clear();  // Disconnect smt_ref from db_.
     meta_table_.Reset();
     db_.reset();
     return false;
   }
 
-  std::vector<CanonicalCookie*> cookies;
+  std::vector<std::unique_ptr<CanonicalCookie>> cookies;
   std::set<std::string>::const_iterator it = domains.begin();
   for (; it != domains.end(); ++it) {
     smt.BindString(0, *it);
     MakeCookiesFromSQLStatement(&cookies, &smt);
     smt.Reset(true);
   }
   {
     base::AutoLock locked(lock_);
-    cookies_.insert(cookies_.end(), cookies.begin(), cookies.end());
+    std::move(cookies.begin(), cookies.end(), std::back_inserter(cookies_));
   }
   return true;
 }
 
 void SQLitePersistentCookieStore::Backend::MakeCookiesFromSQLStatement(
-    std::vector<CanonicalCookie*>* cookies,
+    std::vector<std::unique_ptr<CanonicalCookie>>* cookies,
     sql::Statement* statement) {
   sql::Statement& smt = *statement;
   while (smt.Step()) {
     std::string value;
     std::string encrypted_value = smt.ColumnString(4);
     if (!encrypted_value.empty() && crypto_) {
       if (!crypto_->DecryptString(encrypted_value, &value))
         continue;
     } else {
       value = smt.ColumnString(3);
     }
     std::unique_ptr<CanonicalCookie> cc(CanonicalCookie::Create(
         smt.ColumnString(2),                           // name
         value,                                         // value
         smt.ColumnString(1),                           // domain
         smt.ColumnString(5),                           // path
         Time::FromInternalValue(smt.ColumnInt64(0)),   // creation_utc
         Time::FromInternalValue(smt.ColumnInt64(6)),   // expires_utc
         Time::FromInternalValue(smt.ColumnInt64(10)),  // last_access_utc
         smt.ColumnInt(7) != 0,                         // secure
         smt.ColumnInt(8) != 0,                         // http_only
         DBCookieSameSiteToCookieSameSite(
             static_cast<DBCookieSameSite>(smt.ColumnInt(9))),  // samesite
         DBCookiePriorityToCookiePriority(
             static_cast<DBCookiePriority>(smt.ColumnInt(13)))));  // priority
     DLOG_IF(WARNING, cc->CreationDate() > Time::Now())
         << L"CreationDate too recent";
-    cookies->push_back(cc.release());
+    cookies->push_back(std::move(cc));
     ++num_cookies_read_;
   }
 }
 
 bool SQLitePersistentCookieStore::Backend::EnsureDatabaseVersion() {
   // Version check.
   if (!meta_table_.Init(db_.get(), kCurrentVersionNumber,
                         kCompatibleVersionNumber)) {
     return false;
   }
@@ skipping 546 matching lines @@
     // Backend::InternalBackgroundClose() yet.
     backend_ = nullptr;
   }
 }
 
 void SQLitePersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
   DCHECK(!loaded_callback.is_null());
   if (backend_)
     backend_->Load(loaded_callback);
   else
-    loaded_callback.Run(std::vector<CanonicalCookie*>());
+    loaded_callback.Run(std::vector<std::unique_ptr<CanonicalCookie>>());
 }
 
 void SQLitePersistentCookieStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
   DCHECK(!loaded_callback.is_null());
   if (backend_)
     backend_->LoadCookiesForKey(key, loaded_callback);
   else
-    loaded_callback.Run(std::vector<CanonicalCookie*>());
+    loaded_callback.Run(std::vector<std::unique_ptr<CanonicalCookie>>());
 }
 
 void SQLitePersistentCookieStore::AddCookie(const CanonicalCookie& cc) {
   if (backend_)
     backend_->AddCookie(cc);
 }
 
 void SQLitePersistentCookieStore::UpdateCookieAccessTime(
     const CanonicalCookie& cc) {
   if (backend_)
@@ skipping 12 matching lines @@
 void SQLitePersistentCookieStore::Flush(const base::Closure& callback) {
   if (backend_)
     backend_->Flush(callback);
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   Close(base::Closure());
 }
 
 }  // namespace net