Remove stl_util use from domain_reliability.

components/domain_reliability/dispatcher.cc

 // Copyright 2014 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/domain_reliability/dispatcher.h"
 
+#include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
-#include "base/stl_util.h"
 #include "base/timer/timer.h"
 #include "components/domain_reliability/util.h"
 
 namespace domain_reliability {
 
 struct DomainReliabilityDispatcher::Task {
   Task(const base::Closure& closure,
        std::unique_ptr<MockableTime::Timer> timer,
        base::TimeDelta min_delay,
        base::TimeDelta max_delay);
@@ skipping 15 matching lines @@
       timer(std::move(timer)),
       min_delay(min_delay),
       max_delay(max_delay),
       eligible(false) {}
 
 DomainReliabilityDispatcher::Task::~Task() {}
 
 DomainReliabilityDispatcher::DomainReliabilityDispatcher(MockableTime* time)
     : time_(time) {}
 
-DomainReliabilityDispatcher::~DomainReliabilityDispatcher() {
-  // TODO(juliatuttle): STLElementDeleter?
-  base::STLDeleteElements(&tasks_);
-}
+DomainReliabilityDispatcher::~DomainReliabilityDispatcher() {}
 
 void DomainReliabilityDispatcher::ScheduleTask(
     const base::Closure& closure,
     base::TimeDelta min_delay,
     base::TimeDelta max_delay) {
   DCHECK(!closure.is_null());
   // Would be DCHECK_LE, but you can't << a TimeDelta.
   DCHECK(min_delay <= max_delay);
 
-  Task* task = new Task(closure, time_->CreateTimer(), min_delay, max_delay);
-  tasks_.insert(task);
+  std::unique_ptr<Task> owned_task = base::MakeUnique<Task>(
+      closure, time_->CreateTimer(), min_delay, max_delay);
+  Task* task = owned_task.get();
+  tasks_.insert(std::move(owned_task));
   if (max_delay.InMicroseconds() < 0)
     RunAndDeleteTask(task);
   else if (min_delay.InMicroseconds() < 0)
     MakeTaskEligible(task);
   else
     MakeTaskWaiting(task);
 }
 
 void DomainReliabilityDispatcher::RunEligibleTasks() {
   // Move all eligible tasks to a separate set so that eligible_tasks_.erase in
@@ skipping 33 matching lines @@
                                 base::Unretained(this),
                                 task));
 }
 
 void DomainReliabilityDispatcher::RunAndDeleteTask(Task* task) {
   DCHECK(task);
   DCHECK(!task->closure.is_null());
   task->closure.Run();
   if (task->eligible)
     eligible_tasks_.erase(task);
-  tasks_.erase(task);
-  delete task;
+
+  auto it = std::find_if(tasks_.begin(), tasks_.end(),
+                         [task](const std::unique_ptr<Task>& task_ptr) {
+                           return task_ptr.get() == task;
+                         });

[davidben, 2016/08/30 00:52:54]

This switches from O(lg N) to O(N) which is a bit unfortunate. (I did see the
thread. Crappy situation. :-/)

+juliatuttle, do you know if making this O(N) would an issue here?

I do wonder if we should add a base::OwnedSet<T> instead. It seems pretty common
to have a parent object maintain some owned set of jobs or tasks or other
sub-objects which need to get cleared out when the parent is destroyed.

[Julia Tuttle, 2016/08/30 13:46:37]

Shouldn't be an issue. At absolute worst it will be O(400) or so, since that's
how many domains we have in the system.

[davidben, 2016/08/30 13:49:16]

Hrm. Wouldn't that bound increase once we have the standards-based header
version rather than a hard-coded domain list?

[Julia Tuttle, 2016/08/30 13:59:53]

Nah, I'm hoping that ends up going through the Reporting API.

+
+  DCHECK(it != tasks_.end());
+  tasks_.erase(it);
 }
 
 }  // namespace domain_reliability