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

base/time/time_unittest.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 <time.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
@@ skipping 636 matching lines @@
     TimeDelta difference = delta - delta_thread;
     EXPECT_GE(difference.InMicroseconds(), 9000);
   }
 }
 
 TEST(TimeTicks, NowFromSystemTraceTime) {
   // Re-use HighResNow test for now since clock properties are identical.
   HighResClockTest(&TimeTicks::NowFromSystemTraceTime);
 }
 
+TEST(TimeTicks, WebKitConversion) {
+  double double_null = 0;
+  double double_max = std::numeric_limits<double>::max();
+  double double_min = std::numeric_limits<double>::lowest();
+  double double_positive_inf = std::numeric_limits<double>::infinity();
+  double double_negative_inf = -std::numeric_limits<double>::infinity();
+
+  TimeTicks ticks_null = TimeTicks();
+  TimeTicks ticks_min =
+      TimeTicks::FromInternalValue(std::numeric_limits<int64>::min());
+  TimeTicks ticks_max =
+      TimeTicks::FromInternalValue(std::numeric_limits<int64>::max());
+
+  EXPECT_EQ(ticks_null, TimeTicks::FromWebKit(double_null));
+  EXPECT_EQ(ticks_max, TimeTicks::FromWebKit(double_max));
+  EXPECT_EQ(ticks_min, TimeTicks::FromWebKit(double_min));
+  EXPECT_EQ(ticks_max, TimeTicks::FromWebKit(double_positive_inf));
+  EXPECT_EQ(ticks_min, TimeTicks::FromWebKit(double_negative_inf));
+
+  EXPECT_EQ(double_null, ticks_null.ToWebKit());
+  EXPECT_EQ(double_negative_inf, ticks_min.ToWebKit());
+  EXPECT_EQ(double_positive_inf, ticks_max.ToWebKit());
+
+  // Round trip some values
+  // Outside of 2**53 the int64->double->int64 round trip isn't exact.
+  for (int i = -53; i < 53; i++) {
+    if (!i)
+      continue;
+
+    SCOPED_TRACE(i);
+    double i_abs = abs(static_cast<double>(i));
+
+    TimeTicks ticks_value = TimeTicks::FromInternalValue(
+        static_cast<int64>((i / i_abs) * pow(2.0, i_abs)));
+    EXPECT_EQ(TimeTicks::FromWebKit(ticks_value.ToWebKit()), ticks_value);
+
+    double double_value = (i / i_abs) * pow(2.0, i_abs) / 1e6;
+    EXPECT_EQ(TimeTicks::FromWebKit(double_value).ToWebKit(), double_value);
+  }
+}
+
 TEST(TimeDelta, FromAndIn) {
   EXPECT_TRUE(TimeDelta::FromDays(2) == TimeDelta::FromHours(48));
   EXPECT_TRUE(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180));
   EXPECT_TRUE(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120));
   EXPECT_TRUE(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000));
   EXPECT_TRUE(TimeDelta::FromMilliseconds(2) ==
               TimeDelta::FromMicroseconds(2000));
   EXPECT_EQ(13, TimeDelta::FromDays(13).InDays());
   EXPECT_EQ(13, TimeDelta::FromHours(13).InHours());
   EXPECT_EQ(13, TimeDelta::FromMinutes(13).InMinutes());
@@ skipping 38 matching lines @@
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
   Time t = Time::FromUTCExploded(exploded);
   // Unix 1970 epoch.
   EXPECT_EQ(GG_INT64_C(11644473600000000), t.ToInternalValue());
 
   // We can't test 1601 epoch, since the system time functions on Linux
   // only compute years starting from 1900.
 }