Fix PPAPI time conversion code to handle epoch times.

This fixes the time conversion code to be able to correctly handle epoch times
(e.g. when passing a PP_Time of 0). This eliminates the need to special-case
for epoch time in other code. In practice the problem this fixes only
manifests itself in test code.

BUG=

Review URL: https://codereview.chromium.org/11567013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173516 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 80 insertions, 0 deletions

diff --git a/ppapi/ppapi_tests.gypi b/ppapi/ppapi_tests.gypi
index c989d9c..a229107 100644
--- a/ppapi/ppapi_tests.gypi
+++ b/ppapi/ppapi_tests.gypi
@@ -158,6 +158,7 @@
         'proxy/serialized_var_unittest.cc',
         'proxy/websocket_resource_unittest.cc',
         'shared_impl/resource_tracker_unittest.cc',
+        'shared_impl/time_conversion_unittest.cc',
         'shared_impl/tracked_callback_unittest.cc',
         'shared_impl/var_tracker_unittest.cc',
       ],
diff --git a/ppapi/shared_impl/time_conversion.cc b/ppapi/shared_impl/time_conversion.cc
index 53d7b99..07ca6f7 100644
--- a/ppapi/shared_impl/time_conversion.cc
+++ b/ppapi/shared_impl/time_conversion.cc
@@ -30,6 +30,12 @@ PP_Time TimeToPPTime(base::Time t) {
 }
 
 base::Time PPTimeToTime(PP_Time t) {
+  // The time code handles exact "0" values as special, and produces
+  // a "null" Time object. But calling code would expect t==0 to represent the
+  // epoch (according to the description of PP_Time). Hence we just return the
+  // epoch in this case.
+  if (t == 0.0)
+    return base::Time::UnixEpoch();
   return base::Time::FromDoubleT(t);
 }
 
diff --git a/ppapi/shared_impl/time_conversion_unittest.cc b/ppapi/shared_impl/time_conversion_unittest.cc
new file mode 100644
index 0000000..1ec70bf
--- /dev/null
+++ b/ppapi/shared_impl/time_conversion_unittest.cc
@@ -0,0 +1,73 @@
+// 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 <math.h>
+#include <stdlib.h>
+
+#include "ppapi/shared_impl/time_conversion.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace ppapi {
+
+// Slop we'll allow in two Time "internal values" to consider them equal.
+// Double conversion can introduce rounding errors. The internal values are in
+// microseconds, so an error here is very small.
+static const int kTimeInternalValueSlop = 2;
+
+// Same as above in double-precision seconds units.
+static const double kTimeSecondsSlop =
+    static_cast<double>(kTimeInternalValueSlop) /
+    base::Time::kMicrosecondsPerSecond;
+
+TEST(TimeConversion, Time) {
+  // Should be able to round-trip.
+  base::Time now = base::Time::Now();
+  base::Time converted = ppapi::PPTimeToTime(TimeToPPTime(now));
+  EXPECT_GE(kTimeInternalValueSlop,
+            abs(static_cast<int>((converted - now).ToInternalValue())));
+
+  // Units should be in seconds.
+  base::Time one_second_from_now = now + base::TimeDelta::FromSeconds(1);
+  double converted_one_second_from_now =
+      ppapi::TimeToPPTime(one_second_from_now) - ppapi::TimeToPPTime(now);
+  EXPECT_GE(kTimeSecondsSlop, fabs(converted_one_second_from_now - 1));
+}
+
+TEST(TimeConversion, EventTime) {
+  // Should be able to round-trip.
+  base::Time now = base::Time::Now();
+  double event_now = now.ToDoubleT();
+  double converted =
+      ppapi::EventTimeToPPTimeTicks(ppapi::PPTimeTicksToEventTime(event_now));
+  EXPECT_GE(kTimeSecondsSlop, fabs(converted - event_now));
+
+  // Units should be in seconds.
+  base::Time one_second_from_now = now + base::TimeDelta::FromSeconds(1);
+  double event_one_second_from_now = one_second_from_now.ToDoubleT();
+  EXPECT_GE(kTimeSecondsSlop,
+            1.0 - ppapi::EventTimeToPPTimeTicks(event_one_second_from_now) -
+                ppapi::EventTimeToPPTimeTicks(event_now));
+}
+
+TEST(TimeConversion, EpochTime) {
+  // Should be able to round-trip from epoch time.
+  base::Time epoch = base::Time::UnixEpoch();
+  base::Time converted = ppapi::PPTimeToTime(TimeToPPTime(epoch));
+  EXPECT_GE(kTimeInternalValueSlop,
+            abs(static_cast<int>((converted - epoch).ToInternalValue())));
+
+  // Units should be in seconds.
+  base::Time one_second_from_epoch = epoch + base::TimeDelta::FromSeconds(1);
+  double converted_one_second_from_epoch =
+      ppapi::TimeToPPTime(one_second_from_epoch) - ppapi::TimeToPPTime(epoch);
+  EXPECT_GE(kTimeSecondsSlop, fabs(converted_one_second_from_epoch - 1));
+
+  // Epoch time should be equal to a PP_Time of 0.0.
+  EXPECT_GE(kTimeSecondsSlop, fabs(ppapi::TimeToPPTime(epoch) - 0.0));
+  EXPECT_GE(kTimeInternalValueSlop,
+            abs(static_cast<int>(
+                (ppapi::PPTimeToTime(0.0) - epoch).ToInternalValue())));
+}
+
+}  // namespace ppapi