Domain Reliability: More security review.

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 "base/bind.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,
+       scoped_ptr<MockableTime::Timer> timer,
+       base::TimeDelta min_delay,
+       base::TimeDelta max_delay);
+  ~Task();
+
+  base::Closure closure;
+  scoped_ptr<MockableTime::Timer> timer;
+  base::TimeDelta min_delay;
+  base::TimeDelta max_delay;
+  bool eligible;
+};
+
 DomainReliabilityDispatcher::DomainReliabilityDispatcher(MockableTime* time)
     : time_(time) {}
 
 DomainReliabilityDispatcher::~DomainReliabilityDispatcher() {
   // TODO(ttuttle): STLElementDeleter?
   STLDeleteElements(&tasks_);
 }
 
 void DomainReliabilityDispatcher::ScheduleTask(
     const base::Closure& closure,
@@ skipping 40 matching lines @@
       min_delay(min_delay),
       max_delay(max_delay),
       eligible(false) {}
 
 DomainReliabilityDispatcher::Task::~Task() {}
 
 void DomainReliabilityDispatcher::MakeTaskWaiting(Task* task) {
   DCHECK(task);
   DCHECK(!task->eligible);
   DCHECK(!task->timer->IsRunning());
-  task->timer->Start(
-      FROM_HERE,
-      task->min_delay,
-      base::Bind(
-          &DomainReliabilityDispatcher::MakeTaskEligible,
-          base::Unretained(this),
-          task));
+  task->timer->Start(FROM_HERE,
+                     task->min_delay,
+                     base::Bind(&DomainReliabilityDispatcher::MakeTaskEligible,
+                                base::Unretained(this),
+                                task));
 }
 
 void
 DomainReliabilityDispatcher::MakeTaskEligible(Task* task) {
   DCHECK(task);
   DCHECK(!task->eligible);
   task->eligible = true;
   eligible_tasks_.insert(task);
-  task->timer->Start(
-      FROM_HERE,
-      task->max_delay - task->min_delay,
-      base::Bind(
-          &DomainReliabilityDispatcher::RunAndDeleteTask,
-          base::Unretained(this),
-          task));
+  task->timer->Start(FROM_HERE,
+                     task->max_delay - task->min_delay,
+                     base::Bind(&DomainReliabilityDispatcher::RunAndDeleteTask,
+                                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;
 }
 
 }  // namespace domain_reliability