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_SPDY4 = 4, 41 CONNECTION_INFO_QUIC1_SPDY3 = 5, 42 NUM_OF_CONNECTION_INFOS, 43 }; 44 45 HttpResponseInfo(); 46 HttpResponseInfo(const HttpResponseInfo& rhs); 47 ~HttpResponseInfo(); 48 HttpResponseInfo& operator=(const HttpResponseInfo& rhs); 49 // Even though we could get away with the copy ctor and default operator=, 50 // that would prevent us from doing a bunch of forward declaration. 51 52 // Initializes from the representation stored in the given pickle. 53 bool InitFromPickle(const Pickle& pickle, bool* response_truncated); 54 55 // Call this method to persist the response info. 56 void Persist(Pickle* pickle, 57 bool skip_transient_headers, 58 bool response_truncated) const; 59 60 // The following is only defined if the request_time member is set. 61 // If this resource was found in the cache, then this bool is set, and 62 // request_time may corresponds to a time "far" in the past. Note that 63 // stale content (perhaps un-cacheable) may be fetched from cache subject to 64 // the load flags specified on the request info. For example, this is done 65 // when a user presses the back button to re-render pages, or at startup, 66 // when reloading previously visited pages (without going over the network). 67 // Note also that under normal circumstances, was_cached is set to the correct 68 // value even if the request fails. 69 bool was_cached; 70 71 // True if the request was fetched from cache rather than the network 72 // because of a LOAD_FROM_CACHE_IF_OFFLINE flag when the system 73 // was unable to contact the server. 74 bool server_data_unavailable; 75 76 // True if the request accessed the network in the process of retrieving 77 // data. 78 bool network_accessed; 79 80 // True if the request was fetched over a SPDY channel. 81 bool was_fetched_via_spdy; 82 83 // True if the npn was negotiated for this request. 84 bool was_npn_negotiated; 85 86 // True if the request was fetched via an explicit proxy. The proxy could 87 // be any type of proxy, HTTP or SOCKS. Note, we do not know if a 88 // transparent proxy may have been involved. If true, |proxy_server| contains 89 // the name of the proxy server that was used. 90 bool was_fetched_via_proxy; 91 HostPortPair proxy_server; 92 93 // Whether the request use http proxy or server authentication. 94 bool did_use_http_auth; 95 96 // Remote address of the socket which fetched this resource. 97 // 98 // NOTE: If the response was served from the cache (was_cached is true), 99 // the socket address will be set to the address that the content came from 100 // originally. This is true even if the response was re-validated using a 101 // different remote address, or if some of the content came from a byte-range 102 // request to a different address. 103 HostPortPair socket_address; 104 105 // Protocol negotiated with the server. 106 std::string npn_negotiated_protocol; 107 108 // The type of connection used for this response. 109 ConnectionInfo connection_info; 110 111 // The time at which the request was made that resulted in this response. 112 // For cached responses, this is the last time the cache entry was validated. 113 base::Time request_time; 114 115 // The time at which the response headers were received. For cached 116 // this is the last time the cache entry was validated. 117 base::Time response_time; 118 119 // If the response headers indicate a 401 or 407 failure, then this structure 120 // will contain additional information about the authentication challenge. 121 scoped_refptr<AuthChallengeInfo> auth_challenge; 122 123 // The SSL client certificate request info. 124 // TODO(wtc): does this really belong in HttpResponseInfo? I put it here 125 // because it is similar to |auth_challenge|, but unlike HTTP authentication 126 // challenge, client certificate request is not part of an HTTP response. 127 scoped_refptr<SSLCertRequestInfo> cert_request_info; 128 129 // The SSL connection info (if HTTPS). 130 SSLInfo ssl_info; 131 132 // The parsed response headers and status line. 133 scoped_refptr<HttpResponseHeaders> headers; 134 135 // The "Vary" header data for this response. 136 HttpVaryData vary_data; 137 138 // Any metadata asociated with this resource's cached data. 139 scoped_refptr<IOBufferWithSize> metadata; 140 141 static ConnectionInfo ConnectionInfoFromNextProto(NextProto next_proto); 142 143 static std::string ConnectionInfoToString(ConnectionInfo connection_info); 144 }; 145 146 } // namespace net 147 148 #endif // NET_HTTP_HTTP_RESPONSE_INFO_H_ 149