Propagate the remote socket address to URLRequest and to ViewHostMsg_FrameNavigate.

net/http/http_response_info.cc

 // Copyright (c) 2010 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_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time.h"
 #include "net/base/auth.h"
@@ skipping 56 matching lines @@
       was_alternate_protocol_available(false),
       was_fetched_via_proxy(false) {
 }
 
 HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs)
     : was_cached(rhs.was_cached),
       was_fetched_via_spdy(rhs.was_fetched_via_spdy),
       was_npn_negotiated(rhs.was_npn_negotiated),
       was_alternate_protocol_available(rhs.was_alternate_protocol_available),
       was_fetched_via_proxy(rhs.was_fetched_via_proxy),
+      socket_address(rhs.socket_address),
       request_time(rhs.request_time),
       response_time(rhs.response_time),
       auth_challenge(rhs.auth_challenge),
       cert_request_info(rhs.cert_request_info),
       ssl_info(rhs.ssl_info),
       headers(rhs.headers),
       vary_data(rhs.vary_data),
       metadata(rhs.metadata) {
 }
 
 HttpResponseInfo::~HttpResponseInfo() {
 }
 
 HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) {
   was_cached = rhs.was_cached;
   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
   was_npn_negotiated = rhs.was_npn_negotiated;
   was_alternate_protocol_available = rhs.was_alternate_protocol_available;
   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
+  socket_address = rhs.socket_address;
   request_time = rhs.request_time;
   response_time = rhs.response_time;
   auth_challenge = rhs.auth_challenge;
   cert_request_info = rhs.cert_request_info;
   ssl_info = rhs.ssl_info;
   headers = rhs.headers;
   vary_data = rhs.vary_data;
   metadata = rhs.metadata;
   return *this;
 }
@@ skipping 45 matching lines @@
       return false;
     ssl_info.security_bits = security_bits;
   }
 
   // read vary-data
   if (flags & RESPONSE_INFO_HAS_VARY_DATA) {
     if (!vary_data.InitFromPickle(pickle, &iter))
       return false;
   }
 
+  // Read socket_address.  This was not always present in the response info,
+  // so we don't fail if it can't be read.  If additional fields are added in
+  // a future version, then they must only be read if this operation succeeds.
+  std::string socket_address_host;
+  if (pickle.ReadString(&iter, &socket_address_host)) {
+    // If the host was written, we always expect the port to follow.
+    uint16 socket_address_port;
+    if (!pickle.ReadUInt16(&iter, &socket_address_port))
+      return false;
+    socket_address = HostPortPair(socket_address_host, socket_address_port);
+  }

[wtc, 2011/04/21 22:44:25]

We should have bumped the version number when we started to
serialize socket_address.

[Brian Ryner, 2011/04/22 00:44:27]

Hm, wouldn't that have caused all existing responses to be discarded (at the
check on line 118)?  The intent was to add this in a backwards-compatible way,
so that the socket address would just not be present for older cache entries.

Is this causing a problem somewhere?

[wtc, 2011/04/22 19:07:13]

We could change the check on line 118 to allow version 1, and
read socket_address only if version is > 1 here.

Now that I studied your solution again, I think it is a fine
way to avoid bumping the version number because the new field
is serialized at the end.  The only drawbacks I see are:
1) version 1 records may or may not have the socket_address
field.
2) The code pattern for decoding fields changes starting
on line 167 from
  if (!pickle.Foo())
    return false;
to
  if (pickle.Foo()) {
    // decode next field.
  }

+
   was_fetched_via_spdy = (flags & RESPONSE_INFO_WAS_SPDY) != 0;
 
   was_npn_negotiated = (flags & RESPONSE_INFO_WAS_NPN) != 0;
 
   was_alternate_protocol_available =
       (flags & RESPONSE_INFO_WAS_ALTERNATE_PROTOCOL_AVAILABLE) != 0;
 
   was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
 
   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) ? true : false;
@@ skipping 45 matching lines @@
 
   if (ssl_info.is_valid()) {
     ssl_info.cert->Persist(pickle);
     pickle->WriteInt(ssl_info.cert_status);
     if (ssl_info.security_bits != -1)
       pickle->WriteInt(ssl_info.security_bits);
   }
 
   if (vary_data.is_valid())
     vary_data.Persist(pickle);
+
+  pickle->WriteString(socket_address.host());
+  pickle->WriteUInt16(socket_address.port());
 }
 
 }  // namespace net