Add a non-blocking "OneShotEvent" class

extensions/common/async_event_unittest.cc

Index: extensions/common/async_event_unittest.cc
diff --git a/extensions/common/async_event_unittest.cc b/extensions/common/async_event_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..de2c1f4dc5e6a1a1c9cb4bd45630ceff7afa12a1
--- /dev/null
+++ b/extensions/common/async_event_unittest.cc
@@ -0,0 +1,96 @@
+// 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 "base/bind.h"
+#include "base/run_loop.h"
+#include "base/test/test_simple_task_runner.h"
+#include "extensions/common/async_event.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace extensions {
+
+namespace {
+
+void Increment(int* i) {
+  ++*i;
+}
+
+TEST(AsyncEventTest, RecordsHappened) {
+  AsyncEvent event;
+  EXPECT_FALSE(event.has_happened());
+  event.MarkHappened();
+  EXPECT_TRUE(event.has_happened());
+}
+
+TEST(AsyncEventTest, CallsQueue) {
+  AsyncEvent event;
+  scoped_refptr<base::TestSimpleTaskRunner> runner(
+      new base::TestSimpleTaskRunner);
+  int i = 0;
+  event.RunAfter(FROM_HERE, base::Bind(&Increment, &i), runner);
+  event.RunAfter(FROM_HERE, base::Bind(&Increment, &i), runner);
+  EXPECT_EQ(0U, runner->GetPendingTasks().size());
+  event.MarkHappened();
+  ASSERT_EQ(2U, runner->GetPendingTasks().size());
+  EXPECT_NE(runner->GetPendingTasks()[0].location.line_number(),
+            runner->GetPendingTasks()[1].location.line_number())
+      << "Make sure FROM_HERE is propagated.";
+  EXPECT_EQ(0, i);
+  runner->RunPendingTasks();
+  EXPECT_EQ(2, i);
+}
+
+TEST(AsyncEventTest, CallsAfterHappenedDontRunInline) {
+  AsyncEvent event;
+  scoped_refptr<base::TestSimpleTaskRunner> runner(
+      new base::TestSimpleTaskRunner);
+  int i = 0;
+
+  event.MarkHappened();
+  event.RunAfter(FROM_HERE, base::Bind(&Increment, &i), runner);
+  EXPECT_EQ(1U, runner->GetPendingTasks().size());
+  EXPECT_EQ(0, i);
+  runner->RunPendingTasks();
+  EXPECT_EQ(1, i);
+}
+
+TEST(AsyncEventTest, RunAfterDefaultsToCurrentMessageLoop) {
+  AsyncEvent event;
+  scoped_refptr<base::TestSimpleTaskRunner> runner(
+      new base::TestSimpleTaskRunner);
+  MessageLoop loop;
+  int runner_i = 0;
+  int loop_i = 0;
+
+  event.RunAfter(FROM_HERE, base::Bind(&Increment, &runner_i), runner);
+  event.RunAfter(FROM_HERE, base::Bind(&Increment, &loop_i));
+  event.MarkHappened();
+  EXPECT_EQ(1U, runner->GetPendingTasks().size());
+  EXPECT_EQ(0, runner_i);
+  runner->RunPendingTasks();
+  EXPECT_EQ(1, runner_i);
+  EXPECT_EQ(0, loop_i);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(1, loop_i);
+}
+
+TEST(AsyncEventTest, SupportsMessageLoopOutlivingEvent) {
+  scoped_refptr<base::TestSimpleTaskRunner> runner(
+      new base::TestSimpleTaskRunner);
+  {
+    // Use scoped_ptr to help detect use-after-free.
+    scoped_ptr<AsyncEvent> event1(new AsyncEvent), event2(new AsyncEvent);
+    event1->RunAfter(FROM_HERE,
+                     base::Bind(&AsyncEvent::MarkHappened, event2->AsWeakPtr()),
+                     runner);
+    // The event happens, and then both ends are destroyed.
+    event1->MarkHappened();
+  }
+  // The pending closure shouldn't call any methods on the
+  // now-destroyed |event2|.
+  runner->RunPendingTasks();
+}
+
+}  // namespace
+}  // namespace extensions