Fixit: Factor out common base::Time* math operator overloads.

base/time/time.cc

 // 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.
 
 #include "base/time/time.h"
 
 #include <cmath>
 #include <ios>
 #include <limits>
 #include <ostream>
@@ skipping 79 matching lines @@
 }
 
 int64 TimeDelta::InMicroseconds() const {
   if (is_max()) {
     // Preserve max to prevent overflow.
     return std::numeric_limits<int64>::max();
   }
   return delta_;
 }
 
-int64 TimeDelta::SaturatedAdd(int64 value) const {
-  CheckedNumeric<int64> rv(delta_);
+namespace time_internal {
+
+int64 SaturatedAdd(TimeDelta delta, int64 value) {
+  CheckedNumeric<int64> rv(delta.delta_);
   rv += value;
   return FromCheckedNumeric(rv);
 }
 
-int64 TimeDelta::SaturatedSub(int64 value) const {
-  CheckedNumeric<int64> rv(delta_);
+int64 SaturatedSub(TimeDelta delta, int64 value) {
+  CheckedNumeric<int64> rv(delta.delta_);
   rv -= value;
   return FromCheckedNumeric(rv);
 }
 
-// static
-int64 TimeDelta::FromCheckedNumeric(const CheckedNumeric<int64> value) {
+int64 FromCheckedNumeric(const CheckedNumeric<int64> value) {
   if (value.IsValid())
     return value.ValueUnsafe();
 
   // We could return max/min but we don't really expose what the maximum delta
   // is. Instead, return max/(-max), which is something that clients can reason
   // about.
   // TODO(rvargas) crbug.com/332611: don't use internal values.
   int64 limit = std::numeric_limits<int64>::max();
   if (value.validity() == internal::RANGE_UNDERFLOW)
     limit = -limit;
   return value.ValueOrDefault(limit);
 }
 
+}  // namespace time_internal
+
 std::ostream& operator<<(std::ostream& os, TimeDelta time_delta) {
   return os << time_delta.InSecondsF() << "s";
 }
 
 // Time -----------------------------------------------------------------------
 
 // static
 Time Time::Max() {
   return Time(std::numeric_limits<int64>::max());
 }
@@ skipping 161 matching lines @@
 
 // Static
 TimeTicks TimeTicks::UnixEpoch() {
   return leaky_unix_epoch_singleton_instance.Get().unix_epoch();
 }
 
 TimeTicks TimeTicks::SnappedToNextTick(TimeTicks tick_phase,
                                        TimeDelta tick_interval) const {
   // |interval_offset| is the offset from |this| to the next multiple of
   // |tick_interval| after |tick_phase|, possibly negative if in the past.
-  TimeDelta interval_offset = TimeDelta::FromInternalValue(
-      (tick_phase - *this).ToInternalValue() % tick_interval.ToInternalValue());
+  TimeDelta interval_offset = (tick_phase - *this) % tick_interval;
   // If |this| is exactly on the interval (i.e. offset==0), don't adjust.
   // Otherwise, if |tick_phase| was in the past, adjust forward to the next
   // tick after |this|.
-  if (interval_offset.ToInternalValue() != 0 && tick_phase < *this) {
+  if (!interval_offset.is_zero() && tick_phase < *this)
     interval_offset += tick_interval;
-  }
-
   return *this + interval_offset;
 }
 
 std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks) {
   // This function formats a TimeTicks object as "bogo-microseconds".
   // The origin and granularity of the count are platform-specific, and may very
   // from run to run. Although bogo-microseconds usually roughly correspond to
   // real microseconds, the only real guarantee is that the number never goes
   // down during a single run.
   const TimeDelta as_time_delta = time_ticks - TimeTicks();
@@ skipping 10 matching lines @@
   return is_in_range(month, 1, 12) &&
          is_in_range(day_of_week, 0, 6) &&
          is_in_range(day_of_month, 1, 31) &&
          is_in_range(hour, 0, 23) &&
          is_in_range(minute, 0, 59) &&
          is_in_range(second, 0, 60) &&
          is_in_range(millisecond, 0, 999);
 }
 
 }  // namespace base