HttpCache::Transaction layer allowing parallel validation

net/http/http_transaction_test_util.cc

 // Copyright 2014 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/http/http_transaction_test_util.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
@@ skipping 391 matching lines @@
 // static
 const int64_t MockNetworkTransaction::kTotalSentBytes = 100;
 
 int MockNetworkTransaction::StartInternal(const HttpRequestInfo* request,
                                           const CompletionCallback& callback,
                                           const NetLogWithSource& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return ERR_FAILED;
 
-  if (!before_network_start_callback_.is_null()) {
-    bool defer = false;
-    before_network_start_callback_.Run(&defer);
-    if (defer)
-      return net::ERR_IO_PENDING;
-  }
-
   test_mode_ = t->test_mode;
 
   // Return immediately if we're returning an error.
   if (OK != t->return_code) {
     if (test_mode_ & TEST_MODE_SYNC_NET_START)
       return t->return_code;
     CallbackLater(callback, t->return_code);
     return ERR_IO_PENDING;
   }
 
@@ skipping 30 matching lines @@
   response_.ssl_info.connection_status = t->ssl_connection_status;
   data_ = resp_data;
   content_length_ = response_.headers->GetContentLength();
 
   if (net_log.net_log())
     socket_log_id_ = net_log.net_log()->NextID();
 
   if (request_->load_flags & LOAD_PREFETCH)
     response_.unused_since_prefetch = true;
 
+  // Pause and resume.
+  if (!before_network_start_callback_.is_null()) {
+    bool defer = false;
+    before_network_start_callback_.Run(&defer);
+    if (defer) {
+      callback_ = callback;
+      return net::ERR_IO_PENDING;
+    }
+  }
+
   if (test_mode_ & TEST_MODE_SYNC_NET_START)
     return OK;
 
   CallbackLater(callback, OK);
   return ERR_IO_PENDING;
 }
 
 void MockNetworkTransaction::SetBeforeNetworkStartCallback(
     const BeforeNetworkStartCallback& callback) {
   before_network_start_callback_ = callback;
 }
 
 void MockNetworkTransaction::SetBeforeHeadersSentCallback(
     const BeforeHeadersSentCallback& callback) {}
 
 int MockNetworkTransaction::ResumeNetworkStart() {
-  // Should not get here.
-  return ERR_FAILED;
+  DCHECK(!callback_.is_null());
+  CallbackLater(callback_, OK);
+  return ERR_IO_PENDING;
+}
+
+// static
+void MockNetworkTransaction::DeferNetworkStart(bool* defer) {

[Randy Smith (Not in Mondays), 2017/04/11 19:56:45]

nit, suggestion: This function seems trivial enough that I'd be inclined to say
that tests that want this functionality can put it in the test file; I don't
think it's worth adding cruft to the MockNetworkTransaction interface to have it
centrally.

[shivanisha, 2017/04/12 16:46:03]

done

+  *defer = true;
 }
 
 void MockNetworkTransaction::GetConnectionAttempts(
     ConnectionAttempts* out) const {
   NOTIMPLEMENTED();
 }
 
 void MockNetworkTransaction::CallbackLater(const CompletionCallback& callback,
                                            int result) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 81 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net