cc: Add UniqueNotifier to cc/base.

cc/base/delayed_unique_notifier_unittest.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 "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 {
+    notification_count_ = 0;
+    last_notification_time_ = base::TimeTicks();
+  }
+
+  void Notify() {
+    ++notification_count_;
+    last_notification_time_ = base::TimeTicks::Now();
+  }
+
+  int NotificationCount() const { return notification_count_; }
+
+  base::TimeTicks LastNotificationTime() const {
+    return last_notification_time_;
+  }
+
+  void RunForTime(base::TimeDelta delay) {

[vmpstr, 2014/05/27 18:14:59]

Note that base::RunLoop().RunUntilIdle() doesn't seem to handle delayed tasks,
so this is still needed.

[reveman, 2014/05/27 19:02:17]

How about changing Notify() to quit the message loop when notification_count_
reached expected_notification_count_? This function becomes "void Run()" and it
can post a 5 sec delayed task that should never run under normal circumstances
but makes sure the test doesn't lock up completely when things are so broken
that notifications never happen.

This way we're not wasting time waiting past the last notification.

[vmpstr, 2014/05/27 19:25:49]

Done.

+    base::RunLoop run_loop;
+    base::MessageLoopProxy::current()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), delay);
+    run_loop.Run();
+  }
+
+ protected:
+  int notification_count_;
+  base::TimeTicks last_notification_time_;
+};
+
+TEST_F(DelayedUniqueNotifierTest, HalfSecondDelay) {
+  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(500);

[reveman, 2014/05/27 19:02:17]

Could this delay be 0 or TimeDelta::FromInternalValue(1)? Half a second is a
long time to wait for this test to run. Ideally it wouldn't rely on a real delay
at all.

[vmpstr, 2014/05/27 19:25:49]

Set to to FromInternalValue(1)

+  base::TimeDelta run_delay = base::TimeDelta::FromMilliseconds(600);

[vmpstr, 2014/05/27 18:14:59]

This is a delay just so if we schedule on the same instance as we run for time,
the order is determined. 

I believe this is test is now thread scheduling independent, but please take a
close look to see if you can spot some cases where I might be wrong.

[reveman, 2014/05/27 19:02:17]

My suggestion above would allow you to remove the run_delay part. Please
consider that.

[vmpstr, 2014/05/27 19:25:49]

Done.

+  DelayedUniqueNotifier notifier(
+      base::MessageLoopProxy::current(),
+      base::Bind(&DelayedUniqueNotifierTest::Notify, base::Unretained(this)),
+      delay);
+
+  EXPECT_EQ(0, NotificationCount());
+
+  // Basic schedule for 0.5 seconds from now.
+  base::TimeTicks expected_time = base::TimeTicks::Now() + delay;
+  notifier.Schedule();
+
+  // Expect that we ran only once at least |delay| from now.
+  RunForTime(run_delay);
+  EXPECT_EQ(1, NotificationCount());
+  EXPECT_GE(LastNotificationTime(), expected_time);
+
+  // 5 schedules should result in only one run.
+  for (int i = 0; i < 5; ++i) {
+    expected_time = base::TimeTicks::Now() + delay;
+    notifier.Schedule();
+  }
+
+  RunForTime(run_delay);
+  EXPECT_EQ(2, NotificationCount());
+  EXPECT_GE(LastNotificationTime(), expected_time);
+}
+
+TEST_F(DelayedUniqueNotifierTest, RescheduleDelay) {
+  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(500);
+  base::TimeDelta run_delay = base::TimeDelta::FromMilliseconds(600);
+  DelayedUniqueNotifier notifier(
+      base::MessageLoopProxy::current(),
+      base::Bind(&DelayedUniqueNotifierTest::Notify, base::Unretained(this)),
+      delay);
+
+  EXPECT_EQ(0, NotificationCount());
+
+  // Schedule constantly for some large number of times, so that the expected
+  // time goes beyond |delay| from now by some more or less considerable time.
+  base::TimeTicks expected_time;
+  for (int i = 0; i < 100000; ++i) {

[vmpstr, 2014/05/27 18:14:59]

I could do some sort of a sleep here (as long as I don't let the runloop run).
Let me know if you prefer that, but I don't really like having sleep in tests.
This might be an exception.

[reveman, 2014/05/27 19:02:17]

100000 seems a bit random. Maybe we can just busy loop until TimeTicks::Now() is
some amount greater than the initial value instead?

[vmpstr, 2014/05/27 19:25:49]

Done.

+    expected_time = base::TimeTicks::Now() + delay;
+    notifier.Schedule();
+  }
+
+  // Finish running and expect only one run.
+  RunForTime(run_delay);
+  EXPECT_EQ(1, NotificationCount());
+
+  EXPECT_GE(LastNotificationTime(), expected_time);
+}
+
+TEST_F(DelayedUniqueNotifierTest, Cancel) {
+  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(500);
+  base::TimeDelta run_delay = base::TimeDelta::FromMilliseconds(600);
+  DelayedUniqueNotifier notifier(
+      base::MessageLoopProxy::current(),
+      base::Bind(&DelayedUniqueNotifierTest::Notify, base::Unretained(this)),
+      delay);
+
+  EXPECT_EQ(0, NotificationCount());
+
+  // Schedule for |delay| seconds from now.
+  notifier.Schedule();
+
+  // Cancel the run.
+  notifier.Cancel();
+
+  RunForTime(run_delay);
+  EXPECT_EQ(0, NotificationCount());
+
+  // Schedule for |delay| seconds from now and let it run.
+  base::TimeTicks expected_time = base::TimeTicks::Now() + delay;
+  notifier.Schedule();
+
+  RunForTime(run_delay);
+  EXPECT_EQ(1, NotificationCount());
+  EXPECT_GE(LastNotificationTime(), expected_time);
+
+  // Schedule for |delay| seconds from now.
+  notifier.Schedule();
+
+  // Cancel the run again.
+  notifier.Cancel();
+
+  RunForTime(run_delay);
+  EXPECT_EQ(1, NotificationCount());
+}
+}  // namespace
+}  // namespace cc