posix: replace nonstandard futimes call with futimens

base/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.h"
 
 #include <time.h>
 
 #include "base/compiler_specific.h"
 #include "base/threading/platform_thread.h"
@@ skipping 83 matching lines @@
   EXPECT_EQ(epoch, Time::UnixEpoch());
   Time t = Time::FromJsTime(700000.3);
   EXPECT_EQ(700.0003, t.ToDoubleT());
   t = Time::FromDoubleT(800.73);
   EXPECT_EQ(800730.0, t.ToJsTime());
 }
 
 #if defined(OS_POSIX)
 TEST_F(TimeTest, FromTimeVal) {
   Time now = Time::Now();
-  Time also_now = Time::FromTimeVal(now.ToTimeVal());
+  timespec ts = now.ToTimeSpec();
+  timeval tv;
+  tv.tv_sec = ts.tv_sec;
+  tv.tv_usec = ts.tv_nsec / 1000;
+  Time also_now = Time::FromTimeVal(tv);
   EXPECT_EQ(now, also_now);
 }
 #endif  // OS_POSIX
 
 TEST_F(TimeTest, FromExplodedWithMilliseconds) {
   // Some platform implementations of FromExploded are liable to drop
   // milliseconds if we aren't careful.
   Time now = Time::NowFromSystemTime();
   Time::Exploded exploded1 = {0};
   now.UTCExplode(&exploded1);
@@ skipping 382 matching lines @@
 
   t = Time::FromJsTime(std::numeric_limits<double>::max());
   EXPECT_TRUE(t.is_max());
   EXPECT_EQ(std::numeric_limits<double>::max(), t.ToJsTime());
 
   t = Time::FromTimeT(std::numeric_limits<time_t>::max());
   EXPECT_TRUE(t.is_max());
   EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
 
 #if defined(OS_POSIX)
-  struct timeval tval;
+  timeval tval;
   tval.tv_sec = std::numeric_limits<time_t>::max();
   tval.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
   t = Time::FromTimeVal(tval);
   EXPECT_TRUE(t.is_max());
-  tval = t.ToTimeVal();
-  EXPECT_EQ(std::numeric_limits<time_t>::max(), tval.tv_sec);
-  EXPECT_EQ(static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1,
-      tval.tv_usec);
+  timespec tspec = t.ToTimeSpec();
+  EXPECT_EQ(std::numeric_limits<time_t>::max(), tspec.tv_sec);
+  EXPECT_EQ(static_cast<long>(Time::kNanosecondsPerSecond) - 1,
+      tspec.tv_nsec);
 #endif
 
 #if defined(OS_MACOSX)
   t = Time::FromCFAbsoluteTime(std::numeric_limits<CFAbsoluteTime>::max());
   EXPECT_TRUE(t.is_max());
   EXPECT_EQ(std::numeric_limits<CFAbsoluteTime>::max(), t.ToCFAbsoluteTime());
 #endif
 
 #if defined(OS_WIN)
   FILETIME ftime;
@@ skipping 141 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.
 }