1 // Copyright (c) 2012 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_BASE_LOAD_TIMING_INFO_H_ 6 #define NET_BASE_LOAD_TIMING_INFO_H_ 7 8 #include "base/basictypes.h" 9 #include "base/time/time.h" 10 #include "net/base/net_export.h" 11 12 namespace net { 13 14 // Structure containing timing information for a request. 15 // It addresses the needs of 16 // http://groups.google.com/group/http-archive-specification/web/har-1-1-spec, 17 // http://dev.w3.org/2006/webapi/WebTiming/, and 18 // http://www.w3.org/TR/resource-timing/. 19 // 20 // All events that do not apply to a request have null times. For non-HTTP 21 // requests, all times other than the request_start times are null. 22 // 23 // Requests with connection errors generally only have request start times as 24 // well, since they never received an established socket. 25 // 26 // The general order for events is: 27 // request_start 28 // proxy_start 29 // proxy_end 30 // dns_start 31 // dns_end 32 // connect_start 33 // ssl_start 34 // ssl_end 35 // connect_end 36 // send_start 37 // send_end 38 // receive_headers_end 39 // 40 // Times represent when a request starts/stops blocking on an event, not the 41 // time the events actually occurred. In particular, in the case of preconnects 42 // and socket reuse, no time may be spent blocking on establishing a connection. 43 // In the case of SPDY, PAC scripts are only run once for each shared session, 44 // so no time may be spent blocking on them. 45 // 46 // DNS and SSL times are both times for the host, not the proxy, so DNS times 47 // when using proxies are null, and only requests to HTTPS hosts (Not proxies) 48 // have SSL times. One exception to this is when a proxy server itself returns 49 // a redirect response. In this case, the connect times treat the proxy as the 50 // host. The send and receive times will all be null, however. 51 // See HttpNetworkTransaction::OnHttpsProxyTunnelResponse. 52 // TODO(mmenke): Is this worth fixing? 53 // 54 // Note that internal to the network stack, times are when events actually 55 // occurred. URLRequest converts them to time which the network stack was 56 // blocked on each state. 57 struct NET_EXPORT LoadTimingInfo { 58 // Contains the LoadTimingInfo events related to establishing a connection. 59 // These are all set by ConnectJobs. 60 struct NET_EXPORT_PRIVATE ConnectTiming { 61 ConnectTiming(); 62 ~ConnectTiming(); 63 64 // The time spent looking up the host's DNS address. Null for requests that 65 // used proxies to look up the DNS address. Also null for SOCKS4 proxies, 66 // since the DNS address is only looked up after the connection is 67 // established, which results in unexpected event ordering. 68 // TODO(mmenke): The SOCKS4 event ordering could be refactored to allow 69 // these times to be non-null. 70 base::TimeTicks dns_start; 71 base::TimeTicks dns_end; 72 73 // The time spent establishing the connection. Connect time includes proxy 74 // connect times (Though not proxy_resolve times), DNS lookup times, time 75 // spent waiting in certain queues, TCP, and SSL time. 76 // TODO(mmenke): For proxies, this includes time spent blocking on higher 77 // level socket pools. Fix this. 78 // TODO(mmenke): Retried connections to the same server should apparently 79 // be included in this time. Consider supporting that. 80 // Since the network stack has multiple notions of a "retry", 81 // handled at different levels, this may not be worth 82 // worrying about - backup jobs, reused socket failure, 83 // multiple round authentication. 84 base::TimeTicks connect_start; 85 base::TimeTicks connect_end; 86 87 // The time when the SSL handshake started / completed. For non-HTTPS 88 // requests these are null. These times are only for the SSL connection to 89 // the final destination server, not an SSL/SPDY proxy. 90 base::TimeTicks ssl_start; 91 base::TimeTicks ssl_end; 92 }; 93 94 LoadTimingInfo(); 95 ~LoadTimingInfo(); 96 97 // True if the socket was reused. When true, DNS, connect, and SSL times 98 // will all be null. When false, those times may be null, too, for non-HTTP 99 // requests, or when they don't apply to a request. 100 // 101 // For requests that are sent again after an AUTH challenge, this will be true 102 // if the original socket is reused, and false if a new socket is used. 103 // Responding to a proxy AUTH challenge is never considered to be reusing a 104 // socket, since a connection to the host wasn't established when the 105 // challenge was received. 106 bool socket_reused; 107 108 // Unique socket ID, can be used to identify requests served by the same 109 // socket. For connections tunnelled over SPDY proxies, this is the ID of 110 // the virtual connection (The SpdyProxyClientSocket), not the ID of the 111 // actual socket. HTTP requests handled by the SPDY proxy itself all use the 112 // actual socket's ID. 113 // 114 // 0 when there is no socket associated with the request, or it's not an HTTP 115 // request. 116 uint32 socket_log_id; 117 118 // Start time as a base::Time, so times can be coverted into actual times. 119 // Other times are recorded as TimeTicks so they are not affected by clock 120 // changes. 121 base::Time request_start_time; 122 123 base::TimeTicks request_start; 124 125 // The time spent determing which proxy to use. Null when there is no PAC. 126 base::TimeTicks proxy_resolve_start; 127 base::TimeTicks proxy_resolve_end; 128 129 ConnectTiming connect_timing; 130 131 // The time that sending HTTP request started / ended. 132 base::TimeTicks send_start; 133 base::TimeTicks send_end; 134 135 // The time at which the end of the HTTP headers were received. 136 base::TimeTicks receive_headers_end; 137 }; 138 139 } // namespace net 140 141 #endif // NET_BASE_LOAD_TIMING_INFO_H_ 142
