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

net/url_request/url_request.cc

 // 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.
 
 #include "net/url_request/url_request.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 180 matching lines @@
     SSLCertRequestInfo* cert_request_info) {
   request->Cancel();
 }
 
 void URLRequest::Delegate::OnSSLCertificateError(URLRequest* request,
                                                  const SSLInfo& ssl_info,
                                                  bool is_hsts_ok) {
   request->Cancel();
 }
 
+void URLRequest::Delegate::OnBeforeNetworkStart(URLRequest* request,
+                                                bool* defer) {
+  *defer = false;

[mmenke, 2014/01/07 15:26:23]

"OnReceivedRedirect" assumes defer is initialized to false.  I think we should
be consistent - and having it auto-initialized seems safer to me.

[jkarlin, 2014/01/07 16:19:32]

Done.

+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest
 
 URLRequest::URLRequest(const GURL& url,
                        RequestPriority priority,
                        Delegate* delegate,
                        const URLRequestContext* context)
     : context_(context),
       network_delegate_(context->network_delegate()),
       net_log_(BoundNetLog::Make(context->net_log(),
                                  NetLog::SOURCE_URL_REQUEST)),
       url_chain_(1, url),
       method_("GET"),
       referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       is_redirecting_(false),
       redirect_limit_(kMaxRedirects),
       priority_(priority),
       identifier_(GenerateURLRequestIdentifier()),
       calling_delegate_(false),
       use_blocked_by_as_load_param_(false),
       before_request_callback_(base::Bind(&URLRequest::BeforeRequestComplete,
                                           base::Unretained(this))),
       has_notified_completion_(false),
       received_response_content_length_(0),
-      creation_time_(base::TimeTicks::Now()) {
+      creation_time_(base::TimeTicks::Now()),
+      notified_before_network_start_(false) {
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
   // Sanity check out environment.
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
 
   CHECK(context);
   context->url_requests()->insert(this);
 
   net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
@@ skipping 578 matching lines @@
           this, network_delegate_, location);
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     OnCallToDelegate();
     delegate_->OnReceivedRedirect(this, location, defer_redirect);
     // |this| may be have been destroyed here.
   }
 }
 
+void URLRequest::NotifyBeforeNetworkStart(bool* defer) {
+  if (delegate_ && !notified_before_network_start_) {
+    notified_before_network_start_ = true;
+    OnCallToDelegate();
+    delegate_->OnBeforeNetworkStart(this, defer);
+    if (!(*defer))

[mmenke, 2014/01/07 15:26:23]

optional nit:  I think !*defer is more common in net, though it's not exactly
common.  If you think this is clearer, I don't feel particularly strongly about
it.

[jkarlin, 2014/01/07 16:19:32]

Done.

+      OnCallToDelegateComplete();
+  }
+}
+
+void URLRequest::ResumeNetworkStart() {
+  DCHECK(job_);

[mmenke, 2014/01/07 15:26:23]

Maybe DCHECK(notified_network_create_stream_);?

I'd also suggest setting notified_network_create_stream_ to true after the call
into the delegate, to make the DCHECK trigger on re-entrancy.  I don't believe
the ResumeNetworkCreateStream DCHECK will trigger in that case, and I'd like to
have some protection against it, at least in debug builds.

We could try and handle that case, but I don't think there's a reason to.

[jkarlin, 2014/01/07 16:19:32]

Done.

+  OnCallToDelegateComplete();
+  job_->ResumeNetworkStart();
+}
+
 void URLRequest::NotifyResponseStarted() {
   int net_error = OK;
   if (!status_.is_success())
     net_error = status_.error();
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_URL_REQUEST_START_JOB,
                                     net_error);
 
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptResponse(
           this, network_delegate_);
@@ skipping 366 matching lines @@
       new base::debug::StackTrace(NULL, 0);
   *stack_trace_copy = stack_trace;
   stack_trace_.reset(stack_trace_copy);
 }
 
 const base::debug::StackTrace* URLRequest::stack_trace() const {
   return stack_trace_.get();
 }
 
 }  // namespace net