Replace TimeTicks::UnixEpoch with Time::UnixEpoch for the net log

net/log/net_log_util.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/log/net_log_util.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 257 matching lines @@
     dict->SetInteger("ADDRESS_FAMILY_UNSPECIFIED", ADDRESS_FAMILY_UNSPECIFIED);
     dict->SetInteger("ADDRESS_FAMILY_IPV4", ADDRESS_FAMILY_IPV4);
     dict->SetInteger("ADDRESS_FAMILY_IPV6", ADDRESS_FAMILY_IPV6);
 
     constants_dict->Set("addressFamily", std::move(dict));
   }
 
   // Information about how the "time ticks" values we have given it relate to
   // actual system times.  Time ticks are used throughout since they are stable
   // across system clock changes.
+  // Note: |timeTickOffset| is only comparable to TimeTicks values, converted to
+  // milliseconds by subtracting the null TimeTicks.

[eroman, 2016/03/08 00:11:04]

I am not sure what this comment means. Subtracting null TimeTicks from a
TimeTicks leaves the result unchanged, since it is TimeTicks(0) no? (Just
changes the type).

[Charlie Harrison, 2016/03/08 01:14:46]

Yeah that's what I meant. I thought saying something like "comparable to
TimeTicks" would be a bit imprecise. Maybe"comparable to TimeTicks in
milliseconds" is better.

   {
+    base::TimeDelta time_since_epoch =
+        base::Time::Now() - base::Time::UnixEpoch();
+    base::TimeDelta reference_time_ticks =
+        base::TimeTicks::Now() - base::TimeTicks();
     int64_t tick_to_unix_time_ms =
-        (base::TimeTicks() - base::TimeTicks::UnixEpoch()).InMilliseconds();
+        (time_since_epoch - reference_time_ticks).InMilliseconds();
 
     // Pass it as a string, since it may be too large to fit in an integer.
     constants_dict->SetString("timeTickOffset",

[charliea (OOO until 10-5), 2016/03/08 17:01:42]

Am I right in that we're just trying to do a drop-in replacement here so that we
can eventually kill TimeTicks::UnixEpoch()? If so, can you add a scary comment
above indicating that we know the operation we're doing here is flawed, and
explain why? 

Something like:

TODO(csharrison): This code computes the TimeDelta that must be subtracted from
a TimeTicks value in order for that TimeTicks to be relative to the Unix epoch
rather than some arbitrary point in the past (usually the system boot time).
However, the amount that must be subtracted is inherently subject to change.
TimeTicks takes leap seconds into account, whereas Unix time does not. On some
systems, TimeTicks stops when the computer is asleep, whereas Unix time does
not. Because of this, correctly storing this offset as a constant is impossible.

[Charlie Harrison, 2016/03/08 17:13:41]

I'm not sure why this operation is as flawed as you say. Events are stored with
TimeTicks timestamps, because we care about event monotonicity, etc. This
reference time is just used for conversion for UI purposes, and it will only be
incorrect for skew introduced during logging (the constant is created when
logging starts).

This mimics blink's behavior to generate reference monotonic and wall time
values for performance.timing.

I think the only improvement on this would be to log every event with a
TimeTicks timestamp and a Time ui_timestamp. Is that what you are advocating?

                               base::Int64ToString(tick_to_unix_time_ms));
   }
 
   // "clientInfo" key is required for some WriteToFileNetLogObserver log
   // readers. Provide a default empty value for compatibility.
   constants_dict->Set("clientInfo", new base::DictionaryValue());
 
   // Add a list of active field experiments.
   {
     base::FieldTrial::ActiveGroups active_groups;
@@ skipping 235 matching lines @@
     // fine, since GetRequestStateAsValue() ignores the capture mode.
     NetLog::EntryData entry_data(
         NetLog::TYPE_REQUEST_ALIVE, request->net_log().source(),
         NetLog::PHASE_BEGIN, request->creation_time(), &callback);
     NetLog::Entry entry(&entry_data, NetLogCaptureMode::Default());
     observer->OnAddEntry(entry);
   }
 }
 
 }  // namespace net