Set network_accessed earlier, when network transaction creates stream.

net/http/http_network_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_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 377 matching lines @@
 int64 HttpNetworkTransaction::GetTotalReceivedBytes() const {
   int64 total_received_bytes = total_received_bytes_;
   if (stream_)
     total_received_bytes += stream_->GetTotalReceivedBytes();
   return total_received_bytes;
 }
 
 void HttpNetworkTransaction::DoneReading() {}
 
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
-  return ((headers_valid_ && response_.headers.get()) ||
-          response_.ssl_info.cert.get() || response_.cert_request_info.get())
-             ? &response_
-             : NULL;
+  return &response_;

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

With this, except for FailingHttpTransaction, GetResponseInfo never returns
NULL. How about fixing that one and changing the documentation of
HttpTransaction to not return NULL? Also document that it may only be called
after Start() completes.

Also mention in the commit message that we're changing the meaning of
GetResponseInfo slightly.

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

Done.

 }
 
 LoadState HttpNetworkTransaction::GetLoadState() const {
   // TODO(wtc): Define a new LoadState value for the
   // STATE_INIT_CONNECTION_COMPLETE state, which delays the HTTP request.
   switch (next_state_) {
     case STATE_CREATE_STREAM:
       return LOAD_STATE_WAITING_FOR_DELEGATE;
     case STATE_CREATE_STREAM_COMPLETE:
       return stream_request_->GetLoadState();
@@ skipping 317 matching lines @@
     return OK;
   return ERR_IO_PENDING;
 }
 
 int HttpNetworkTransaction::DoCreateStream() {
   // TODO(mmenke): Remove ScopedTracker below once crbug.com/424359 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "424359 HttpNetworkTransaction::DoCreateStream"));
 
+  response_.network_accessed = true;
+
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
   if (ForWebSocketHandshake()) {
     stream_request_.reset(
         session_->http_stream_factory_for_websocket()
             ->RequestWebSocketHandshakeStream(
                   *request_,
                   priority_,
                   server_ssl_config_,
                   proxy_ssl_config_,
                   this,
@@ skipping 218 matching lines @@
   send_start_time_ = base::TimeTicks::Now();
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
 
   return stream_->SendRequest(request_headers_, &response_, io_callback_);
 }
 
 int HttpNetworkTransaction::DoSendRequestComplete(int result) {
   send_end_time_ = base::TimeTicks::Now();
   if (result < 0)
     return HandleIOError(result);
-  response_.network_accessed = true;
   next_state_ = STATE_READ_HEADERS;
   return OK;
 }
 
 int HttpNetworkTransaction::DoReadHeaders() {
   next_state_ = STATE_READ_HEADERS_COMPLETE;
   return stream_->ReadResponseHeaders(io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
@@ skipping 631 matching lines @@
   DCHECK(stream_request_);
 
   // Since the transaction can restart with auth credentials, it may create a
   // stream more than once. Accumulate all of the connection attempts across
   // those streams by appending them to the vector:
   for (const auto& attempt : stream_request_->connection_attempts())
     connection_attempts_.push_back(attempt);
 }
 
 }  // namespace net