Remove support for a URLRequest having a NULL Delegate.

ios/web/net/request_tracker_impl_unittest.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.
 
 #include "ios/web/net/request_tracker_impl.h"
 
 #include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
+#include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ios/web/public/cert_policy.h"
 #include "ios/web/public/certificate_policy_cache.h"
 #include "ios/web/public/ssl_status.h"
 #include "ios/web/public/test/test_browser_state.h"
 #include "ios/web/public/test/test_web_thread.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/http_response_headers.h"
@@ skipping 95 matching lines @@
   // Nothing yet.
 }
 
 @end
 
 namespace {
 
 // Used and incremented each time a tabId is created.
 int g_count = 0;
 
+// URLRequest::Delegate that does nothing.
+class DummyURLRequestDelegate : public net::URLRequest::Delegate {
+ public:
+  DummyURLRequestDelegate() {}
+  ~DummyURLRequestDelegate() override {}
+
+  void OnResponseStarted(net::URLRequest* request) override {}
+  void OnReadCompleted(net::URLRequest* request, int bytes_read) override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DummyURLRequestDelegate);
+};
+
 class RequestTrackerTest : public PlatformTest {
  public:
   RequestTrackerTest()
       : loop_(base::MessageLoop::TYPE_IO),
         ui_thread_(web::WebThread::UI, &loop_),
         io_thread_(web::WebThread::IO, &loop_){};
 
   ~RequestTrackerTest() override {}
 
   void SetUp() override {
@@ skipping 98 matching lines @@
  private:
   net::URLRequest* GetInternalRequest(size_t i, bool secure) {
     GURL url;
     if (secure)
       url = GetSecureURL(requests_.size());
     else
       url = GetURL(requests_.size());
 
     while (i >= requests_.size()) {
       contexts_.push_back(new net::URLRequestContext());
-      requests_.push_back(contexts_[i]->CreateRequest(url,
-                                                      net::DEFAULT_PRIORITY,
-                                                      NULL).release());
+      requests_.push_back(
+          contexts_[i]
+              ->CreateRequest(url, net::DEFAULT_PRIORITY, &request_delegate_)
+              .release());
 
       if (secure) {
         // Put a valid SSLInfo inside
         net::HttpResponseInfo* response =
             const_cast<net::HttpResponseInfo*>(&requests_[i]->response_info());
 
         response->ssl_info.cert = new net::X509Certificate(
             "subject", "issuer",
             base::Time::Now() - base::TimeDelta::FromDays(2),
             base::Time::Now() + base::TimeDelta::FromDays(2));
         response->ssl_info.cert_status = 0;  // No errors.
         response->ssl_info.security_bits = 128;
 
         EXPECT_TRUE(requests_[i]->ssl_info().is_valid());
       }
     }
     EXPECT_TRUE(!secure == !requests_[i]->url().SchemeIsCryptographic());
     return requests_[i];
   }
 
+  DummyURLRequestDelegate request_delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(RequestTrackerTest);
 };
 
 TEST_F(RequestTrackerTest, OnePage) {
   // Start a request.
   tracker_->StartRequest(GetRequest(0));
   // Start page load.
   TrimRequest(request_group_id_, GetURL(0));
   EXPECT_NSEQ(nil, CheckActive());
 
@@ skipping 214 matching lines @@
                                   base::Bind(&TwoStartsSSLCallback,
                                              &request_0_called));
   tracker_->OnSSLCertificateError(GetSecureRequest(1), ssl_info, true,
                                   base::Bind(&TwoStartsSSLCallback,
                                              &request_1_called));
   EXPECT_TRUE(request_0_called);
   EXPECT_TRUE(request_1_called);
 }
 
 }  // namespace