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::Task::Task(const base::Closure& closure,
+                                        scoped_ptr<MockableTime::Timer> timer,
+                                        base::TimeDelta min_delay,
+                                        base::TimeDelta max_delay)
+    : closure(closure),
+      timer(timer.Pass()),
+      min_delay(min_delay),
+      max_delay(max_delay),
+      eligible(false) {}
+
+DomainReliabilityDispatcher::Task::~Task() {}
+
 DomainReliabilityDispatcher::DomainReliabilityDispatcher(MockableTime* time)
     : time_(time) {}
 
 DomainReliabilityDispatcher::~DomainReliabilityDispatcher() {
   // TODO(ttuttle): STLElementDeleter?
   STLDeleteElements(&tasks_);
 }
 
 void DomainReliabilityDispatcher::ScheduleTask(
     const base::Closure& closure,
@@ skipping 24 matching lines @@
   for (std::set<Task*>::const_iterator it = tasks.begin();
        it != tasks.end();
        ++it) {
     Task* task = *it;
     DCHECK(task);
     DCHECK(task->eligible);
     RunAndDeleteTask(task);
   }
 }
 
-DomainReliabilityDispatcher::Task::Task(const base::Closure& closure,
-                                        scoped_ptr<MockableTime::Timer> timer,
-                                        base::TimeDelta min_delay,
-                                        base::TimeDelta max_delay)
-    : closure(closure),
-      timer(timer.Pass()),
-      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