Allows deferral of a URLRequest just before talking to the network, at

net/url_request/url_request.h

 // Copyright (c) 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 256 matching lines @@
     // ContinueDespiteLastError().  cert_error is a ERR_* error code
     // indicating what's wrong with the certificate.
     // If |fatal| is true then the host in question demands a higher level
     // of security (due e.g. to HTTP Strict Transport Security, user
     // preference, or built-in policy). In this case, errors must not be
     // bypassable by the user.
     virtual void OnSSLCertificateError(URLRequest* request,
                                        const SSLInfo& ssl_info,
                                        bool fatal);
 
+    // Called to notify that the request must use the network to complete the
+    // request and is about to do so. This is called at most once per
+    // URLRequest, and by default does not defer. If deferred, call
+    // ResumeNetworkStart() to continue or Cancel() to cancel.
+    virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer);
+
     // After calling Start(), the delegate will receive an OnResponseStarted
     // callback when the request has completed.  If an error occurred, the
     // request->status() will be set.  On success, all redirects have been
     // followed and the final response is beginning to arrive.  At this point,
     // meta data about the response is available, including for example HTTP
     // response headers if this is a request for a HTTP resource.
     virtual void OnResponseStarted(URLRequest* request) = 0;
 
     // Called when the a Read of the response body is completed after an
     // IO_PENDING status from a Read() call.
@@ skipping 328 matching lines @@
   // Note that this method has no effect on other (simultaneous or not) requests
   // for the same resource. The typical example is a request that results in
   // the data being stored to disk (downloaded instead of rendered) so we don't
   // want to store it twice.
   void StopCaching();
 
   // This method may be called to follow a redirect that was deferred in
   // response to an OnReceivedRedirect call.
   void FollowDeferredRedirect();
 
+  // This method must be called to resume network communications that were
+  // deferred in response to an OnBeforeNetworkStart call.
+  void ResumeNetworkStart();
+
   // One of the following two methods should be called in response to an
   // OnAuthRequired() callback (and only then).
   // SetAuth will reissue the request with the given credentials.
   // CancelAuth will give up and display the error page.
   void SetAuth(const AuthCredentials& credentials);
   void CancelAuth();
 
   // This method can be called after the user selects a client certificate to
   // instruct this URLRequest to continue with the request with the
   // certificate.  Pass NULL if the user doesn't have a client certificate.
@@ skipping 47 matching lines @@
   // Allow the URLRequestJob class to set our status too
   void set_status(const URLRequestStatus& value) { status_ = value; }
 
   // Allow the URLRequestJob to redirect this request.  Returns OK if
   // successful, otherwise an error code is returned.
   int Redirect(const GURL& location, int http_status_code);
 
   // Called by URLRequestJob to allow interception when a redirect occurs.
   void NotifyReceivedRedirect(const GURL& location, bool* defer_redirect);
 
+  // Called by URLRequestHttpJob (note, only HTTP(S) jobs will call this) to
+  // allow deferral of network initialization.
+  void NotifyBeforeNetworkStart(bool* defer);
+
   // Allow an interceptor's URLRequestJob to restart this request.
   // Should only be called if the original job has not started a response.
   void Restart();
 
  private:
   friend class URLRequestJob;
+  friend class URLRequestHttpJob;

[mmenke, 2014/01/07 19:44:05]

I don't think this is needed.

[jkarlin, 2014/01/07 20:10:03]

Done.

 
   // Registers a new protocol handler for the given scheme. If the scheme is
   // already handled, this will overwrite the given factory. To delete the
   // protocol factory, use NULL for the factory BUT this WILL NOT put back
   // any previously registered protocol factory. It will have returned
   // the previously registered factory (or NULL if none is registered) when
   // the scheme was first registered so that the caller can manually put it
   // back if desired.
   //
   // The scheme must be all-lowercase ASCII. See the ProtocolFactory
@@ skipping 164 matching lines @@
   int64 received_response_content_length_;
 
   base::TimeTicks creation_time_;
 
   // Timing information for the most recent request.  Its start times are
   // populated during Start(), and the rest are populated in OnResponseReceived.
   LoadTimingInfo load_timing_info_;
 
   scoped_ptr<const base::debug::StackTrace> stack_trace_;
 
+  // Keeps track of whether or not OnBeforeNetworkStart has been called yet.
+  bool notified_before_network_start_;
+
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_