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..9fefe1a6d2af8970b4b13878790fc58dc2eac286
--- /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"
+
+#include "base/time/time.h"
+#include "testing/platform_test.h"
+#import "base/test/ios/wait_util.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.
+  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;
+  };
+  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;
+  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.
+  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.
+  [runner runBlockIfNecessary:@"multiple"];
+  EXPECT_EQ(0U, [runner numberOfBlocksRemaining]);
+  EXPECT_EQ(1, blockRunCount);
+}