1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_HTTP_HTTP_RESPONSE_INFO_H_ 6 #define NET_HTTP_HTTP_RESPONSE_INFO_H_ 7 8 #include <string> 9 10 #include "base/time/time.h" 11 #include "net/base/host_port_pair.h" 12 #include "net/base/net_export.h" 13 #include "net/http/http_vary_data.h" 14 #include "net/socket/next_proto.h" 15 #include "net/ssl/ssl_info.h" 16 17 class Pickle; 18 19 namespace net { 20 21 class AuthChallengeInfo; 22 class HttpResponseHeaders; 23 class IOBufferWithSize; 24 class SSLCertRequestInfo; 25 26 class NET_EXPORT HttpResponseInfo { 27 public: 28 // Describes the kind of connection used to fetch this response. 29 // 30 // NOTE: This is persisted to the cache, so make sure not to reorder 31 // these values. 32 // 33 // TODO(akalin): Better yet, just use a string instead of an enum, 34 // like |npn_negotiated_protocol|. 35 enum ConnectionInfo { 36 CONNECTION_INFO_UNKNOWN = 0, 37 CONNECTION_INFO_HTTP1 = 1, 38 CONNECTION_INFO_DEPRECATED_SPDY2 = 2, 39 CONNECTION_INFO_SPDY3 = 3, 40 CONNECTION_INFO_SPDY4A2 = 4, 41 CONNECTION_INFO_QUIC1_SPDY3 = 5, 42 CONNECTION_INFO_HTTP2_DRAFT_04 = 6, 43 NUM_OF_CONNECTION_INFOS, 44 }; 45 46 HttpResponseInfo(); 47 HttpResponseInfo(const HttpResponseInfo& rhs); 48 ~HttpResponseInfo(); 49 HttpResponseInfo& operator=(const HttpResponseInfo& rhs); 50 // Even though we could get away with the copy ctor and default operator=, 51 // that would prevent us from doing a bunch of forward declaration. 52 53 // Initializes from the representation stored in the given pickle. 54 bool InitFromPickle(const Pickle& pickle, bool* response_truncated); 55 56 // Call this method to persist the response info. 57 void Persist(Pickle* pickle, 58 bool skip_transient_headers, 59 bool response_truncated) const; 60 61 // The following is only defined if the request_time member is set. 62 // If this response was resurrected from cache, then this bool is set, and 63 // request_time may corresponds to a time "far" in the past. Note that 64 // stale content (perhaps un-cacheable) may be fetched from cache subject to 65 // the load flags specified on the request info. For example, this is done 66 // when a user presses the back button to re-render pages, or at startup, 67 // when reloading previously visited pages (without going over the network). 68 bool was_cached; 69 70 // True if the request was fetched from cache rather than the network 71 // because of a LOAD_FROM_CACHE_IF_OFFLINE flag when the system 72 // was unable to contact the server. 73 bool server_data_unavailable; 74 75 // True if the request accessed the network in the process of retrieving 76 // data. 77 bool network_accessed; 78 79 // True if the request was fetched over a SPDY channel. 80 bool was_fetched_via_spdy; 81 82 // True if the npn was negotiated for this request. 83 bool was_npn_negotiated; 84 85 // True if the request was fetched via an explicit proxy. The proxy could 86 // be any type of proxy, HTTP or SOCKS. Note, we do not know if a 87 // transparent proxy may have been involved. 88 bool was_fetched_via_proxy; 89 90 // Whether the request use http proxy or server authentication. 91 bool did_use_http_auth; 92 93 // Remote address of the socket which fetched this resource. 94 // 95 // NOTE: If the response was served from the cache (was_cached is true), 96 // the socket address will be set to the address that the content came from 97 // originally. This is true even if the response was re-validated using a 98 // different remote address, or if some of the content came from a byte-range 99 // request to a different address. 100 HostPortPair socket_address; 101 102 // Protocol negotiated with the server. 103 std::string npn_negotiated_protocol; 104 105 // The type of connection used for this response. 106 ConnectionInfo connection_info; 107 108 // The time at which the request was made that resulted in this response. 109 // For cached responses, this is the last time the cache entry was validated. 110 base::Time request_time; 111 112 // The time at which the response headers were received. For cached 113 // this is the last time the cache entry was validated. 114 base::Time response_time; 115 116 // If the response headers indicate a 401 or 407 failure, then this structure 117 // will contain additional information about the authentication challenge. 118 scoped_refptr<AuthChallengeInfo> auth_challenge; 119 120 // The SSL client certificate request info. 121 // TODO(wtc): does this really belong in HttpResponseInfo? I put it here 122 // because it is similar to |auth_challenge|, but unlike HTTP authentication 123 // challenge, client certificate request is not part of an HTTP response. 124 scoped_refptr<SSLCertRequestInfo> cert_request_info; 125 126 // The SSL connection info (if HTTPS). 127 SSLInfo ssl_info; 128 129 // The parsed response headers and status line. 130 scoped_refptr<HttpResponseHeaders> headers; 131 132 // The "Vary" header data for this response. 133 HttpVaryData vary_data; 134 135 // Any metadata asociated with this resource's cached data. 136 scoped_refptr<IOBufferWithSize> metadata; 137 138 static ConnectionInfo ConnectionInfoFromNextProto(NextProto next_proto); 139 140 static std::string ConnectionInfoToString(ConnectionInfo connection_info); 141 }; 142 143 } // namespace net 144 145 #endif // NET_HTTP_HTTP_RESPONSE_INFO_H_ 146