net/base/load_timing_info.h

   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_t 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_