Remove some uses of stl_util's STLDeleteContainerPointers.

components/certificate_transparency/log_proof_fetcher.cc

 // Copyright 2015 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 "components/certificate_transparency/log_proof_fetcher.h"
 
 #include <iterator>
 #include <memory>
 
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
-#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "components/safe_json/safe_json_parser.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/cert/ct_log_response_parser.h"
 #include "net/cert/signed_tree_head.h"
 #include "net/http/http_status_code.h"
@@ skipping 364 matching lines @@
  private:
   LogProofFetcher::ConsistencyProofFetchedCallback proof_fetched_;
 };
 
 LogProofFetcher::LogProofFetcher(net::URLRequestContext* request_context)
     : request_context_(request_context), weak_factory_(this) {
   DCHECK(request_context);
 }
 
 LogProofFetcher::~LogProofFetcher() {
-  base::STLDeleteContainerPointers(inflight_fetches_.begin(),
-                                   inflight_fetches_.end());
 }
 
 void LogProofFetcher::FetchSignedTreeHead(
     const GURL& base_log_url,
     const std::string& log_id,
     const SignedTreeHeadFetchedCallback& fetched_callback,
     const FetchFailedCallback& failed_callback) {
   GURL request_url = base_log_url.Resolve("ct/v1/get-sth");
-  StartFetch(request_url, new GetSTHLogResponseHandler(log_id, fetched_callback,
-                                                       failed_callback));
+  StartFetch(request_url, base::MakeUnique<GetSTHLogResponseHandler>(
+                              log_id, fetched_callback, failed_callback));
 }
 
 void LogProofFetcher::FetchConsistencyProof(
     const GURL& base_log_url,
     const std::string& log_id,
     uint64_t old_tree_size,
     uint64_t new_tree_size,
     const ConsistencyProofFetchedCallback& fetched_callback,
     const FetchFailedCallback& failed_callback) {
   GURL request_url = base_log_url.Resolve(base::StringPrintf(
       "ct/v1/get-sth-consistency?first=%" PRIu64 "&second=%" PRIu64,
       old_tree_size, new_tree_size));
-  StartFetch(request_url, new GetConsistencyProofLogResponseHandler(
-                              log_id, fetched_callback, failed_callback));
+  StartFetch(request_url,
+             base::MakeUnique<GetConsistencyProofLogResponseHandler>(
+                 log_id, fetched_callback, failed_callback));
 }
 
-void LogProofFetcher::StartFetch(const GURL& request_url,
-                                 LogResponseHandler* log_request) {
-  log_request->StartFetch(request_context_, request_url,
-                          base::Bind(&LogProofFetcher::OnFetchDone,
-                                     weak_factory_.GetWeakPtr(), log_request));
-  inflight_fetches_.insert(log_request);
+void LogProofFetcher::StartFetch(
+    const GURL& request_url,
+    std::unique_ptr<LogResponseHandler> log_request) {
+  log_request->StartFetch(
+      request_context_, request_url,
+      base::Bind(&LogProofFetcher::OnFetchDone, weak_factory_.GetWeakPtr(),
+                 log_request.get()));
+  inflight_fetches_.insert(std::move(log_request));
 }
 
 void LogProofFetcher::OnFetchDone(LogResponseHandler* log_handler,
                                   const base::Closure& requestor_callback) {
-  auto it = inflight_fetches_.find(log_handler);
+  auto it = std::find_if(
+      inflight_fetches_.begin(), inflight_fetches_.end(),
+      [log_handler](const std::unique_ptr<LogResponseHandler>& ptr) {
+        return ptr.get() == log_handler;
+      });
   DCHECK(it != inflight_fetches_.end());
 
-  delete *it;
   inflight_fetches_.erase(it);
   requestor_callback.Run();
 }
 
 }  // namespace certificate_transparency