Set network_accessed earlier, when network transaction creates stream.

net/http/http_cache_transaction.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/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 555 matching lines @@
       cache_->DoneReadingFromEntry(entry_, this);
       entry_ = NULL;
     }
   }
 }
 
 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
   // Null headers means we encountered an error or haven't a response yet
   if (auth_response_.headers.get())
     return &auth_response_;
-  return (response_.headers.get() || response_.ssl_info.cert.get() ||
-          response_.cert_request_info.get())
-             ? &response_
-             : NULL;
+  return &response_;
 }
 
 LoadState HttpCache::Transaction::GetLoadState() const {
   LoadState state = GetWriterLoadState();
   if (state != LOAD_STATE_WAITING_FOR_CACHE)
     return state;
 
   if (cache_.get())
     return cache_->GetLoadStateForPendingTransaction(this);
 
@@ skipping 485 matching lines @@
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
   rv = network_trans_->Start(request_, io_callback_, net_log_);
   return rv;
 }
 
 int HttpCache::Transaction::DoSendRequestComplete(int result) {
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
+  const HttpResponseInfo* response = network_trans_->GetResponseInfo();
+  if (response)

[davidben, 2015/05/14 22:28:14]

This can't ever be NULL, can it? That one testing transaction aside (see
http_network_transaction.cc)

[Deprecated (see juliatuttle), 2015/05/14 23:52:10]

Not anymore, no.

+    response_.network_accessed = response->network_accessed;
+

[davidben, 2015/05/14 22:28:14]

Let's move this after line 1094. In the non-error case, we're going to handle
network_accessed already anyway and possibly need more complex logic. Also I
think this codepath kicks in for range requests and the like which might do
weirder things.

[Deprecated (see juliatuttle), 2015/05/14 23:52:10]

Done.

   // If we tried to conditionalize the request and failed, we know
   // we won't be reading from the cache after this point.
   if (couldnt_conditionalize_request_)
     mode_ = WRITE;
 
   if (result == OK) {
     next_state_ = STATE_SUCCESSFUL_SEND_REQUEST;
     return OK;
   }
 
   // Do not record requests that have network errors or restarts.
   UpdateTransactionPattern(PATTERN_NOT_COVERED);
   if (IsCertificateError(result)) {
-    const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     // If we get a certificate error, then there is a certificate in ssl_info,
     // so GetResponseInfo() should never return NULL here.
     DCHECK(response);
     response_.ssl_info = response->ssl_info;
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
-    const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     DCHECK(response);
     response_.cert_request_info = response->cert_request_info;
   } else if (response_.was_cached) {
     DoneWritingToEntry(true);
   }
+
   return result;
 }
 
 // We received the response headers and there is no error.
 int HttpCache::Transaction::DoSuccessfulSendRequest() {
   DCHECK(!new_response_);
   const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
   bool authentication_failure = false;
 
   if (new_response->headers->response_code() == 401 ||
@@ skipping 1859 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net