Order function definitions in base/ according to the header.

base/time_posix.cc

 // Copyright (c) 2010 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 <sys/time.h>
 #include <time.h>
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 namespace base {
 
+struct timespec TimeDelta::ToTimeSpec() const {
+  int64 microseconds = InMicroseconds();
+  time_t seconds = 0;
+  if (microseconds >= Time::kMicrosecondsPerSecond) {
+    seconds = InSeconds();
+    microseconds -= seconds * Time::kMicrosecondsPerSecond;
+  }
+  struct timespec result =
+      {seconds,
+       microseconds * Time::kNanosecondsPerMicrosecond};
+  return result;
+}
+
 #if !defined(OS_MACOSX)
 // The Time routines in this file use standard POSIX routines, or almost-
 // standard routines in the case of timegm.  We need to use a Mach-specific
 // function for TimeTicks::Now() on Mac OS X.
 
 // Time -----------------------------------------------------------------------
 
 // Windows uses a Gregorian epoch of 1601.  We need to match this internally
 // so that our time representations match across all platforms.  See bug 14734.
 //   irb(main):010:0> Time.at(0).getutc()
@@ skipping 26 matching lines @@
   return Time((tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec) +
       kWindowsEpochDeltaMicroseconds);
 }
 
 // static
 Time Time::NowFromSystemTime() {
   // Just use Now() because Now() returns the system time.
   return Now();
 }
 
+void Time::Explode(bool is_local, Exploded* exploded) const {
+  // Time stores times with microsecond resolution, but Exploded only carries
+  // millisecond resolution, so begin by being lossy.  Adjust from Windows
+  // epoch (1601) to Unix epoch (1970);
+  int64 milliseconds = (us_ - kWindowsEpochDeltaMicroseconds) /
+      kMicrosecondsPerMillisecond;
+  time_t seconds = milliseconds / kMillisecondsPerSecond;
+
+  struct tm timestruct;
+  if (is_local)
+    localtime_r(&seconds, &timestruct);
+  else
+    gmtime_r(&seconds, &timestruct);
+
+  exploded->year         = timestruct.tm_year + 1900;
+  exploded->month        = timestruct.tm_mon + 1;
+  exploded->day_of_week  = timestruct.tm_wday;
+  exploded->day_of_month = timestruct.tm_mday;
+  exploded->hour         = timestruct.tm_hour;
+  exploded->minute       = timestruct.tm_min;
+  exploded->second       = timestruct.tm_sec;
+  exploded->millisecond  = milliseconds % kMillisecondsPerSecond;
+}
+
 // static
 Time Time::FromExploded(bool is_local, const Exploded& exploded) {
   struct tm timestruct;
   timestruct.tm_sec    = exploded.second;
   timestruct.tm_min    = exploded.minute;
   timestruct.tm_hour   = exploded.hour;
   timestruct.tm_mday   = exploded.day_of_month;
   timestruct.tm_mon    = exploded.month - 1;
   timestruct.tm_year   = exploded.year - 1900;
   timestruct.tm_wday   = exploded.day_of_week;  // mktime/timegm ignore this
@@ skipping 39 matching lines @@
     }
   } else {
     milliseconds = seconds * kMillisecondsPerSecond + exploded.millisecond;
   }
 
   // Adjust from Unix (1970) to Windows (1601) epoch.
   return Time((milliseconds * kMicrosecondsPerMillisecond) +
       kWindowsEpochDeltaMicroseconds);
 }
 
-void Time::Explode(bool is_local, Exploded* exploded) const {
-  // Time stores times with microsecond resolution, but Exploded only carries
-  // millisecond resolution, so begin by being lossy.  Adjust from Windows
-  // epoch (1601) to Unix epoch (1970);
-  int64 milliseconds = (us_ - kWindowsEpochDeltaMicroseconds) /
-      kMicrosecondsPerMillisecond;
-  time_t seconds = milliseconds / kMillisecondsPerSecond;
-
-  struct tm timestruct;
-  if (is_local)
-    localtime_r(&seconds, &timestruct);
-  else
-    gmtime_r(&seconds, &timestruct);
-
-  exploded->year         = timestruct.tm_year + 1900;
-  exploded->month        = timestruct.tm_mon + 1;
-  exploded->day_of_week  = timestruct.tm_wday;
-  exploded->day_of_month = timestruct.tm_mday;
-  exploded->hour         = timestruct.tm_hour;
-  exploded->minute       = timestruct.tm_min;
-  exploded->second       = timestruct.tm_sec;
-  exploded->millisecond  = milliseconds % kMillisecondsPerSecond;
-}
-
 // TimeTicks ------------------------------------------------------------------
 // FreeBSD 6 has CLOCK_MONOLITHIC but defines _POSIX_MONOTONIC_CLOCK to -1.
 #if (defined(OS_POSIX) &&                                               \
      defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0) || \
      defined(OS_FREEBSD) || defined(OS_OPENBSD)
 
 // static
 TimeTicks TimeTicks::Now() {
   uint64_t absolute_micro;
 
@@ skipping 14 matching lines @@
 #error No usable tick clock function on this platform.
 #endif  // _POSIX_MONOTONIC_CLOCK
 
 // static
 TimeTicks TimeTicks::HighResNow() {
   return Now();
 }
 
 #endif  // !OS_MACOSX
 
-struct timespec TimeDelta::ToTimeSpec() const {
-  int64 microseconds = InMicroseconds();
-  time_t seconds = 0;
-  if (microseconds >= Time::kMicrosecondsPerSecond) {
-    seconds = InSeconds();
-    microseconds -= seconds * Time::kMicrosecondsPerSecond;
-  }
-  struct timespec result =
-      {seconds,
-       microseconds * Time::kNanosecondsPerMicrosecond};
-  return result;
-}
-
 struct timeval Time::ToTimeVal() const {
   struct timeval result;
   int64 us = us_ - kTimeTToMicrosecondsOffset;
   result.tv_sec = us / Time::kMicrosecondsPerSecond;
   result.tv_usec = us % Time::kMicrosecondsPerSecond;
   return result;
 }
 
 }  // namespace base