Add month and year to time_format.

ui/base/l10n/time_format.cc

 // Copyright (c) 2011 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 "ui/base/l10n/time_format.h"
 
 #include <limits>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 UI_BASE_EXPORT base::LazyInstance<FormatterContainer>::Leaky g_container =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 base::string16 TimeFormat::Simple(TimeFormat::Format format,
                                   TimeFormat::Length length,
                                   const base::TimeDelta& delta) {
   return Detailed(format, length, 0, delta);
 }
 
+base::string16 TimeFormat::SimpleWithMonthAndYear(TimeFormat::Format format,
+                                                  TimeFormat::Length length,
+                                                  const base::TimeDelta& delta,
+                                                  bool with_month_and_year) {
+  return DetailedWithMonthAndYear(format, length, 0, delta,
+                                  with_month_and_year);
+}
+
 // static
 base::string16 TimeFormat::Detailed(TimeFormat::Format format,
                                     TimeFormat::Length length,
                                     int cutoff,
                                     const base::TimeDelta& delta) {
+  return DetailedWithMonthAndYear(format, length, cutoff, delta, false);
+}
+
+base::string16 TimeFormat::DetailedWithMonthAndYear(
+    TimeFormat::Format format,
+    TimeFormat::Length length,
+    int cutoff,
+    const base::TimeDelta& delta,
+    bool with_month_and_year) {
   if (delta < TimeDelta::FromSeconds(0)) {
     NOTREACHED() << "Negative duration";
     return base::string16();
   }
 
   // Negative cutoff: always use two-value format.
   if (cutoff < 0)
     cutoff = std::numeric_limits<int>::max();
 
   const TimeDelta one_minute(TimeDelta::FromMinutes(1));
   const TimeDelta one_hour(TimeDelta::FromHours(1));
   const TimeDelta one_day(TimeDelta::FromDays(1));
+
+  // An average month is a twelfth of a year.
+  const TimeDelta one_month(TimeDelta::FromDays(365) / 12);
+
+  // Simplify one year to be 365 days.
+  const TimeDelta one_year(TimeDelta::FromDays(365));
+
   const TimeDelta half_second(TimeDelta::FromMilliseconds(500));
   const TimeDelta half_minute(TimeDelta::FromSeconds(30));
   const TimeDelta half_hour(TimeDelta::FromMinutes(30));
   const TimeDelta half_day(TimeDelta::FromHours(12));
 
   // Rationale: Start by determining major (first) unit, then add minor (second)
   // unit if mandated by |cutoff|.
   icu::UnicodeString time_string;
   const Formatter* formatter = g_container.Get().Get(format, length);
   if (delta < one_minute - half_second) {
@@ skipping 22 matching lines @@
     // minutes).
     if (delta >= cutoff * one_hour - half_minute) {
       const int hours = (delta + half_hour).InHours();
       formatter->Format(Formatter::UNIT_HOUR, hours, &time_string);
     } else {
       const int hours = (delta + half_minute).InHours();
       const int minutes = (delta + half_minute).InMinutes() % 60;
       formatter->Format(Formatter::TWO_UNITS_HOUR_MIN,
                         hours, minutes, &time_string);
     }
-
-  } else {
+  } else if (!with_month_and_year || delta < one_month) {
     // Anything bigger is formatted as days (respectively days and hours).
     if (delta >= cutoff * one_day - half_hour) {
       const int days = (delta + half_day).InDays();
       formatter->Format(Formatter::UNIT_DAY, days, &time_string);
     } else {
       const int days = (delta + half_hour).InDays();
       const int hours = (delta + half_hour).InHours() % 24;
       formatter->Format(Formatter::TWO_UNITS_DAY_HOUR,
                         days, hours, &time_string);
     }
+  } else if (delta < one_year) {
+    DCHECK(with_month_and_year);
+    int month = delta / one_month;
+    DCHECK(month >= 1 && month <= 12);
+    formatter->Format(Formatter::UNIT_MONTH, month, &time_string);
+  } else {
+    DCHECK(with_month_and_year);
+    int year = delta / one_year;
+    formatter->Format(Formatter::UNIT_YEAR, year, &time_string);
   }
 
   const int capacity = time_string.length() + 1;
   DCHECK_GT(capacity, 1);
   base::string16 result;
   UErrorCode error = U_ZERO_ERROR;
   time_string.extract(static_cast<UChar*>(base::WriteInto(&result, capacity)),
                       capacity, error);
   DCHECK(U_SUCCESS(error));
   return result;
@@ skipping 11 matching lines @@
   if (time >= tomorrow)
     return base::string16();
   else if (time >= midnight_today)
     return l10n_util::GetStringUTF16(IDS_PAST_TIME_TODAY);
   else if (time >= yesterday)
     return l10n_util::GetStringUTF16(IDS_PAST_TIME_YESTERDAY);
   return base::string16();
 }
 
 }  // namespace ui