Add logging support for base::Time* types.

base/time/time.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 <ios>
 #include <limits>
 #include <ostream>
+#include <sstream>
 
 #include "base/float_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/strings/stringprintf.h"
 #include "base/third_party/nspr/prtime.h"
 
 namespace base {
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::Max() {
   return TimeDelta(std::numeric_limits<int64>::max());
 }
@@ skipping 64 matching lines @@
 }
 
 int64 TimeDelta::InMicroseconds() const {
   if (is_max()) {
     // Preserve max to prevent overflow.
     return std::numeric_limits<int64>::max();
   }
   return delta_;
 }
 
+std::ostream& operator<<(std::ostream& os, TimeDelta time_delta) {
+  return os << time_delta.InSecondsF() << "s";
+}
+
 // Time -----------------------------------------------------------------------
 
 // static
 Time Time::Max() {
   return Time(std::numeric_limits<int64>::max());
 }
 
 // static
 Time Time::FromTimeT(time_t tt) {
   if (tt == 0)
@@ skipping 116 matching lines @@
                                        is_local ? PR_FALSE : PR_TRUE,
                                        &result_time);
   if (PR_SUCCESS != result)
     return false;
 
   result_time += kTimeTToMicrosecondsOffset;
   *parsed_time = Time(result_time);
   return true;
 }
 
+std::ostream& operator<<(std::ostream& os, Time time) {
+  Time::Exploded exploded;
+  time.UTCExplode(&exploded);
+  // Use StringPrintf because iostreams formatting is painful.
+  return os << StringPrintf("%04d-%02d-%02d %02d:%02d:%02d.%03d UTC",
+                            exploded.year,
+                            exploded.month,
+                            exploded.day_of_month,
+                            exploded.hour,
+                            exploded.minute,
+                            exploded.second,
+                            exploded.millisecond);
+}
+
 // Local helper class to hold the conversion from Time to TickTime at the
 // time of the Unix epoch.
 class UnixEpochSingleton {
  public:
   UnixEpochSingleton()
       : unix_epoch_(TimeTicks::Now() - (Time::Now() - Time::UnixEpoch())) {}
 
   TimeTicks unix_epoch() const { return unix_epoch_; }
 
  private:
   const TimeTicks unix_epoch_;
 
   DISALLOW_COPY_AND_ASSIGN(UnixEpochSingleton);
 };
 
 static LazyInstance<UnixEpochSingleton>::Leaky
     leaky_unix_epoch_singleton_instance = LAZY_INSTANCE_INITIALIZER;
 
 // Static
 TimeTicks TimeTicks::UnixEpoch() {
   return leaky_unix_epoch_singleton_instance.Get().unix_epoch();
 }
 
+std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks) {
+  // This function formats a TimeTicks object as "bogo-microseconds".
+  // The origin and granularity of the count are platform-specific, and may very
+  // from run to run. Although bogo-microseconds usually roughly correspond to
+  // real microseconds, the only real guarantee is that the number never goes
+  // down during a single run.
+  const TimeDelta as_time_delta = time_ticks - TimeTicks();
+  return os << as_time_delta.InMicroseconds() << " bogo-microseconds";
+}
+
 // Time::Exploded -------------------------------------------------------------
 
 inline bool is_in_range(int value, int lo, int hi) {
   return lo <= value && value <= hi;
 }
 
 bool Time::Exploded::HasValidValues() const {
   return is_in_range(month, 1, 12) &&
          is_in_range(day_of_week, 0, 6) &&
          is_in_range(day_of_month, 1, 31) &&
          is_in_range(hour, 0, 23) &&
          is_in_range(minute, 0, 59) &&
          is_in_range(second, 0, 60) &&
          is_in_range(millisecond, 0, 999);
 }
 
 }  // namespace base