Remove stl_util's deletion functions from net/url_request/.

net/url_request/report_sender.cc

Index: net/url_request/report_sender.cc
diff --git a/net/url_request/report_sender.cc b/net/url_request/report_sender.cc
index 16503608f9c4354f5b807135b909b57ddd149a48..226eaba7c32035e62c9c59c1d1732cc7ff77ccac 100644
--- a/net/url_request/report_sender.cc
+++ b/net/url_request/report_sender.cc
@@ -6,7 +6,6 @@
 
 #include <utility>
 
-#include "base/stl_util.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
@@ -28,8 +27,6 @@ ReportSender::ReportSender(URLRequestContext* request_context,
       error_callback_(error_callback) {}
 
 ReportSender::~ReportSender() {
-  // Cancel all of the uncompleted requests.
-  base::STLDeleteElements(&inflight_requests_);
 }
 
 void ReportSender::Send(const GURL& report_uri,
@@ -59,7 +56,7 @@ void ReportSender::Send(const GURL& report_uri,
       ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
 
   URLRequest* raw_url_request = url_request.get();
-  inflight_requests_.insert(url_request.release());
+  inflight_requests_.insert(std::move(url_request));
   raw_url_request->Start();
 }
 
@@ -76,9 +73,12 @@ void ReportSender::OnResponseStarted(URLRequest* request, int net_error) {
       error_callback_.Run(request->url(), net_error);
   }
 
-  CHECK_GT(inflight_requests_.erase(request), 0u);
-  // Clean up the request, which cancels it.
-  delete request;
+  auto it = std::find_if(inflight_requests_.begin(), inflight_requests_.end(),
+                         [request](const std::unique_ptr<URLRequest>& ptr) {
+                           return ptr.get() == request;
+                         });
+  CHECK(it != inflight_requests_.end());
+  inflight_requests_.erase(it);

[davidben, 2016/10/03 16:01:38]

I should have noticed this for the other CL, but if we're doing this, the
std::set is buying us nothing but overhead. It'd be strictly better to use a
std::vector of unique_ptr.

These can also potentially trigger one per URLRequest so I'm not very
comfortable with it being O(N). This is actually a really common pattern where
one object owns a bunch of jobs and drops them when completed. I think it would
be good to just write a base::OwnedSet<T> and use that. (Or maybe some linked
list thing? That would actually be a more efficient structure.)

[Avi (use Gerrit), 2016/10/03 16:27:25]

If we're talking efficiency, linked lists and sets are bad. They guarantee a
cache miss for every access, so that even an O(n) access into a vector is better
performing than an "O(log n)" access that has zero memory locality.

sets of owned objects are kinda broken in C++11 anyway, so I would be super
happy to swap in a vector here.

 }
 
 void ReportSender::OnReadCompleted(URLRequest* request, int bytes_read) {