Prevent multiple pending UpdatePolicy tasks.

content/renderer/scheduler/deadline_task_runner.cc

Index: content/renderer/scheduler/deadline_task_runner.cc
diff --git a/content/renderer/scheduler/deadline_task_runner.cc b/content/renderer/scheduler/deadline_task_runner.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3ad3bc9aed09f916017bea0c3fd6586ef7a6146d
--- /dev/null
+++ b/content/renderer/scheduler/deadline_task_runner.cc
@@ -0,0 +1,50 @@
+// 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 "content/renderer/scheduler/deadline_task_runner.h"
+
+#include "base/bind.h"
+
+namespace content {
+
+DeadlineTaskRunner::DeadlineTaskRunner(
+    const base::Closure& callback,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : callback_(callback), task_runner_(task_runner), weak_factory_(this) {
+  InitializeRunInternal();
+}
+
+DeadlineTaskRunner::~DeadlineTaskRunner() {
+}
+
+void DeadlineTaskRunner::SetDeadline(const tracked_objects::Location& from_here,
+                                     base::TimeTicks deadline,
+                                     base::TimeTicks now) {
+  DCHECK(deadline > now);
+  if (deadline_ != base::TimeTicks()) {
+    if (deadline >= deadline_)
+      return;

[rmcilroy, 2015/03/12 15:45:30]

This might be clearer with a non-nested early out and use of a
CancelableClosureHolder (see my comment below).  I think you could do this as:

if (deadline >= deadline_)
  return;

if (deadline_ != base::TimeTicks)
  cancelable_closure_.Cancel()

deadline_ = deadline
task_runner_->PostDelayedTask(from_here, cancelable_closure_, delay);

[alex clarke (OOO till 29th), 2015/03/12 17:01:49]

Unfortunately that will always early out if we use deadline_ = base::TimeTicks()
to signal that no timer has been posted.   But I think I can simplify this
another way.

+
+    Cancel();
+  }
+  deadline_ = deadline;
+  task_runner_->PostDelayedTask(from_here, run_internal_, deadline - now);
+}
+
+void DeadlineTaskRunner::RunInternal() {
+  deadline_ = base::TimeTicks();
+  callback_.Run();
+}
+
+void DeadlineTaskRunner::Cancel() {
+  weak_factory_.InvalidateWeakPtrs();
+  InitializeRunInternal();
+}
+
+void DeadlineTaskRunner::InitializeRunInternal() {
+  run_internal_ =
+      base::Bind(&DeadlineTaskRunner::RunInternal, weak_factory_.GetWeakPtr());

[rmcilroy, 2015/03/12 15:45:30]

Just use a CancelableClosureHolder for the internal closure - then you can
create it once in the constructor and don't need to recreate it again and don't
need a weak_factory_ - just call cancelable_closure.Cancel() and
cancelable_closure.callback() in SetDeadline()

[alex clarke (OOO till 29th), 2015/03/12 17:01:49]

I thought about doing it that way but I think we'd end up with three nested
closures. This method has two.

+}
+
+}  // namespace content