Add sequential dispatching for InitializationRunner

ios/chrome/app/deferred_initialization_runner_unittest.mm

Index: ios/chrome/app/deferred_initialization_runner_unittest.mm
diff --git a/ios/chrome/app/deferred_initialization_runner_unittest.mm b/ios/chrome/app/deferred_initialization_runner_unittest.mm
new file mode 100644
index 0000000000000000000000000000000000000000..f5da514bf13bcb7826999594ff804f880ce0920d
--- /dev/null
+++ b/ios/chrome/app/deferred_initialization_runner_unittest.mm
@@ -0,0 +1,145 @@
+// Copyright 2016 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.
+
+#import "ios/chrome/app/deferred_initialization_runner.h"
+
+#import "base/test/ios/wait_util.h"
+#include "base/time/time.h"
+#include "testing/platform_test.h"
+
+TEST(DeferredInitializationRunnerTest, TestSharedInstance) {
+  EXPECT_TRUE([DeferredInitializationRunner sharedInstance]);
+  // Cancelling a non-existing block does nothing.
+  [[DeferredInitializationRunner sharedInstance]
+      cancelBlockNamed:@"Invalid Name"];
+}
+
+TEST(DeferredInitializationRunnerTest, TestRunBlockSequentially) {
+  // Setup.
+  __block BOOL firstFlag = NO;
+  __block BOOL secondFlag = NO;
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  ProceduralBlock firstBlock = ^() {
+    EXPECT_FALSE(firstFlag);
+    firstFlag = YES;
+  };
+  ProceduralBlock secondBlock = ^() {
+    EXPECT_FALSE(secondFlag);
+    secondFlag = YES;
+  };
+  ConditionBlock secondBlockRun = ^BOOL {
+    return secondFlag;
+  };
+  runner.delayBetweenBlocks = 0.01;
+
+  [runner enqueueBlockNamed:@"first block" block:firstBlock];
+  [runner enqueueBlockNamed:@"second block" block:secondBlock];
+
+  ASSERT_FALSE(firstFlag);
+  ASSERT_FALSE(secondFlag);
+  EXPECT_EQ(2U, [runner numberOfBlocksRemaining]);
+
+  // Action.
+  base::test::ios::WaitUntilCondition(secondBlockRun);
+
+  // Test.

[pkl (ping after 24h if needed), 2016/08/08 23:41:54]

It would be helpful to explain the expected result, i.e. "both blocks should be
executed and no additional blocks are queued on the runner."

[gambard, 2016/08/09 08:17:05]

Yes, I have adapted the old tests but I forget to add comments.
Done.

+  EXPECT_TRUE(firstFlag);
+  EXPECT_TRUE(secondFlag);
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+}
+
+TEST(DeferredInitializationRunnerTest, TestRunBlock) {
+  // Setup.
+  __block BOOL quickFlag = NO;
+  __block BOOL slowFlag = NO;
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  ProceduralBlock quickBlock = ^() {
+    EXPECT_FALSE(quickFlag);
+    quickFlag = YES;
+    // Make sure we have time to go back to this test before running the second
+    // task.
+    runner.delayBetweenBlocks = 1;

[pkl (ping after 24h if needed), 2016/08/08 23:41:54]

This will cause this unit test to take at least 1 second to run. Are there any
ways to avoid this?
As it stands now, this leaves the sharedInstance of DeferredInitializationRunner
in a state of 1 second delay for the rest of this unit test run.

What is the intent of this test that is different from TestRunBlockSequentially?

[gambard, 2016/08/09 08:17:05]

No. The 1s delay is to ensure the next block won't be run immediately. It will
be run inside the test function with |runBlockIfNecessary|.

+  };
+  ConditionBlock quickBlockRun = ^BOOL {
+    return quickFlag;
+  };
+  ProceduralBlock slowBlock = ^() {
+    EXPECT_FALSE(slowFlag);
+    slowFlag = YES;
+  };
+  runner.delayBetweenBlocks = 0.01;
+
+  // Action.
+  [runner enqueueBlockNamed:@"quick block" block:quickBlock];
+  [runner enqueueBlockNamed:@"slow block" block:slowBlock];
+
+  // Test.
+  base::test::ios::WaitUntilCondition(quickBlockRun);
+  EXPECT_TRUE(quickFlag);
+  EXPECT_FALSE(slowFlag);
+  EXPECT_EQ(1U, [runner numberOfBlocksRemaining]);
+  [runner runBlockIfNecessary:@"quick block"];
+  [runner runBlockIfNecessary:@"slow block"];
+  EXPECT_TRUE(quickFlag);
+  EXPECT_TRUE(slowFlag);
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+}
+
+TEST(DeferredInitializationRunnerTest, TestCancelBlock) {
+  // Setup.
+  __block BOOL blockFinished = NO;

[pkl (ping after 24h if needed), 2016/08/08 23:41:53]

You should set runner.delayBetweenBlocks = 0.01 here to control the test
environment.

[gambard, 2016/08/09 08:17:05]

Done.

+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  [runner enqueueBlockNamed:@"cancel me"
+                      block:^() {
+                        blockFinished = YES;
+                      }];
+  ASSERT_EQ(1U, [runner numberOfBlocksRemaining]);
+
+  // Action.
+  [runner cancelBlockNamed:@"cancel me"];
+
+  // Test.
+  EXPECT_FALSE(blockFinished);
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+}
+
+TEST(DeferredInitializationRunnerTest, TestCancelledBlockDoNothing) {
+  // Setup.
+  __block BOOL blockFinished = NO;
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  [runner enqueueBlockNamed:@"cancel me"
+                      block:^() {
+                        blockFinished = YES;
+                      }];
+
+  // Action.
+  [runner cancelBlockNamed:@"cancel me"];
+  [runner runBlockIfNecessary:@"cancel me"];
+
+  // Test.

[pkl (ping after 24h if needed), 2016/08/08 23:41:53]

Explain expected results, e.g. "Block should never be executed because it was
cancelled before it started running."

[gambard, 2016/08/09 08:17:05]

Done.

+  EXPECT_FALSE(blockFinished);
+}
+
+TEST(DeferredInitializationRunnerTest, TestSecondBlockInvalidatesFirst) {
+  // Setup.
+  __block int blockRunCount = 0;
+  ProceduralBlock runBlock = ^() {
+    ++blockRunCount;
+  };
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+
+  // Action.
+  [runner enqueueBlockNamed:@"multiple" block:runBlock];
+  [runner enqueueBlockNamed:@"multiple" block:runBlock];
+
+  // Test.

[pkl (ping after 24h if needed), 2016/08/08 23:41:54]

Explain expected results, e.g. "runBlock was executed only once, thus
blockRunCount has a value of 1."

[gambard, 2016/08/09 08:17:05]

Done.

+  [runner runBlockIfNecessary:@"multiple"];
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+  EXPECT_EQ(1, blockRunCount);
+}