Fixing Time::Max()'s behavior with Time::ToTimeT() and friends.

base/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.h"
 
 #include <math.h>
 #if defined(OS_WIN)
 #include <float.h>
 #endif
@@ skipping 56 matching lines @@
 
 // static
 Time Time::Max() {
   return Time(std::numeric_limits<int64>::max());
 }
 
 // static
 Time Time::FromTimeT(time_t tt) {
   if (tt == 0)
     return Time();  // Preserve 0 so we can tell it doesn't exist.
+  if (tt == std::numeric_limits<time_t>::max())
+    return Max();
   return Time((tt * kMicrosecondsPerSecond) + kTimeTToMicrosecondsOffset);
 }
 
 time_t Time::ToTimeT() const {
-  if (us_ == 0)
+  if (is_null())
     return 0;  // Preserve 0 so we can tell it doesn't exist.
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<time_t>::max();
+  }
   return (us_ - kTimeTToMicrosecondsOffset) / kMicrosecondsPerSecond;

[msarda, 2012/09/06 15:04:34]

There is still a risk of overflow here: us_ might still be big enough without
actually being equal to std::numeric_limits<int64>::max().
I would add a DLOG(WARNING) in case there is an overflow and return
std::numeric_limits<time_t>::max().

[Mike West, 2012/09/06 19:51:16]

Good point. I've added the log. This one looks like the only one that can
overflow based on the offset. The rest of the conversions are doubles, or on
platforms where the offset is 0.

 }
 
 // static
 Time Time::FromDoubleT(double dt) {
   if (dt == 0 || isnan(dt))
     return Time();  // Preserve 0 so we can tell it doesn't exist.
+  if (dt == std::numeric_limits<double>::max())
+    return Max();
   return Time(static_cast<int64>((dt *
                                   static_cast<double>(kMicrosecondsPerSecond)) +
                                  kTimeTToMicrosecondsOffset));
 }
 
 double Time::ToDoubleT() const {
-  if (us_ == 0)
+  if (is_null())
     return 0;  // Preserve 0 so we can tell it doesn't exist.
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<double>::max();
+  }
   return (static_cast<double>(us_ - kTimeTToMicrosecondsOffset) /
           static_cast<double>(kMicrosecondsPerSecond));
 }
 
 // static
 Time Time::FromJsTime(double ms_since_epoch) {
   // The epoch is a valid time, so this constructor doesn't interpret
   // 0 as the null time.
+  if (ms_since_epoch == std::numeric_limits<double>::max())
+    return Max();
   return Time(static_cast<int64>(ms_since_epoch * kMicrosecondsPerMillisecond) +
               kTimeTToMicrosecondsOffset);
 }
 
 double Time::ToJsTime() const {
-  if (us_ == 0) {
+  if (is_null()) {
     // Preserve 0 so the invalid result doesn't depend on the platform.
     return 0;
   }
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<double>::max();
+  }
   return (static_cast<double>(us_ - kTimeTToMicrosecondsOffset) /
           kMicrosecondsPerMillisecond);
 }
 
 // static
 Time Time::UnixEpoch() {
   Time time;
   time.us_ = kTimeTToMicrosecondsOffset;
   return time;
 }
@@ skipping 36 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