Add a non-blocking "OneShotEvent" class

extensions/common/async_event.cc

Index: extensions/common/async_event.cc
diff --git a/extensions/common/async_event.cc b/extensions/common/async_event.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8b9d05c238c8a8f048fb1d3eb904085dd3f82c48
--- /dev/null
+++ b/extensions/common/async_event.cc
@@ -0,0 +1,67 @@
+// Copyright (c) 2013 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 "extensions/common/async_event.h"
+
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/logging.h"

[Devlin, 2013/05/15 00:21:16]

logging is included in both the .h and .cc file.

[Jeffrey Yasskin, 2013/05/15 03:07:18]

That's not a big problem, but sure, removed it from here.

+#include "base/message_loop/message_loop_proxy.h"
+#include "base/task_runner.h"
+
+using base::TaskRunner;
+
+namespace extensions {
+
+struct AsyncEvent::TaskInfo {
+  TaskInfo() {}
+  TaskInfo(const tracked_objects::Location& from_here,
+           const scoped_refptr<TaskRunner>& runner,
+           const base::Closure& task)
+      : from_here(from_here), runner(runner), task(task) {}
+  tracked_objects::Location from_here;
+  scoped_refptr<TaskRunner> runner;
+  base::Closure task;
+};
+
+AsyncEvent::AsyncEvent() : happened_(false) {}
+AsyncEvent::~AsyncEvent() {}
+
+void AsyncEvent::RunAfter(const tracked_objects::Location& from_here,
+                          const base::Closure& task,
+                          const scoped_refptr<TaskRunner>& in_runner) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  scoped_refptr<TaskRunner> message_loop_proxy;
+  TaskRunner* runner = in_runner.get();
+  if (runner == NULL) {
+    message_loop_proxy = base::MessageLoopProxy::current();
+    runner = message_loop_proxy.get();
+  }
+
+  if (has_happened()) {
+    runner->PostTask(from_here, task);
+  } else {
+    tasks_.push_back(TaskInfo(from_here, runner, task));
+  }
+}
+
+void AsyncEvent::MarkHappened() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  CHECK(!happened_) << "Only call MarkHappened once.";
+
+  happened_ = true;
+  // After this point, a call to RunAfter() from one of the queued
+  // tasks could proceed immediately, but the fact that this object is
+  // single-threaded prevents that from being relevant.
+
+  // We could randomize tasks_ in debug mode in order to check that
+  // the order doesn't matter...
+  for (size_t i = 0; i < tasks_.size(); ++i) {
+    tasks_[i].runner->PostTask(tasks_[i].from_here, tasks_[i].task);
+  }
+}
+
+}

[Devlin, 2013/05/15 00:21:16]

// namespace extensions

[Jeffrey Yasskin, 2013/05/15 03:07:18]

Done.