Replaces deprecated CFGregorianDate with CFCalendar.

base/time/time_mac.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 <CoreFoundation/CFDate.h>
 #include <CoreFoundation/CFTimeZone.h>
 #include <mach/mach.h>
 #include <mach/mach_time.h>
@@ skipping 147 matching lines @@
 }
 
 // static
 Time Time::NowFromSystemTime() {
   // Just use Now() because Now() returns the system time.
   return Now();
 }
 
 // static
 Time Time::FromExploded(bool is_local, const Exploded& exploded) {
-  CFGregorianDate date;
-  date.second = exploded.second +
+  base::ScopedCFTypeRef<CFTimeZoneRef> time_zone(

[Nico, 2015/12/04 20:18:59]

I wondered why we don't just use time_posix.cc on Mac, and I found
https://codereview.chromium.org/9249 -- time_t is a long on OS X and we didn't
want y2k bugs. This is also explained around line 104 in this file. However, in
the 7 years since then we moved to an exclusively-64-bit build on mac, where
long is 64-bit. So I think we can probably delete this file and use
time_posix.cc again. Maybe that's a better fix?

[sdefresne, 2016/01/07 16:36:28]

iOS still target 32-bit platforms so the fact that time_t is a long should
probably still be relevant I think. Maybe we should continue using time_mac.cc
due to that. WDYT?

[pkl (ping after 24h if needed), 2016/02/03 06:42:31]

I've taken the route of keeping time_mac.cc based on sdefresne's input above.

+      is_local ? CFTimeZoneCopySystem() :
+          CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorDefault, 0));
+  base::ScopedCFTypeRef<CFCalendarRef> gregorian(
+      CFCalendarCreateWithIdentifier(kCFAllocatorDefault,
+                                     kCFGregorianCalendar));
+  CFCalendarSetTimeZone(gregorian, time_zone);
+  CFAbsoluteTime absolute_time;
+  CFCalendarComposeAbsoluteTime(gregorian, &absolute_time, "yMdHms",

[sdefresne, 2016/01/07 16:36:28]

nit: you can use "yMdHmS" to also pass the "exploded.millisecond" value (the 'S'
meaning 'millisecond' according to the opensource CFCalendar.c implementation
http://www.opensource.apple.com/source/CF/CF-855.17/CFCalendar.c).

[pkl (ping after 24h if needed), 2016/02/03 06:42:32]

Done. Also added a comment to explain 'S'.

+                                static_cast<int>(exploded.year),

[sdefresne, 2016/01/07 16:36:28]

nit: exploded.year, ... are all int, so the static_cast<int>() are not required

[pkl (ping after 24h if needed), 2016/02/03 06:42:31]

Done.

+                                static_cast<int>(exploded.month),
+                                static_cast<int>(exploded.day_of_month),
+                                static_cast<int>(exploded.hour),
+                                static_cast<int>(exploded.minute),
+                                static_cast<int>(exploded.second));
+  // Milliseconds from |exploded| is added back to |absolute_time| here
+  // because CFCalendar parameters are integer values.
+  double milliseconds =
       exploded.millisecond / static_cast<double>(kMillisecondsPerSecond);
-  date.minute = exploded.minute;
-  date.hour = exploded.hour;
-  date.day = exploded.day_of_month;
-  date.month = exploded.month;
-  date.year = exploded.year;
-
-  base::ScopedCFTypeRef<CFTimeZoneRef> time_zone(
-      is_local ? CFTimeZoneCopySystem() : NULL);
-  CFAbsoluteTime seconds = CFGregorianDateGetAbsoluteTime(date, time_zone) +
-      kCFAbsoluteTimeIntervalSince1970;
+  CFAbsoluteTime seconds =
+      absolute_time + milliseconds + kCFAbsoluteTimeIntervalSince1970;
   return Time(static_cast<int64>(seconds * kMicrosecondsPerSecond) +
       kWindowsEpochDeltaMicroseconds);
 }
 
 void Time::Explode(bool is_local, Exploded* exploded) const {
   // Avoid rounding issues, by only putting the integral number of seconds
   // (rounded towards -infinity) into a |CFAbsoluteTime| (which is a |double|).
   int64 microsecond = us_ % kMicrosecondsPerSecond;
   if (microsecond < 0)
     microsecond += kMicrosecondsPerSecond;
   CFAbsoluteTime seconds = ((us_ - microsecond) / kMicrosecondsPerSecond) -
                            kWindowsEpochDeltaSeconds -
                            kCFAbsoluteTimeIntervalSince1970;
 
   base::ScopedCFTypeRef<CFTimeZoneRef> time_zone(
-      is_local ? CFTimeZoneCopySystem() : NULL);
-  CFGregorianDate date = CFAbsoluteTimeGetGregorianDate(seconds, time_zone);
-  // 1 = Monday, ..., 7 = Sunday.
-  int cf_day_of_week = CFAbsoluteTimeGetDayOfWeek(seconds, time_zone);
+      is_local ? CFTimeZoneCopySystem() :
+          CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorDefault, 0));
+  base::ScopedCFTypeRef<CFCalendarRef> gregorian(
+      CFCalendarCreateWithIdentifier(kCFAllocatorDefault,
+                                     kCFGregorianCalendar));
+  CFCalendarSetTimeZone(gregorian, time_zone);
+  int year, month, day, hour, minute, second;
+  CFCalendarDecomposeAbsoluteTime(gregorian, seconds, "yMdHms", &year, &month,

[sdefresne, 2016/01/07 16:36:28]

nit: you can use "yMdHmsE" to also extract cf_day_of_week instead of calling
"CFCalendarGetOrdinalityOfUnit" (again the 'E' can be found in
http://www.opensource.apple.com/source/CF/CF-855.17/CFCalendar.c).

[pkl (ping after 24h if needed), 2016/02/03 06:42:31]

Done. Added 'E'.

+                                  &day, &hour, &minute, &second);

[sdefresne, 2016/01/07 16:36:28]

nit: you can also use &exploded->year, ... to avoid using local variables.

[pkl (ping after 24h if needed), 2016/02/03 06:42:31]

Changed to use &exploded->year etc. where appropriate.

 
-  exploded->year = date.year;
-  exploded->month = date.month;
-  exploded->day_of_week = cf_day_of_week % 7;
-  exploded->day_of_month = date.day;
-  exploded->hour = date.hour;
-  exploded->minute = date.minute;
+  // Calculate the day of week using CFCalendar, which returns 1 = Sunday,
+  // 2 = Monday, etc., then convert to |Exploded|'s 0 = Sunday convention.
+  CFIndex cf_day_of_week = CFCalendarGetOrdinalityOfUnit(
+      gregorian, kCFCalendarUnitWeekday, kCFCalendarUnitWeekOfMonth, seconds);
+
+  exploded->year = year;
+  exploded->month = month;
+  exploded->day_of_week = (cf_day_of_week - 1) % 7;
+  exploded->day_of_month = day;
+  exploded->hour = hour;
+  exploded->minute = minute;
   // Make sure seconds are rounded down towards -infinity.
-  exploded->second = floor(date.second);
+  exploded->second = floor(second);
   // Calculate milliseconds ourselves, since we rounded the |seconds|, making
   // sure to round towards -infinity.
   exploded->millisecond =
       (microsecond >= 0) ? microsecond / kMicrosecondsPerMillisecond :
                            (microsecond - kMicrosecondsPerMillisecond + 1) /
                                kMicrosecondsPerMillisecond;
 }
 
 // TimeTicks ------------------------------------------------------------------
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks(ComputeCurrentTicks());
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   return true;
 }
 
 // static
 ThreadTicks ThreadTicks::Now() {
   return ThreadTicks(ComputeThreadTicks());
 }
 
 }  // namespace base