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"
 
+namespace {
+// Interval between two blocks.
+const NSTimeInterval kDelayBetweenBlock = 0.2;

[gambard, 2016/08/05 09:47:57]

There are 18 current calls to this class ranging from 0.1 to 6 seconds.
This will execute the calls from 0.2 to 3.6 seconds.

+}  // namespace
+
 // 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;
 }
 
+// Schedule the next block to be run after |kDelayBetweenBlock|.
+- (void)scheduleNextBlock;
+
+@end
+
+@implementation DeferredInitializationRunner
+
 + (DeferredInitializationRunner*)sharedInstance {
   static DeferredInitializationRunner* 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;
+  }
   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)(kDelayBetweenBlock * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     [nextBlock run];
+                     [self scheduleNextBlock];
+                   });
+
+    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