time: Add a static TimeTicks method that returns the underlying clock

base/time/time.h

 // Copyright (c) 2012 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.
 
 // Time represents an absolute point in coordinated universal time (UTC),
 // internally represented as microseconds (s/1,000,000) since the Windows epoch
 // (1601-01-01 00:00:00 UTC). System-dependent clock interface routines are
 // defined in time_PLATFORM.cc. Note that values for Time may skew and jump
 // around as the operating system makes adjustments to synchronize (e.g., with
 // NTP servers). Thus, client code that uses the Time class must account for
@@ skipping 662 matching lines @@
   // the same value for the duration of the application, but will be different
   // in future application runs.
   static TimeTicks UnixEpoch();
 
   // Returns |this| snapped to the next tick, given a |tick_phase| and
   // repeating |tick_interval| in both directions. |this| may be before,
   // after, or equal to the |tick_phase|.
   TimeTicks SnappedToNextTick(TimeTicks tick_phase,
                               TimeDelta tick_interval) const;
 
+  // Returns a string identifier for the underlying clock being used to generate
+  // TimeTicks timestamps (e.g. LINUX_CLOCK_MONOTONIC_MICROS, WIN_QPC_MICROS).
+  // This function should only be used for debugging and logging purposes.
+  static std::string ClockId();

[danakj, 2016/03/26 00:40:33]

it looks like this can return const char*.

i kinda am wondering why strings and not an enum. but maybe that's good enough
for you? it hides the platform-specific stuff in platform-specific files. but
also makes it very hard to tell what this might return.

[charliea (OOO until 10-5), 2016/03/28 15:40:51]

Definitely agree that it makes it hard to see the possible return values. The
main reason for the strings over the enums is that the primary way this will be
used is as metadata for Chrome traces. The primary consumer of this (at least
for right now) is going to be trace viewer (about:tracing). It's a whole
separate thing from Chrome itself and pulls in traces from a variety of sources
(Windows ETW, Android atrace, etc.). We'll use these clock IDs to determine if
Chrome was using the same clock as one of these other tracers that was tracing
concurrently, allowing us to know if the two have timestamps on the same
timeline.

That being said, that's a lot of levels removed. Is there some idiomatic Chrome
way to map enums to strings for printing? If we had that, returning an enum
could be sufficient because we could just do something like:

  AddTraceMetadata("clock-id", ClockIdToString(TimeTicks::ClockId()));

[danakj, 2016/03/28 17:53:50]

https://code.google.com/p/chromium/codesearch#chromium/src/cc/scheduler/sched...
is a good example of doing that.

[danakj, 2016/03/28 17:54:21]

(And I think that such a function would belong in the tracing code, not in
time.h)

[charliea (OOO until 10-5), 2016/03/28 21:07:36]

Done.

+
 #if defined(OS_WIN)
  protected:
   typedef DWORD (*TickFunctionType)(void);
   static TickFunctionType SetMockTickFunction(TickFunctionType ticker);
 #endif
 
  private:
   friend class time_internal::TimeBase<TimeTicks>;
 
   // Please use Now() to create a new object. This is for internal use
@@ skipping 62 matching lines @@
   static void WaitUntilInitializedWin();
 #endif
 };
 
 // For logging use only.
 BASE_EXPORT std::ostream& operator<<(std::ostream& os, ThreadTicks time_ticks);
 
 }  // namespace base
 
 #endif  // BASE_TIME_TIME_H_