Reland "Turn libbase into a component"

src/base/platform/time.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_BASE_PLATFORM_TIME_H_
 #define V8_BASE_PLATFORM_TIME_H_
 
 #include <ctime>
 #include <iosfwd>
 #include <limits>
 
+#include "src/base/base-export.h"
 #include "src/base/bits.h"
 #include "src/base/macros.h"
 #include "src/base/safe_math.h"
 #if V8_OS_WIN
 #include "src/base/win32-headers.h"
 #endif
 
 // Forward declarations.
 extern "C" {
 struct _FILETIME;
@@ skipping 13 matching lines @@
 template<class TimeClass>
 class TimeBase;
 }
 
 // -----------------------------------------------------------------------------
 // TimeDelta
 //
 // This class represents a duration of time, internally represented in
 // microseonds.
 
-class TimeDelta final {
+class V8_BASE_EXPORT TimeDelta final {
  public:
   TimeDelta() : delta_(0) {}
 
   // Converts units of time to TimeDeltas.
   static TimeDelta FromDays(int days);
   static TimeDelta FromHours(int hours);
   static TimeDelta FromMinutes(int minutes);
   static TimeDelta FromSeconds(int64_t seconds);
   static TimeDelta FromMilliseconds(int64_t milliseconds);
   static TimeDelta FromMicroseconds(int64_t microseconds) {
@@ skipping 214 matching lines @@
 
 }  // namespace time_internal
 
 
 // -----------------------------------------------------------------------------
 // Time
 //
 // This class represents an absolute point in time, internally represented as
 // microseconds (s/1,000,000) since 00:00:00 UTC, January 1, 1970.
 
-class Time final : public time_internal::TimeBase<Time> {
+class V8_BASE_EXPORT Time final : public time_internal::TimeBase<Time> {
  public:
   // Contains the NULL time. Use Time::Now() to get the current time.
   Time() : TimeBase(0) {}
 
   // Returns the current time. Watch out, the system might adjust its clock
   // in which case time will actually go backwards. We don't guarantee that
   // times are increasing, or that two calls to Now() won't be the same.
   static Time Now();
 
   // Returns the current time. Same as Now() except that this function always
@@ skipping 24 matching lines @@
   // Converts to/from the Javascript convention for times, a number of
   // milliseconds since the epoch:
   static Time FromJsTime(double ms_since_epoch);
   double ToJsTime() const;
 
  private:
   friend class time_internal::TimeBase<Time>;
   explicit Time(int64_t us) : TimeBase(us) {}
 };
 
-std::ostream& operator<<(std::ostream&, const Time&);
+V8_BASE_EXPORT std::ostream& operator<<(std::ostream&, const Time&);
 
 inline Time operator+(const TimeDelta& delta, const Time& time) {
   return time + delta;
 }
 
 
 // -----------------------------------------------------------------------------
 // TimeTicks
 //
 // This class represents an abstract time that is most of the time incrementing
 // for use in measuring time durations. It is internally represented in
 // microseconds.  It can not be converted to a human-readable time, but is
 // guaranteed not to decrease (if the user changes the computer clock,
 // Time::Now() may actually decrease or jump).  But note that TimeTicks may
 // "stand still", for example if the computer suspended.
 
-class TimeTicks final : public time_internal::TimeBase<TimeTicks> {
+class V8_BASE_EXPORT TimeTicks final
+    : public time_internal::TimeBase<TimeTicks> {
  public:
   TimeTicks() : TimeBase(0) {}
 
   // Platform-dependent tick count representing "right now."
   // The resolution of this clock is ~1-15ms.  Resolution varies depending
   // on hardware/operating system configuration.
   // This method never returns a null TimeTicks.
   static TimeTicks Now();
 
   // Returns a platform-dependent high-resolution tick count. Implementation
@@ skipping 16 matching lines @@
 
 inline TimeTicks operator+(const TimeDelta& delta, const TimeTicks& ticks) {
   return ticks + delta;
 }
 
 
 // ThreadTicks ----------------------------------------------------------------
 
 // Represents a clock, specific to a particular thread, than runs only while the
 // thread is running.
-class ThreadTicks final : public time_internal::TimeBase<ThreadTicks> {
+class V8_BASE_EXPORT ThreadTicks final
+    : public time_internal::TimeBase<ThreadTicks> {
  public:
   ThreadTicks() : TimeBase(0) {}
 
   // Returns true if ThreadTicks::Now() is supported on this system.
   static bool IsSupported();
 
   // Waits until the initialization is completed. Needs to be guarded with a
   // call to IsSupported().
   static void WaitUntilInitialized() {
 #if V8_OS_WIN
@@ skipping 11 matching lines @@
   static ThreadTicks Now();
 
 #if V8_OS_WIN
   // Similar to Now() above except this returns thread-specific CPU time for an
   // arbitrary thread. All comments for Now() method above apply apply to this
   // method as well.
   static ThreadTicks GetForThread(const HANDLE& thread_handle);
 #endif
 
  private:
+  template <class TimeClass>
+  friend class time_internal::TimeBase;
+
   // Please use Now() or GetForThread() to create a new object. This is for
   // internal use and testing. Ticks are in microseconds.
   explicit ThreadTicks(int64_t ticks) : TimeBase(ticks) {}
 
 #if V8_OS_WIN
   // Returns the frequency of the TSC in ticks per second, or 0 if it hasn't
   // been measured yet. Needs to be guarded with a call to IsSupported().
   static double TSCTicksPerSecond();
   static bool IsSupportedWin();
   static void WaitUntilInitializedWin();
 #endif
 };
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_PLATFORM_TIME_H_