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..e5f83b037a71dfb0145c43e2d3b21441ca170f4b
--- /dev/null
+++ b/ios/chrome/app/deferred_initialization_runner_unittest.mm
@@ -0,0 +1,160 @@
+// 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"];
+}
+
+// Tests that all blocks added on the queue are executed after a delay.
+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.
+  EXPECT_TRUE(firstFlag);
+  EXPECT_TRUE(secondFlag);
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+}
+
+// Tests that runBlockIfNecessary do not execute the block if it has already
+// been executed and runs synchronously the one not executed.
+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;
+  };
+  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]);
+}
+
+// Tests that a block is not executed when canceld and it is removed from the

[pkl (ping after 24h if needed), 2016/08/09 13:22:57]

s/canceld/cancelled/

[gambard, 2016/08/19 12:16:24]

Done.

+// remaining block list.

[pkl (ping after 24h if needed), 2016/08/09 13:22:56]

s/block/blocks/

[gambard, 2016/08/19 12:16:24]

Done.

+TEST(DeferredInitializationRunnerTest, TestCancelBlock) {
+  // Setup.
+  __block BOOL blockFinished = NO;
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  runner.delayBetweenBlocks = 0.01;
+
+  [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]);
+}
+
+// Tests that a canceled block will do nothing when run by name.

[pkl (ping after 24h if needed), 2016/08/09 13:22:56]

s/canceled/cancelled/

[gambard, 2016/08/19 12:16:24]

Done.

+TEST(DeferredInitializationRunnerTest, TestCancelledBlockDoNothing) {
+  // Setup.
+  __block BOOL blockFinished = NO;
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  runner.delayBetweenBlocks = 0.01;
+
+  [runner enqueueBlockNamed:@"cancel me"
+                      block:^() {
+                        blockFinished = YES;
+                      }];
+
+  // Action.
+  [runner cancelBlockNamed:@"cancel me"];
+  [runner runBlockIfNecessary:@"cancel me"];
+
+  // Test: expect false, the block should never be executed because it was

[pkl (ping after 24h if needed), 2016/08/09 13:22:57]

The "expect false, " part seems unnecessary.

[gambard, 2016/08/19 12:16:24]

It tests that the block has not been run after being cancelled, even if it is
called by name.

+  // cancelled before it started running.
+  EXPECT_FALSE(blockFinished);
+}
+
+// Tests that adding a block with the same name as an existing block will
+// override the existing one.
+TEST(DeferredInitializationRunnerTest, TestSecondBlockInvalidatesFirst) {
+  // Setup.
+  __block int blockRunCount = 0;
+  ProceduralBlock runBlock = ^() {
+    ++blockRunCount;
+  };
+  DeferredInitializationRunner* runner =
+      [DeferredInitializationRunner sharedInstance];
+  runner.delayBetweenBlocks = 0.01;
+
+  // Action.
+  [runner enqueueBlockNamed:@"multiple" block:runBlock];
+  [runner enqueueBlockNamed:@"multiple" block:runBlock];
+
+  // Test: |runBlock| was executed only once.
+  EXPECT_EQ(1U, [runner numberOfBlocksRemaining]);
+  [runner runBlockIfNecessary:@"multiple"];
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+  EXPECT_EQ(1, blockRunCount);
+}