s/NPN/ALPN/

net/http/http_response_info.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_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
@@ skipping 51 matching lines @@
 
   // This bit is set if the response info has vary header data.
   RESPONSE_INFO_HAS_VARY_DATA = 1 << 11,
 
   // This bit is set if the request was cancelled before completion.
   RESPONSE_INFO_TRUNCATED = 1 << 12,
 
   // 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 has ALPN negotiated.
+  RESPONSE_INFO_WAS_ALPN = 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,
 
   // This bit is set if the response info has protocol version.
-  RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL = 1 << 17,
+  RESPONSE_INFO_HAS_ALPN_NEGOTIATED_PROTOCOL = 1 << 17,
 
   // This bit is set if the response info has connection info.
   RESPONSE_INFO_HAS_CONNECTION_INFO = 1 << 18,
 
   // This bit is set if the request has http authentication.
   RESPONSE_INFO_USE_HTTP_AUTHENTICATION = 1 << 19,
 
   // This bit is set if ssl_info has SCTs.
   RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS = 1 << 20,
 
   RESPONSE_INFO_UNUSED_SINCE_PREFETCH = 1 << 21,
 
   // This bit is set if the response has a key-exchange-info field at the end.
   RESPONSE_INFO_HAS_KEY_EXCHANGE_INFO = 1 << 22,
 
   // This bit is set if ssl_info recorded that PKP was bypassed due to a local
   // trust anchor.
   RESPONSE_INFO_PKP_BYPASSED = 1 << 23,
 
   // TODO(darin): Add other bits to indicate alternate request methods.
   // For now, we don't support storing those.
 };
 
 HttpResponseInfo::HttpResponseInfo()
     : was_cached(false),
       cache_entry_status(CacheEntryStatus::ENTRY_UNDEFINED),
       server_data_unavailable(false),
       network_accessed(false),
       was_fetched_via_spdy(false),
-      was_npn_negotiated(false),
+      was_alpn_negotiated(false),
       was_fetched_via_proxy(false),
       did_use_http_auth(false),
       unused_since_prefetch(false),
       async_revalidation_required(false),
       connection_info(CONNECTION_INFO_UNKNOWN) {}
 
 HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs)
     : was_cached(rhs.was_cached),
       cache_entry_status(rhs.cache_entry_status),
       server_data_unavailable(rhs.server_data_unavailable),
       network_accessed(rhs.network_accessed),
       was_fetched_via_spdy(rhs.was_fetched_via_spdy),
-      was_npn_negotiated(rhs.was_npn_negotiated),
+      was_alpn_negotiated(rhs.was_alpn_negotiated),
       was_fetched_via_proxy(rhs.was_fetched_via_proxy),
       proxy_server(rhs.proxy_server),
       did_use_http_auth(rhs.did_use_http_auth),
       unused_since_prefetch(rhs.unused_since_prefetch),
       async_revalidation_required(rhs.async_revalidation_required),
       socket_address(rhs.socket_address),
-      npn_negotiated_protocol(rhs.npn_negotiated_protocol),
+      alpn_negotiated_protocol(rhs.alpn_negotiated_protocol),
       connection_info(rhs.connection_info),
       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;
   cache_entry_status = rhs.cache_entry_status;
   server_data_unavailable = rhs.server_data_unavailable;
   network_accessed = rhs.network_accessed;
   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
   proxy_server = rhs.proxy_server;
-  was_npn_negotiated = rhs.was_npn_negotiated;
+  was_alpn_negotiated = rhs.was_alpn_negotiated;
   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
   did_use_http_auth = rhs.did_use_http_auth;
   unused_since_prefetch = rhs.unused_since_prefetch;
   async_revalidation_required = rhs.async_revalidation_required;
   socket_address = rhs.socket_address;
-  npn_negotiated_protocol = rhs.npn_negotiated_protocol;
+  alpn_negotiated_protocol = rhs.alpn_negotiated_protocol;
   connection_info = rhs.connection_info;
   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 90 matching lines @@
     if (!iter.ReadUInt16(&socket_address_port))
       return false;
     socket_address = HostPortPair(socket_address_host, socket_address_port);
   } else if (version > 1) {
     // socket_address was not always present in version 1 of the response
     // info, so we don't fail if it can't be read.
     return false;
   }
 
   // Read protocol-version.
-  if (flags & RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL) {
-    if (!iter.ReadString(&npn_negotiated_protocol))
+  if (flags & RESPONSE_INFO_HAS_ALPN_NEGOTIATED_PROTOCOL) {
+    if (!iter.ReadString(&alpn_negotiated_protocol))
       return false;
   }
 
   // Read connection info.
   if (flags & RESPONSE_INFO_HAS_CONNECTION_INFO) {
     int value;
     if (!iter.ReadInt(&value))
       return false;
 
     if (value > static_cast<int>(CONNECTION_INFO_UNKNOWN) &&
         value < static_cast<int>(NUM_OF_CONNECTION_INFOS)) {
       connection_info = static_cast<ConnectionInfo>(value);
     }
   }
 
   // Read key_exchange_info
   if (flags & RESPONSE_INFO_HAS_KEY_EXCHANGE_INFO) {
     int key_exchange_info;
     if (!iter.ReadInt(&key_exchange_info))
       return false;
     ssl_info.key_exchange_info = key_exchange_info;
   }
 
   was_fetched_via_spdy = (flags & RESPONSE_INFO_WAS_SPDY) != 0;
 
-  was_npn_negotiated = (flags & RESPONSE_INFO_WAS_NPN) != 0;
+  was_alpn_negotiated = (flags & RESPONSE_INFO_WAS_ALPN) != 0;
 
   was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
 
   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) != 0;
 
   did_use_http_auth = (flags & RESPONSE_INFO_USE_HTTP_AUTHENTICATION) != 0;
 
   unused_since_prefetch = (flags & RESPONSE_INFO_UNUSED_SINCE_PREFETCH) != 0;
 
   ssl_info.pkp_bypassed = (flags & RESPONSE_INFO_PKP_BYPASSED) != 0;
@@ skipping 14 matching lines @@
       flags |= RESPONSE_INFO_HAS_KEY_EXCHANGE_INFO;
     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;
-    flags |= RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL;
+  if (was_alpn_negotiated) {
+    flags |= RESPONSE_INFO_WAS_ALPN;
+    flags |= RESPONSE_INFO_HAS_ALPN_NEGOTIATED_PROTOCOL;
   }
   if (was_fetched_via_proxy)
     flags |= RESPONSE_INFO_WAS_PROXY;
   if (connection_info != CONNECTION_INFO_UNKNOWN)
     flags |= RESPONSE_INFO_HAS_CONNECTION_INFO;
   if (did_use_http_auth)
     flags |= RESPONSE_INFO_USE_HTTP_AUTHENTICATION;
   if (unused_since_prefetch)
     flags |= RESPONSE_INFO_UNUSED_SINCE_PREFETCH;
   if (!ssl_info.signed_certificate_timestamps.empty())
@@ skipping 36 matching lines @@
       }
     }
   }
 
   if (vary_data.is_valid())
     vary_data.Persist(pickle);
 
   pickle->WriteString(socket_address.host());
   pickle->WriteUInt16(socket_address.port());
 
-  if (was_npn_negotiated)
-    pickle->WriteString(npn_negotiated_protocol);
+  if (was_alpn_negotiated)
+    pickle->WriteString(alpn_negotiated_protocol);
 
   if (connection_info != CONNECTION_INFO_UNKNOWN)
     pickle->WriteInt(static_cast<int>(connection_info));
 
   if (ssl_info.is_valid() && ssl_info.key_exchange_info != 0)
     pickle->WriteInt(ssl_info.key_exchange_info);
 }
 
 HttpResponseInfo::ConnectionInfo HttpResponseInfo::ConnectionInfoFromNextProto(
     NextProto next_proto) {
@@ skipping 40 matching lines @@
     case CONNECTION_INFO_HTTP1_0:
       return "http/1.0";
     case NUM_OF_CONNECTION_INFOS:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace net