Add sequential dispatching for InitializationRunner

ios/chrome/app/deferred_initialization_runner.mm

 // Copyright 2012 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 <stdint.h>
 
 #include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
 
 // An object encapsulating the deferred execution of a block of initialization
 // code.
 @interface DeferredInitializationBlock : NSObject {
   // A string to reference the initialization block.
   base::scoped_nsobject<NSString> _name;
   // A block of code to execute.
   base::scoped_nsprotocol<ProceduralBlock> _runBlock;
 }
 
+- (instancetype)init NS_UNAVAILABLE;
+
 // Designated initializer.
-- (id)initWithName:(NSString*)name block:(ProceduralBlock)block;
+- (instancetype)initWithName:(NSString*)name
+                       block:(ProceduralBlock)block NS_DESIGNATED_INITIALIZER;
 
 // Dispatches the deferred execution the block after |delaySeconds|.
+// Deprecated.
 - (void)dispatch:(NSTimeInterval)delaySeconds;
 
 // Executes the deferred block now.
-- (void)runSynchronously;
+- (void)run;
 
 // Cancels the block's execution.
 - (void)cancel;
+
 @end
 
 @implementation DeferredInitializationBlock
 
 // Overrides default designated initializer.
-- (id)init {
+- (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
-- (id)initWithName:(NSString*)name block:(ProceduralBlock)block {
+- (void)dispatch:(NSTimeInterval)delaySeconds {
+  int64_t nanoseconds = delaySeconds * NSEC_PER_SEC;
+  DCHECK([NSThread isMainThread]);
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, nanoseconds),
+                 dispatch_get_main_queue(), ^() {
+                   [self run];
+                 });
+}
+
+- (instancetype)initWithName:(NSString*)name block:(ProceduralBlock)block {
   DCHECK(block);
   self = [super init];
   if (self) {
     _name.reset([name copy]);
     _runBlock.reset([block copy]);
   }
   return self;
 }
 
-- (void)dispatch:(NSTimeInterval)delaySeconds {
-  int64_t nanoseconds = delaySeconds * NSEC_PER_SEC;
-  DCHECK([NSThread isMainThread]);
-  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, nanoseconds),
-                 dispatch_get_main_queue(), ^() {
-                   [self runSynchronously];
-                 });
-}
-
-- (void)runSynchronously {
+- (void)run {
   ProceduralBlock deferredBlock = _runBlock.get();
   if (!deferredBlock)
     return;
   deferredBlock();
   [[DeferredInitializationRunner sharedInstance] cancelBlockNamed:_name];
 }
 
 - (void)cancel {
   _runBlock.reset();
 }
 
 @end
 
-@implementation DeferredInitializationRunner {
+@interface DeferredInitializationRunner () {
+  base::scoped_nsobject<NSMutableArray> _blocksNameQueue;
   base::scoped_nsobject<NSMutableDictionary> _runBlocks;
+  BOOL isBlockScheduled;

[rohitrao (ping after 24h), 2016/08/08 14:07:23]

Should this be _isBlockScheduled?

[gambard, 2016/08/08 15:02:10]

Done.

 }
 
+// Schedule the next block to be run after |kDelayBetweenBlock|.
+- (void)scheduleNextBlock;
+
+@end
+
+@implementation DeferredInitializationRunner
+
+@synthesize delayBetweenBlocks = _delayBetweenBlocks;
+
 + (DeferredInitializationRunner*)sharedInstance {
-  static DeferredInitializationRunner* instance =
-      [[DeferredInitializationRunner alloc] init];
+  static dispatch_once_t once = 0;
+  static DeferredInitializationRunner* instance = nil;
+  dispatch_once(&once, ^{
+    instance = [[DeferredInitializationRunner alloc] init];
+  });
   return instance;
 }
 
 - (id)init {
   self = [super init];
-  if (self)
+  if (self) {
+    _blocksNameQueue.reset([[NSMutableArray array] retain]);
     _runBlocks.reset([[NSMutableDictionary dictionary] retain]);
+    isBlockScheduled = NO;
+    _delayBetweenBlocks = 0.2;
+  }
   return self;
 }
 
+- (void)enqueueBlockNamed:(NSString*)name block:(ProceduralBlock)block {
+  DCHECK(name);
+  [self cancelBlockNamed:name];
+  [_blocksNameQueue addObject:name];
+
+  base::scoped_nsobject<DeferredInitializationBlock> deferredBlock(
+      [[DeferredInitializationBlock alloc] initWithName:name block:block]);
+  [_runBlocks setObject:deferredBlock forKey:name];
+
+  if (!isBlockScheduled) {
+    [self scheduleNextBlock];
+  }
+}
+
+- (void)scheduleNextBlock {
+  isBlockScheduled = NO;
+  if ([_blocksNameQueue count] > 0) {
+    NSString* nextBlockName = [_blocksNameQueue firstObject];
+
+    DeferredInitializationBlock* nextBlock =
+        [_runBlocks objectForKey:nextBlockName];
+    DCHECK(nextBlock);
+
+    dispatch_after(
+        dispatch_time(DISPATCH_TIME_NOW,
+                      (int64_t)(self.delayBetweenBlocks * NSEC_PER_SEC)),
+        dispatch_get_main_queue(), ^{
+          [nextBlock run];
+          [self scheduleNextBlock];

[rohitrao (ping after 24h), 2016/08/08 14:07:23]

Is there any chance that retaining |self| could cause issues?  For example, if
we somehow managed to trigger shutdown before all of the blocks had finished
executing?

(I'm guessing not, because DeferredInitializationRunning is already a singleton,
so retaining self can't make it live any longer than it already does.)

[gambard, 2016/08/08 15:02:10]

As it was a singleton I thought it would be ok to use a strong reference. I have
changed it to a weak self.

+        });
+
+    isBlockScheduled = YES;
+    [_blocksNameQueue removeObjectAtIndex:0];
+  }
+}
+
 - (void)runBlockNamed:(NSString*)name
                 after:(NSTimeInterval)delaySeconds
                 block:(ProceduralBlock)block {
   DCHECK(name);
   // Safety check in case this function is called with a nanosecond or
   // microsecond parameter by mistake.
   DCHECK(delaySeconds < 3600.0);
   // Cancels the previously scheduled block, if there is one, so this
   // |name| block will not be run more than once.
   [[_runBlocks objectForKey:name] cancel];
   base::scoped_nsobject<DeferredInitializationBlock> deferredBlock(
       [[DeferredInitializationBlock alloc] initWithName:name block:block]);
   [_runBlocks setObject:deferredBlock forKey:name];
   [deferredBlock dispatch:delaySeconds];
 }
 
 - (void)runBlockIfNecessary:(NSString*)name {
-  [[_runBlocks objectForKey:name] runSynchronously];
+  [[_runBlocks objectForKey:name] run];
 }
 
 - (void)cancelBlockNamed:(NSString*)name {
   DCHECK(name);
+  [_blocksNameQueue removeObject:name];
   [[_runBlocks objectForKey:name] cancel];
   [_runBlocks removeObjectForKey:name];
 }
 
 - (NSUInteger)numberOfBlocksRemaining {
   return [_runBlocks count];
 }
 
 @end