cc: Add UniqueNotifier to cc/base.

cc/base/delayed_unique_notifier_unittest.cc

Index: cc/base/delayed_unique_notifier_unittest.cc
diff --git a/cc/base/delayed_unique_notifier_unittest.cc b/cc/base/delayed_unique_notifier_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3281d388525f29edcd65fb029ef18ce91e22446f
--- /dev/null
+++ b/cc/base/delayed_unique_notifier_unittest.cc
@@ -0,0 +1,101 @@
+// 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 "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "cc/base/delayed_unique_notifier.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+class DelayedUniqueNotifierTest : public testing::Test {
+ public:
+  DelayedUniqueNotifierTest() : notification_count_(0) {}
+
+  virtual void SetUp() OVERRIDE { ResetNotificationCount(); }
+
+  void Notify() { ++notification_count_; }
+
+  int NotificationCount() const { return notification_count_; }
+
+  void ResetNotificationCount() { notification_count_ = 0; }
+
+  void RunForTime(base::TimeDelta delay) {

[reveman, 2014/05/21 20:01:56]

RunLoop::RunUntilIdle() doesn't wait for delayed tasks to run?

+    base::RunLoop run_loop;
+    base::MessageLoopProxy::current()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), delay);
+    run_loop.Run();
+  }
+
+ protected:
+  int notification_count_;
+};
+
+TEST_F(DelayedUniqueNotifierTest, SecondDelay) {
+  DelayedUniqueNotifier notifier(
+      base::MessageLoopProxy::current(),
+      base::Bind(&DelayedUniqueNotifierTest::Notify, base::Unretained(this)),
+      base::TimeDelta::FromSeconds(1));
+
+  EXPECT_EQ(0, NotificationCount());
+
+  // Basic schedule for 1 second from now.
+  notifier.Schedule();
+
+  // Half a second passed, we should have no runs.
+  RunForTime(base::TimeDelta::FromMilliseconds(500));
+  EXPECT_EQ(0, NotificationCount());
+
+  // After another 0.6 seconds, we should get a run.
+  RunForTime(base::TimeDelta::FromMilliseconds(600));
+  EXPECT_EQ(1, NotificationCount());
+
+  // 5 schedules should result in only one run.
+  for (int i = 0; i < 5; ++i)
+    notifier.Schedule();
+
+  RunForTime(base::TimeDelta::FromMilliseconds(1100));
+  EXPECT_EQ(2, NotificationCount());
+}
+
+TEST_F(DelayedUniqueNotifierTest, RescheduleDelay) {
+  DelayedUniqueNotifier notifier(
+      base::MessageLoopProxy::current(),
+      base::Bind(&DelayedUniqueNotifierTest::Notify, base::Unretained(this)),
+      base::TimeDelta::FromSeconds(1));
+
+  EXPECT_EQ(0, NotificationCount());
+
+  // Schedule for 1 second from now.
+  notifier.Schedule();
+
+  // Half a second later, we should have no runs.
+  RunForTime(base::TimeDelta::FromMilliseconds(500));
+  EXPECT_EQ(0, NotificationCount());
+
+  // Reschedule for an extra second.
+  notifier.Schedule();
+
+  // Half a second later, we should have no runs.
+  RunForTime(base::TimeDelta::FromMilliseconds(500));
+  EXPECT_EQ(0, NotificationCount());
+
+  // Reschedule for an extra second.
+  notifier.Schedule();
+
+  // Half a second later, we should have no runs.
+  RunForTime(base::TimeDelta::FromMilliseconds(500));
+  EXPECT_EQ(0, NotificationCount());
+
+  // After another 0.6 seconds, we should get a run.
+  RunForTime(base::TimeDelta::FromMilliseconds(600));
+  EXPECT_EQ(1, NotificationCount());
+}
+
+}  // namespace
+}  // namespace cc