Make callers of FromUTC(Local)Exploded in base/ use new time API.

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 <stdint.h>
 #include <time.h>
 #include <limits>
 #include <string>
@@ skipping 108 matching lines @@
 
   // This will test both our exploding and our time_t -> Time conversion.
   EXPECT_EQ(tms.tm_year + 1900, exploded.year);
   EXPECT_EQ(tms.tm_mon + 1, exploded.month);
   EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
   EXPECT_EQ(tms.tm_hour, exploded.hour);
   EXPECT_EQ(tms.tm_min, exploded.minute);
   EXPECT_EQ(tms.tm_sec, exploded.second);
 
   // Convert exploded back to the time struct.
-  Time our_time_2 = Time::FromLocalExploded(exploded);
+  Time our_time_2;
+  EXPECT_TRUE(Time::FromLocalExploded(exploded, &our_time_2));
   EXPECT_TRUE(our_time_1 == our_time_2);
 
   time_t now_t_2 = our_time_2.ToTimeT();
   EXPECT_EQ(now_t_1, now_t_2);
 
   EXPECT_EQ(10, Time().FromTimeT(10).ToTimeT());
   EXPECT_EQ(10.0, Time().FromTimeT(10).ToDoubleT());
 
   // Conversions of 0 should stay 0.
   EXPECT_EQ(0, Time().ToTimeT());
@@ skipping 18 matching lines @@
 }
 #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);
   exploded1.millisecond = 500;
-  Time time = Time::FromUTCExploded(exploded1);
+  Time time;
+  EXPECT_TRUE(Time::FromUTCExploded(exploded1, &time));
   Time::Exploded exploded2 = {0};
   time.UTCExplode(&exploded2);
   EXPECT_EQ(exploded1.millisecond, exploded2.millisecond);
 }
 
 TEST_F(TimeTest, ZeroIsSymmetric) {
   Time zero_time(Time::FromTimeT(0));
   EXPECT_EQ(0, zero_time.ToTimeT());
 
   EXPECT_EQ(0.0, zero_time.ToDoubleT());
 }
 
 TEST_F(TimeTest, LocalExplode) {
   Time a = Time::Now();
   Time::Exploded exploded;
   a.LocalExplode(&exploded);
 
-  Time b = Time::FromLocalExploded(exploded);
+  Time b;
+  EXPECT_TRUE(Time::FromLocalExploded(exploded, &b));
 
   // The exploded structure doesn't have microseconds, and on Mac & Linux, the
   // internal OS conversion uses seconds, which will cause truncation. So we
   // can only make sure that the delta is within one second.
   EXPECT_TRUE((a - b) < TimeDelta::FromSeconds(1));
 }
 
 TEST_F(TimeTest, UTCExplode) {
   Time a = Time::Now();
   Time::Exploded exploded;
   a.UTCExplode(&exploded);
 
-  Time b = Time::FromUTCExploded(exploded);
+  Time b;
+  EXPECT_TRUE(Time::FromUTCExploded(exploded, &b));
   EXPECT_TRUE((a - b) < TimeDelta::FromSeconds(1));
 }
 
 TEST_F(TimeTest, LocalMidnight) {
   Time::Exploded exploded;
   Time::Now().LocalMidnight().LocalExplode(&exploded);
   EXPECT_EQ(0, exploded.hour);
   EXPECT_EQ(0, exploded.minute);
   EXPECT_EQ(0, exploded.second);
   EXPECT_EQ(0, exploded.millisecond);
@@ skipping 394 matching lines @@
                              13,    // day_of_month
                              0,     // hour
                              0,     // minute
                              0,     // second
   };
   // The string passed to putenv() must be a char* and the documentation states
   // that it 'becomes part of the environment', so use a static buffer.
   static char buffer[] = "TZ=America/Santiago";
   putenv(buffer);
   tzset();
-  Time t = Time::FromLocalExploded(midnight);
+  Time t;
+  EXPECT_TRUE(Time::FromLocalExploded(midnight, &t));
   EXPECT_EQ(1381633200, t.ToTimeT());
 }
 #endif  // OS_ANDROID
 
 TEST(TimeTicks, Deltas) {
   for (int index = 0; index < 50; index++) {
     TimeTicks ticks_start = TimeTicks::Now();
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
     TimeTicks ticks_stop = TimeTicks::Now();
     TimeDelta delta = ticks_stop - ticks_start;
@@ skipping 201 matching lines @@
 TEST(TimeDelta, WindowsEpoch) {
   Time::Exploded exploded;
   exploded.year = 1970;
   exploded.month = 1;
   exploded.day_of_week = 0;  // Should be unusued.
   exploded.day_of_month = 1;
   exploded.hour = 0;
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
-  Time t = Time::FromUTCExploded(exploded);
+  Time t;
+  EXPECT_TRUE(Time::FromUTCExploded(exploded, &t));
   // Unix 1970 epoch.
   EXPECT_EQ(INT64_C(11644473600000000), t.ToInternalValue());
 
   // We can't test 1601 epoch, since the system time functions on Linux
   // only compute years starting from 1900.
 }
 
 // We could define this separately for Time, TimeTicks and TimeDelta but the
 // definitions would be identical anyway.
 template <class Any>
@@ skipping 320 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base