Local clock changes

Code changes

We define a ServerTimeInfo struct that represents time information received from a server:

struct ServerTimeInfo {
  enum SourceType { UNKNOWN, TLS, TLS_FALSE_START, HTTP, HTTPS, FROM_DISK, ... };
  string server;
  SourceType source_type;
  Time server_time;
  TimeTicks start_ticks, end_ticks;
}

server is the hostname of the server from which the time was received.  source_type is the type of the time source -- TLS, HTTPS, etc.  Most of the time we care about time infos from *.google.com and with source type TLS or HTTPS, but sometimes we may still use time infos that are slightly less trusted, e.g. FROM_DISK, if we have no other source.  server_time is the actual timestamp received from the server. start_ticks is the client time when the request to the server was made, and end_ticks is the client time when the response was received. server_time corresponds to some time in [start_ticks, end_ticks], so ideally the latter interval should be as small as possible.  We use ticks since it's from a monotonic clock (i.e., unrelated to the computer clock, which the user may change).  However, this means that we can't persist ServerTimeInfo structs to disk directly, as ticks are reset on computer start.  But one can serialize a ServerTimeInfo by converting start_ticks/end_ticks to Time objects (using the current values of Time::now() and TimeTicks::now()) and then serializing those along with server_time. However, since the local clock may change between serialization and deserialization, the TrustLevel of the deserialized ServerTimeInfo object should be at most UNVERIFIED.

One can approximate the current server time given a ServerTimeInfo:

// Assume sti.server_time corresponds to the time midway between start_ticks and end_ticks.
TimeTicks midpoint = sti.start_ticks + (sti.end_ticks - sti.start_ticks) / 2;
Time server_now = sti.server_time + (TimeTicks::now() - midpoint);

Here's a rough outline of what needs to be changed to maintain a clock based on sane time:

1. Modify SSLInfo to have a ServerTimeInfo member.
2. Modify the implementations of SSLClientSocket to fill in the ServerTimeInfo in SSLInfo from the TLS handshake when possible. (This may take a while, so it can be done in parallel with the following steps.)
3. Modify URLRequest and related classes to create a ServerTimeInfo from the Date response header (if it exists) and request/response timestamps (they're already being calculated).
4. Expose methods to get/create the TLS/HTTP ServerTimeInfos from URLRequest/URLFetcher.
5. Create a SaneTimeTracker class that consumes ServerTimeInfos and maintains the best known one.  It can have a policy of which ones it'll accept.  For example, it should only accept ones from TLS connections to google.com servers, it should keep the one from the last hour with the smallest tick interval, etc.
6. Add a SaneTimeTracker to URLRequestContext and hook it up to any created connections.
7. Add a way to propagate ServerTimeInfos from the "main" SaneTimeTracker to other threads/objects (perhaps similar to NetworkChangeNotifier).
8. Add periodic serialization to a pref, and deserialize on startup.
9. Add code to detect when the system time changes.  Serialize when that happens.
10. Add code to detect when the system goes to sleep and wakes.  Treat this the same way as a restart of Chrome.