Create a Delayed Response Provider for GCDWebServer.

ios/web/public/test/response_providers/delayed_response_provider.mm

+// 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.
+
+#include "ios/web/public/test/response_providers/delayed_response_provider.h"
+
+#import <Foundation/Foundation.h>
+
+#import "base/mac/scoped_nsobject.h"
+#import "base/mac/foundation_util.h"
+#import "ios/third_party/gcdwebserver/src/GCDWebServer/Responses/GCDWebServerDataResponse.h"
+
+// A proxy class that will forward all messages to the |_response|.
+// It will delay read operation  |_delay| seconds.
+@interface DelayedGCDWebServerResponse : NSProxy
+
++ (instancetype)responseWithServerResponse:(GCDWebServerResponse*)response
+                                     delay:(NSTimeInterval)delay;
+- (instancetype)initWithServerResponse:(GCDWebServerResponse*)response
+                                 delay:(NSTimeInterval)delay;
+@end
+
+@implementation DelayedGCDWebServerResponse {
+  base::scoped_nsobject<GCDWebServerResponse> _response;

[marq (ping after 24h), 2016/08/29 08:16:36]

is ios/third_party on ARC yet?

[Olivier, 2016/08/29 08:48:10]

GCDWebServer is ARC, yes. Should I do something specific in that case?

[marq (ping after 24h), 2016/08/29 08:59:12]

Two things. First, there's no need to use scoped_nsobject, as object properties
are strong by default and ARC will manage releasing them on dealloc.

Second, you should add the ARC guard macro to this file, just after the last
include:

#if !defined(__has_feature) || !__has_feature(objc_arc)
#error "This file requires ARC support."
#endif

(At least, I think that's what we're doing with ARC .m files for now -- I don't
know if only some files get it or not).

[Olivier, 2016/08/29 10:42:14]

But this file is not compiled with ARC. GCDWebServerResponse is.
So adding this will result as an error.
Should I create a new target in BUILD.gn to add ARC flags?

+  NSTimeInterval _delay;
+}
+
++ (instancetype)responseWithServerResponse:(GCDWebServerResponse*)response
+                                     delay:(NSTimeInterval)delay {
+  return [[[DelayedGCDWebServerResponse alloc] initWithServerResponse:response
+                                                                delay:delay]
+      autorelease];
+}
+
+- (instancetype)initWithServerResponse:(GCDWebServerResponse*)response
+                                 delay:(NSTimeInterval)delay {
+  _response.reset([response retain]);
+  _delay = delay;
+  return self;
+}
+
+#pragma mark - GCDWebServerResponse
+
+- (void)performReadDataWithCompletion:
+    (GCDWebServerBodyReaderCompletionBlock)block {
+  [self asyncReadDataWithCompletion:block];
+}
+
+- (void)asyncReadDataWithCompletion:
+    (GCDWebServerBodyReaderCompletionBlock)block {
+  if ([_response respondsToSelector:@selector(asyncReadDataWithCompletion:)]) {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
+                                 static_cast<int64_t>(_delay * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     [_response asyncReadDataWithCompletion:block];

[marq (ping after 24h), 2016/08/29 08:16:36]

This (and the block below) guarantees that the receiver will be retained until
after the |_delay|, even if (for example) the test it was called in completes.
Is this intentional? If so, please document it. Otherwise, use a weakified
_response.

[Olivier, 2016/08/29 08:48:10]

Done.

+                   });
+  } else {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
+                                 static_cast<int64_t>(_delay * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     NSError* error = nil;
+                     NSData* data = [_response readData:&error];
+                     block(data, error);
+                   });
+  }
+}
+
+#pragma mark - NSProxy
+
+- (BOOL)conformsToProtocol:(Protocol*)protocol {
+  return [[_response class] conformsToProtocol:protocol];
+}
+
+- (BOOL)respondsToSelector:(SEL)selector {
+  return [[_response class] instancesRespondToSelector:selector];
+}
+
+- (NSMethodSignature*)methodSignatureForSelector:(SEL)selector {
+  return [[_response class] instanceMethodSignatureForSelector:selector];
+}
+
+- (void)forwardInvocation:(NSInvocation*)invocation {
+  SEL selector = [invocation selector];
+  if ([_response respondsToSelector:selector])
+    [invocation invokeWithTarget:_response];
+}
+
+@end
+
+namespace web {
+
+DelayedResponseProvider::DelayedResponseProvider(
+    std::unique_ptr<web::ResponseProvider> delayed_provider,
+    double delay)
+    : web::ResponseProvider(),
+      delayed_provider_(std::move(delayed_provider)),
+      delay_(delay) {}
+
+DelayedResponseProvider::~DelayedResponseProvider() {}
+
+bool DelayedResponseProvider::CanHandleRequest(const Request& request) {
+  return delayed_provider_->CanHandleRequest(request);
+}
+
+GCDWebServerResponse* DelayedResponseProvider::GetGCDWebServerResponse(
+    const Request& request) {
+  DelayedGCDWebServerResponse* response = [DelayedGCDWebServerResponse
+      responseWithServerResponse:delayed_provider_->GetGCDWebServerResponse(
+                                     request)
+                           delay:delay_];
+  return base::mac::ObjCCastStrict<GCDWebServerResponse>(response);
+}
+
+}  // namespace web