net: serialize SSL connection status to disk cache.

net/http/http_response_info.cc

 // Copyright (c) 2011 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 39 matching lines @@
 
   // This bit is set if the response was received via SPDY.
   RESPONSE_INFO_WAS_SPDY = 1 << 13,
 
   // This bit is set if the request has NPN negotiated.
   RESPONSE_INFO_WAS_NPN = 1 << 14,
 
   // This bit is set if the request was fetched via an explicit proxy.
   RESPONSE_INFO_WAS_PROXY = 1 << 15,
 
+  // This bit is set if the response info has an SSL connection status field.
+  // This contains the ciphersuite used to fetch the resource as well as the
+  // protocol version, compression method and whether SSLv3 fallback was used.
+  RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS = 1 << 16,
+
   // TODO(darin): Add other bits to indicate alternate request methods.
   // For now, we don't support storing those.
 };
 
 HttpResponseInfo::HttpResponseInfo()
     : was_cached(false),
       was_fetched_via_spdy(false),
       was_npn_negotiated(false),
       was_fetched_via_proxy(false) {
 }
@@ skipping 81 matching lines @@
       return false;
     ssl_info.cert_status = cert_status;
   }
   if (flags & RESPONSE_INFO_HAS_SECURITY_BITS) {
     int security_bits;
     if (!pickle.ReadInt(&iter, &security_bits))
       return false;
     ssl_info.security_bits = security_bits;
   }
 
+  if (flags & RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS) {
+    int connection_status;
+    if (!pickle.ReadInt(&iter, &connection_status))
+      return false;
+    ssl_info.connection_status = connection_status;
+  }
+
   // read vary-data
   if (flags & RESPONSE_INFO_HAS_VARY_DATA) {
     if (!vary_data.InitFromPickle(pickle, &iter))
       return false;
   }
 
   // Read socket_address.
   std::string socket_address_host;
   if (pickle.ReadString(&iter, &socket_address_host)) {
     // If the host was written, we always expect the port to follow.
@@ skipping 20 matching lines @@
 
 void HttpResponseInfo::Persist(Pickle* pickle,
                                bool skip_transient_headers,
                                bool response_truncated) const {
   int flags = RESPONSE_INFO_VERSION;
   if (ssl_info.is_valid()) {
     flags |= RESPONSE_INFO_HAS_CERT;
     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
     if (ssl_info.security_bits != -1)
       flags |= RESPONSE_INFO_HAS_SECURITY_BITS;
-    // TODO(wtc): we should persist ssl_info.connection_status.
+    if (ssl_info.connection_status != 0)
+      flags |= RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS;
   }
   if (vary_data.is_valid())
     flags |= RESPONSE_INFO_HAS_VARY_DATA;
   if (response_truncated)
     flags |= RESPONSE_INFO_TRUNCATED;
   if (was_fetched_via_spdy)
     flags |= RESPONSE_INFO_WAS_SPDY;
   if (was_npn_negotiated)
     flags |= RESPONSE_INFO_WAS_NPN;
   if (was_fetched_via_proxy)
@@ skipping 15 matching lines @@
         net::HttpResponseHeaders::PERSIST_SANS_RANGES;
   }
 
   headers->Persist(pickle, persist_options);
 
   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 (ssl_info.connection_status != 0)
+      pickle->WriteInt(ssl_info.connection_status);
   }
 
   if (vary_data.is_valid())
     vary_data.Persist(pickle);
 
   pickle->WriteString(socket_address.host());
   pickle->WriteUInt16(socket_address.port());
 }
 
 }  // namespace net