Certificate Transparency: Ensure timestamps over 32 bit are handled correctly.

net/cert/ct_log_response_parser.cc

Index: net/cert/ct_log_response_parser.cc
diff --git a/net/cert/ct_log_response_parser.cc b/net/cert/ct_log_response_parser.cc
index 628eef286be0a1081267b53e504ce050ee28bf77..5baf1b33534dc8abbf1f18950c985cbf6b75eeba 100644
--- a/net/cert/ct_log_response_parser.cc
+++ b/net/cert/ct_log_response_parser.cc
@@ -145,9 +145,7 @@ bool FillSignedTreeHead(const base::Value& json_signed_tree_head,
 
   signed_tree_head->version = SignedTreeHead::V1;
   signed_tree_head->tree_size = parsed_sth.tree_size;
-  signed_tree_head->timestamp =
-      base::Time::UnixEpoch() + base::TimeDelta::FromMilliseconds(
-                                    static_cast<int64_t>(parsed_sth.timestamp));
+  signed_tree_head->timestamp = base::Time::FromJsTime(parsed_sth.timestamp);

[Ryan Sleevi, 2016/03/02 19:03:22]

Are you sure this is correct? Js loses precision 

[davidben, 2016/03/02 19:11:46]

What do you mean? FromJsTime and JsonSignedTreeHead both take double. FromJsTime
uses TimeDelta::FromMillisecondsD which also takes a double.

[Ryan Sleevi, 2016/03/02 19:16:53]

I just meant that a 64-bit timestamp will be capped at 2^53-1 if round-tripping
through the double

[davidben, 2016/03/02 19:21:04]

Ah. (Well, it won't be capped but it'll lose precision beyond that point.)
That's true, but this isn't a 64-bit timestamp to begin with. JsonSignedTreeHead
is *already* a double. And JSONValueConverter doesn't have a
RegisterUint64Field, only RegisterIntField and RegisterDoubleField. This seems
fine.

[Eran Messeri, 2016/03/04 11:28:30]

What davidben said - I couldn't find a more accurate method and given that this
precision will carry us beyond the 26th century, I'm not too worried.

   signed_tree_head->signature = parsed_sth.signature;
   memcpy(signed_tree_head->sha256_root_hash,
          parsed_sth.sha256_root_hash.c_str(),