iOS Cronet: Put cap on the buffer size passed to onReadCompleted delegate

components/cronet/ios/test/cronet_http_test.mm

 // Copyright 2015 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 <Cronet/Cronet.h>
 #import <Foundation/Foundation.h>
 
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 15 matching lines @@
                                    NSURLSessionTaskDelegate>
 
 // Completion semaphore for this TestDelegate. When the request this delegate is
 // attached to finishes (either successfully or with an error), this delegate
 // signals this semaphore.
 @property(assign, atomic) dispatch_semaphore_t semaphore;
 
 // Error the request this delegate is attached to failed with, if any.
 @property(retain, atomic) NSError* error;
 
+// Contains total amount of received data.
+@property(readonly) long totalBytesReceived;
+
 @end
 
 @implementation TestDelegate
+
 @synthesize semaphore = _semaphore;
 @synthesize error = _error;
+@synthesize totalBytesReceived = _totalBytesReceived;
 
 NSMutableArray<NSData*>* _responseData;
 
 - (id)init {
   if (self = [super init]) {
     _semaphore = dispatch_semaphore_create(0);
   }
   return self;
 }
 
 - (void)dealloc {
   dispatch_release(_semaphore);
   [_error release];
   _error = nil;
   [super dealloc];
 }
 
 - (void)reset {
   [_responseData dealloc];
   _responseData = nil;
   _error = nil;
+  _totalBytesReceived = 0;
 }
 
 - (NSString*)responseBody {
   if (_responseData == nil) {
     return nil;
   }
   NSMutableString* body = [NSMutableString string];
   for (NSData* data in _responseData) {
     [body appendString:[[NSString alloc] initWithData:data
                                              encoding:NSUTF8StringEncoding]];
@@ skipping 27 matching lines @@
               dataTask:(NSURLSessionDataTask*)dataTask
     didReceiveResponse:(NSURLResponse*)response
      completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))
                            completionHandler {
   completionHandler(NSURLSessionResponseAllow);
 }
 
 - (void)URLSession:(NSURLSession*)session
           dataTask:(NSURLSessionDataTask*)dataTask
     didReceiveData:(NSData*)data {
+  _totalBytesReceived += [data length];
   if (_responseData == nil) {
     _responseData = [[NSMutableArray alloc] init];
   }
   [_responseData addObject:data];
 }
 
 - (void)URLSession:(NSURLSession*)session
              dataTask:(NSURLSessionDataTask*)dataTask
     willCacheResponse:(NSCachedURLResponse*)proposedResponse
     completionHandler:
@@ skipping 77 matching lines @@
   }];
   StartDataTaskAndWaitForCompletion(task);
   EXPECT_TRUE(block_used);
   EXPECT_EQ(nil, [delegate_ error]);
   EXPECT_STREQ(grpc_support::kSimpleBodyValue,
                base::SysNSStringToUTF8([delegate_ responseBody]).c_str());
 }
 
 TEST_F(HttpTest, NSURLSessionReceivesBigHttpDataLoop) {
   int iterations = 50;
   long size = 10 * 1024 * 1024;

[lilyhoughton, 2017/05/05 16:33:05]

Where does this number come from?

[kapishnikov, 2017/05/05 19:13:42]

This is an arbitrary size of the response that we use for testing. The higher
number would make the test run longer and consume more RAM. The lower number
would give us less precision when we try to measure the elapsed time.

   LOG(INFO) << "Downloading " << size << " bytes " << iterations << " times.";
   NSTimeInterval elapsed_avg = 0;
   NSTimeInterval elapsed_max = 0;
   NSURL* url = net::NSURLWithGURL(GURL(TestServer::PrepareBigDataURL(size)));
   for (int i = 0; i < iterations; ++i) {
     [delegate_ reset];
     __block BOOL block_used = NO;
     NSURLSessionDataTask* task = [session_ dataTaskWithURL:url];
     [Cronet setRequestFilterBlock:^(NSURLRequest* request) {
       block_used = YES;
       EXPECT_EQ([request URL], url);
       return YES;
     }];
     NSDate* start = [NSDate date];
     StartDataTaskAndWaitForCompletion(task);
     NSTimeInterval elapsed = -[start timeIntervalSinceNow];
     elapsed_avg += elapsed;
     if (elapsed > elapsed_max)
       elapsed_max = elapsed;
     EXPECT_TRUE(block_used);
     EXPECT_EQ(nil, [delegate_ error]);
+    EXPECT_EQ(size, [delegate_ totalBytesReceived]);
   }
   // Release the response buffer.
   TestServer::ReleaseBigDataURL();
   LOG(INFO) << "Elapsed Average:" << elapsed_avg * 1000 / iterations
             << "ms Max:" << elapsed_max * 1000 << "ms";
 }
 
 TEST_F(HttpTest, GetGlobalMetricsDeltas) {
   NSData* delta1 = [Cronet getGlobalMetricsDeltas];
 
@@ skipping 224 matching lines @@
   [Cronet setRequestFilterBlock:^(NSURLRequest* request) {
     EXPECT_TRUE(false) << "Block should not be called for unsupported requests";
     return YES;
   }];
   StartDataTaskAndWaitForCompletion(task);
   EXPECT_EQ(nil, [delegate_ error]);
   EXPECT_TRUE([[delegate_ responseBody] containsString:testString]);
 }
 
 }  // namespace cronet