Chromium -> Mojo roll.

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) (See http://crbug.com/14734).  System-dependent
 // clock interface routines are defined in time_PLATFORM.cc.
 //
 // TimeDelta represents a duration of time, internally represented in
@@ skipping 15 matching lines @@
 
 #ifndef BASE_TIME_TIME_H_
 #define BASE_TIME_TIME_H_
 
 #include <time.h>
 
 #include <iosfwd>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/numerics/safe_math.h"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 // Avoid Mac system header macro leak.
 #undef TYPE_BOOL
 #endif
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 87 matching lines @@
   int64 InMillisecondsRoundedUp() const;
   int64 InMicroseconds() const;
 
   TimeDelta& operator=(TimeDelta other) {
     delta_ = other.delta_;
     return *this;
   }
 
   // Computations with other deltas.
   TimeDelta operator+(TimeDelta other) const {
-    return TimeDelta(delta_ + other.delta_);
+    return TimeDelta(SaturatedAdd(other.delta_));
   }
   TimeDelta operator-(TimeDelta other) const {
-    return TimeDelta(delta_ - other.delta_);
+    return TimeDelta(SaturatedSub(other.delta_));
   }
 
   TimeDelta& operator+=(TimeDelta other) {
-    delta_ += other.delta_;
+    delta_ = SaturatedAdd(other.delta_);
     return *this;
   }
   TimeDelta& operator-=(TimeDelta other) {
-    delta_ -= other.delta_;
+    delta_ = SaturatedSub(other.delta_);
     return *this;
   }
   TimeDelta operator-() const {
     return TimeDelta(-delta_);
   }
 
   // Computations with numeric types.
   template<typename T>
   TimeDelta operator*(T a) const {
-    return TimeDelta(delta_ * a);
+    CheckedNumeric<int64> rv(delta_);
+    rv *= a;
+    return TimeDelta(FromCheckedNumeric(rv));
   }
   template<typename T>
   TimeDelta operator/(T a) const {
-    return TimeDelta(delta_ / a);
+    CheckedNumeric<int64> rv(delta_);
+    rv /= a;
+    return TimeDelta(FromCheckedNumeric(rv));
   }
   template<typename T>
   TimeDelta& operator*=(T a) {
-    delta_ *= a;
+    CheckedNumeric<int64> rv(delta_);
+    rv *= a;
+    delta_ = FromCheckedNumeric(rv);
     return *this;
   }
   template<typename T>
   TimeDelta& operator/=(T a) {
-    delta_ /= a;
+    CheckedNumeric<int64> rv(delta_);
+    rv /= a;
+    delta_ = FromCheckedNumeric(rv);
     return *this;
   }
 
   int64 operator/(TimeDelta a) const {
     return delta_ / a.delta_;
   }
 
   // Defined below because it depends on the definition of the other classes.
   Time operator+(Time t) const;
   TimeTicks operator+(TimeTicks t) const;
@@ skipping 21 matching lines @@
  private:
   friend class Time;
   friend class TimeTicks;
 
   // Constructs a delta given the duration in microseconds. This is private
   // to avoid confusion by callers with an integer constructor. Use
   // FromSeconds, FromMilliseconds, etc. instead.
   explicit TimeDelta(int64 delta_us) : delta_(delta_us) {
   }
 
+  // Add or subtract |value| from this delta.
+  int64 SaturatedAdd(int64 value) const;
+  int64 SaturatedSub(int64 value) const;
+
+  // Clamp |value| on overflow and underflow conditions.
+  static int64 FromCheckedNumeric(const CheckedNumeric<int64> value);
+
   // Delta in microseconds.
   int64 delta_;
 };
 
 template<typename T>
 inline TimeDelta operator*(T a, TimeDelta td) {
   return td * a;
 }
 
 // For logging use only.
@@ skipping 215 matching lines @@
     return *this;
   }
 
   // Compute the difference between two times.
   TimeDelta operator-(Time other) const {
     return TimeDelta(us_ - other.us_);
   }
 
   // Modify by some time delta.
   Time& operator+=(TimeDelta delta) {
-    us_ += delta.delta_;
+    us_ = delta.SaturatedAdd(us_);
     return *this;
   }
   Time& operator-=(TimeDelta delta) {
-    us_ -= delta.delta_;
+    us_ = -delta.SaturatedSub(us_);
     return *this;
   }
 
   // Return a new time modified by some delta.
   Time operator+(TimeDelta delta) const {
-    return Time(us_ + delta.delta_);
+    return Time(delta.SaturatedAdd(us_));
   }
   Time operator-(TimeDelta delta) const {
-    return Time(us_ - delta.delta_);
+    return Time(-delta.SaturatedSub(us_));
   }
 
   // Comparison operators
   bool operator==(Time other) const {
     return us_ == other.us_;
   }
   bool operator!=(Time other) const {
     return us_ != other.us_;
   }
   bool operator<(Time other) const {
@@ skipping 98 matching lines @@
 
 // static
 inline TimeDelta TimeDelta::FromMicroseconds(int64 us) {
   // Preserve max to prevent overflow.
   if (us == std::numeric_limits<int64>::max())
     return Max();
   return TimeDelta(us);
 }
 
 inline Time TimeDelta::operator+(Time t) const {
-  return Time(t.us_ + delta_);
+  return Time(SaturatedAdd(t.us_));
 }
 
 // For logging use only.
 BASE_EXPORT std::ostream& operator<<(std::ostream& os, Time time);
 
 // TimeTicks ------------------------------------------------------------------
 
 class BASE_EXPORT TimeTicks {
  public:
   // We define this even without OS_CHROMEOS for seccomp sandbox testing.
@@ skipping 61 matching lines @@
   // value has the same origin as Now(). Do NOT attempt to use this if
   // IsHighResolution() returns false.
   static TimeTicks FromQPCValue(LONGLONG qpc_value);
 #endif
 
   // Returns true if this object has not been initialized.
   bool is_null() const {
     return ticks_ == 0;
   }
 
+  // Returns true if the time delta is the maximum delta.
+  bool is_max() const {
+    return ticks_ == std::numeric_limits<int64>::max();
+  }
+
   // Converts an integer value representing TimeTicks to a class. This is used
   // when deserializing a |TimeTicks| structure, using a value known to be
   // compatible. It is not provided as a constructor because the integer type
   // may be unclear from the perspective of a caller.
   static TimeTicks FromInternalValue(int64 ticks) {
     return TimeTicks(ticks);
   }
 
   // Get the TimeTick value at the time of the UnixEpoch. This is useful when
   // you need to relate the value of TimeTicks to a real time and date.
@@ skipping 20 matching lines @@
     return *this;
   }
 
   // Compute the difference between two times.
   TimeDelta operator-(TimeTicks other) const {
     return TimeDelta(ticks_ - other.ticks_);
   }
 
   // Modify by some time delta.
   TimeTicks& operator+=(TimeDelta delta) {
-    ticks_ += delta.delta_;
+    ticks_ = delta.SaturatedAdd(ticks_);
     return *this;
   }
   TimeTicks& operator-=(TimeDelta delta) {
-    ticks_ -= delta.delta_;
+    ticks_ = -delta.SaturatedSub(ticks_);
     return *this;
   }
 
   // Return a new TimeTicks modified by some delta.
   TimeTicks operator+(TimeDelta delta) const {
-    return TimeTicks(ticks_ + delta.delta_);
+    return TimeTicks(delta.SaturatedAdd(ticks_));
   }
   TimeTicks operator-(TimeDelta delta) const {
-    return TimeTicks(ticks_ - delta.delta_);
+    return TimeTicks(-delta.SaturatedSub(ticks_));
   }
 
   // Comparison operators
   bool operator==(TimeTicks other) const {
     return ticks_ == other.ticks_;
   }
   bool operator!=(TimeTicks other) const {
     return ticks_ != other.ticks_;
   }
   bool operator<(TimeTicks other) const {
@@ skipping 20 matching lines @@
   // Tick count in microseconds.
   int64 ticks_;
 
 #if defined(OS_WIN)
   typedef DWORD (*TickFunctionType)(void);
   static TickFunctionType SetMockTickFunction(TickFunctionType ticker);
 #endif
 };
 
 inline TimeTicks TimeDelta::operator+(TimeTicks t) const {
-  return TimeTicks(t.ticks_ + delta_);
+  return TimeTicks(SaturatedAdd(t.ticks_));
 }
 
 // For logging use only.
 BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
 
 }  // namespace base
 
 #endif  // BASE_TIME_TIME_H_