Removing the use of base::Time inside the LayerTreeHost system.

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 <limits>
 #include <ostream>
 
 #include "base/float_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/third_party/nspr/prtime.h"
 #include "base/third_party/nspr/prtypes.h"
 
 namespace base {
@@ skipping 189 matching lines @@
 };
 
 static LazyInstance<UnixEpochSingleton>::Leaky
     leaky_unix_epoch_singleton_instance = LAZY_INSTANCE_INITIALIZER;
 
 // Static
 TimeTicks TimeTicks::UnixEpoch() {
   return leaky_unix_epoch_singleton_instance.Get().unix_epoch();
 }
 
+TimeTicks TimeTicks::FromWebKit(double dt) {
+  // Outside of 2**53 the conversion to/from double isn't presevative.
+
+  if (dt == 0 || IsNaN(dt))
+    return TimeTicks();  // Preserve 0 so we can tell it doesn't exist.
+
+  double dus = dt * static_cast<double>(Time::kMicrosecondsPerSecond);
+
+  // Check double isn't too big for an int64
+  if (dus >= static_cast<double>(std::numeric_limits<int64>::max()))
+    return TimeTicks(std::numeric_limits<int64>::max());
+  if (dus <= static_cast<double>(std::numeric_limits<int64>::min()))
+    return TimeTicks(std::numeric_limits<int64>::min());
+
+  int64 epoch_us = static_cast<int64>(dus);
+
+  // Make sure the Epoch adjustment won't cause over/under flow.
+  if (UnixEpoch().ticks_ > 0 &&
+      epoch_us >= std::numeric_limits<int64>::max() - UnixEpoch().ticks_)
+    return TimeTicks(std::numeric_limits<int64>::max());
+  if (UnixEpoch().ticks_ < 0 &&
+      epoch_us <= std::numeric_limits<int64>::min() - UnixEpoch().ticks_)
+    return TimeTicks(std::numeric_limits<int64>::min());
+
+  return TimeTicks(epoch_us + UnixEpoch().ticks_);
+}
+
+double TimeTicks::ToWebKit() const {
+  if (is_null())
+    return 0;  // Preserve 0 so we can tell it doesn't exist.
+
+  if (ticks_ == std::numeric_limits<int64>::max())
+    return std::numeric_limits<double>::infinity();
+  if (ticks_ == std::numeric_limits<int64>::min())
+    return -std::numeric_limits<double>::infinity();
+
+  return (static_cast<double>(ticks_ - UnixEpoch().ticks_) /
+          static_cast<double>(Time::kMicrosecondsPerSecond));
+}
+
 // Time::Exploded -------------------------------------------------------------
 
 inline bool is_in_range(int value, int lo, int hi) {
   return lo <= value && value <= hi;
 }
 
 bool Time::Exploded::HasValidValues() const {
   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