Add support for localized time strings with two units, eg. "2 hours 17 minutes"

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 <vector>

[bartfab (slow), 2014/02/18 12:04:04]

Nit: No longer used.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

 
 #include "base/lazy_instance.h"
-#include "base/logging.h"

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Still used for NOTREACHED(), DCHECK() and friends.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

-#include "base/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.h"
-#include "base/stl_util.h"
-#include "base/strings/string16.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "grit/ui_strings.h"
-#include "third_party/icu/source/common/unicode/locid.h"
-#include "third_party/icu/source/i18n/unicode/datefmt.h"
-#include "third_party/icu/source/i18n/unicode/plurfmt.h"
-#include "third_party/icu/source/i18n/unicode/plurrule.h"
-#include "third_party/icu/source/i18n/unicode/smpdtfmt.h"
+#include "third_party/icu/source/common/unicode/unistr.h"
+#include "ui/base/l10n/formatter.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/l10n/l10n_util_plurals.h"
 
 using base::Time;
 using base::TimeDelta;
 
-namespace {
+using ui::TimeFormat;
 
-static const char kFallbackFormatSuffixAgo[] = " ago}";
-static const char kFallbackFormatSuffixLeft[] = " left}";
-static const char kFallbackFormatSuffixDuration[] = "}";
+namespace ui {
 
-// Contains message IDs for various time units and pluralities.
-struct MessageIDs {
-  // There are 4 different time units and 6 different pluralities.
-  int ids[4][6];
-};
-
-// Message IDs for different time formats.
-static const MessageIDs kTimeElapsedMessageIDs = { {
-  {
-    IDS_TIME_ELAPSED_SECS_DEFAULT, IDS_TIME_ELAPSED_SEC_SINGULAR,
-    IDS_TIME_ELAPSED_SECS_ZERO, IDS_TIME_ELAPSED_SECS_TWO,
-    IDS_TIME_ELAPSED_SECS_FEW, IDS_TIME_ELAPSED_SECS_MANY
-  },
-  {
-    IDS_TIME_ELAPSED_MINS_DEFAULT, IDS_TIME_ELAPSED_MIN_SINGULAR,
-    IDS_TIME_ELAPSED_MINS_ZERO, IDS_TIME_ELAPSED_MINS_TWO,
-    IDS_TIME_ELAPSED_MINS_FEW, IDS_TIME_ELAPSED_MINS_MANY
-  },
-  {
-    IDS_TIME_ELAPSED_HOURS_DEFAULT, IDS_TIME_ELAPSED_HOUR_SINGULAR,
-    IDS_TIME_ELAPSED_HOURS_ZERO, IDS_TIME_ELAPSED_HOURS_TWO,
-    IDS_TIME_ELAPSED_HOURS_FEW, IDS_TIME_ELAPSED_HOURS_MANY
-  },
-  {
-    IDS_TIME_ELAPSED_DAYS_DEFAULT, IDS_TIME_ELAPSED_DAY_SINGULAR,
-    IDS_TIME_ELAPSED_DAYS_ZERO, IDS_TIME_ELAPSED_DAYS_TWO,
-    IDS_TIME_ELAPSED_DAYS_FEW, IDS_TIME_ELAPSED_DAYS_MANY
-  }
-} };
-
-static const MessageIDs kTimeRemainingMessageIDs = { {
-  {
-    IDS_TIME_REMAINING_SECS_DEFAULT, IDS_TIME_REMAINING_SEC_SINGULAR,
-    IDS_TIME_REMAINING_SECS_ZERO, IDS_TIME_REMAINING_SECS_TWO,
-    IDS_TIME_REMAINING_SECS_FEW, IDS_TIME_REMAINING_SECS_MANY
-  },
-  {
-    IDS_TIME_REMAINING_MINS_DEFAULT, IDS_TIME_REMAINING_MIN_SINGULAR,
-    IDS_TIME_REMAINING_MINS_ZERO, IDS_TIME_REMAINING_MINS_TWO,
-    IDS_TIME_REMAINING_MINS_FEW, IDS_TIME_REMAINING_MINS_MANY
-  },
-  {
-    IDS_TIME_REMAINING_HOURS_DEFAULT, IDS_TIME_REMAINING_HOUR_SINGULAR,
-    IDS_TIME_REMAINING_HOURS_ZERO, IDS_TIME_REMAINING_HOURS_TWO,
-    IDS_TIME_REMAINING_HOURS_FEW, IDS_TIME_REMAINING_HOURS_MANY
-  },
-  {
-    IDS_TIME_REMAINING_DAYS_DEFAULT, IDS_TIME_REMAINING_DAY_SINGULAR,
-    IDS_TIME_REMAINING_DAYS_ZERO, IDS_TIME_REMAINING_DAYS_TWO,
-    IDS_TIME_REMAINING_DAYS_FEW, IDS_TIME_REMAINING_DAYS_MANY
-  }
-} };
-
-static const MessageIDs kTimeRemainingLongMessageIDs = { {
-  {
-    IDS_TIME_REMAINING_LONG_SECS_DEFAULT, IDS_TIME_REMAINING_LONG_SEC_SINGULAR,
-    IDS_TIME_REMAINING_LONG_SECS_ZERO, IDS_TIME_REMAINING_LONG_SECS_TWO,
-    IDS_TIME_REMAINING_LONG_SECS_FEW, IDS_TIME_REMAINING_LONG_SECS_MANY
-  },
-  {
-    IDS_TIME_REMAINING_LONG_MINS_DEFAULT, IDS_TIME_REMAINING_LONG_MIN_SINGULAR,
-    IDS_TIME_REMAINING_LONG_MINS_ZERO, IDS_TIME_REMAINING_LONG_MINS_TWO,
-    IDS_TIME_REMAINING_LONG_MINS_FEW, IDS_TIME_REMAINING_LONG_MINS_MANY
-  },
-  {
-    IDS_TIME_REMAINING_HOURS_DEFAULT, IDS_TIME_REMAINING_HOUR_SINGULAR,
-    IDS_TIME_REMAINING_HOURS_ZERO, IDS_TIME_REMAINING_HOURS_TWO,
-    IDS_TIME_REMAINING_HOURS_FEW, IDS_TIME_REMAINING_HOURS_MANY
-  },
-  {
-    IDS_TIME_REMAINING_DAYS_DEFAULT, IDS_TIME_REMAINING_DAY_SINGULAR,
-    IDS_TIME_REMAINING_DAYS_ZERO, IDS_TIME_REMAINING_DAYS_TWO,
-    IDS_TIME_REMAINING_DAYS_FEW, IDS_TIME_REMAINING_DAYS_MANY
-  }
-} };
-
-static const MessageIDs kTimeDurationShortMessageIDs = { {
-  {
-    IDS_TIME_SECS_DEFAULT, IDS_TIME_SEC_SINGULAR, IDS_TIME_SECS_ZERO,
-    IDS_TIME_SECS_TWO, IDS_TIME_SECS_FEW, IDS_TIME_SECS_MANY
-  },
-  {
-    IDS_TIME_MINS_DEFAULT, IDS_TIME_MIN_SINGULAR, IDS_TIME_MINS_ZERO,
-    IDS_TIME_MINS_TWO, IDS_TIME_MINS_FEW, IDS_TIME_MINS_MANY
-  },
-  {
-    IDS_TIME_HOURS_DEFAULT, IDS_TIME_HOUR_SINGULAR, IDS_TIME_HOURS_ZERO,
-    IDS_TIME_HOURS_TWO, IDS_TIME_HOURS_FEW, IDS_TIME_HOURS_MANY
-  },
-  {
-    IDS_TIME_DAYS_DEFAULT, IDS_TIME_DAY_SINGULAR, IDS_TIME_DAYS_ZERO,
-    IDS_TIME_DAYS_TWO, IDS_TIME_DAYS_FEW, IDS_TIME_DAYS_MANY
-  }
-} };
-
-static const MessageIDs kTimeDurationLongMessageIDs = { {
-  {
-    IDS_TIME_DURATION_LONG_SECS_DEFAULT, IDS_TIME_DURATION_LONG_SEC_SINGULAR,
-    IDS_TIME_DURATION_LONG_SECS_ZERO, IDS_TIME_DURATION_LONG_SECS_TWO,
-    IDS_TIME_DURATION_LONG_SECS_FEW, IDS_TIME_DURATION_LONG_SECS_MANY
-  },
-  {
-    IDS_TIME_DURATION_LONG_MINS_DEFAULT, IDS_TIME_DURATION_LONG_MIN_SINGULAR,
-    IDS_TIME_DURATION_LONG_MINS_ZERO, IDS_TIME_DURATION_LONG_MINS_TWO,
-    IDS_TIME_DURATION_LONG_MINS_FEW, IDS_TIME_DURATION_LONG_MINS_MANY
-  },
-  {
-    IDS_TIME_HOURS_DEFAULT, IDS_TIME_HOUR_SINGULAR,
-    IDS_TIME_HOURS_ZERO, IDS_TIME_HOURS_TWO,
-    IDS_TIME_HOURS_FEW, IDS_TIME_HOURS_MANY
-  },
-  {
-    IDS_TIME_DAYS_DEFAULT, IDS_TIME_DAY_SINGULAR,
-    IDS_TIME_DAYS_ZERO, IDS_TIME_DAYS_TWO,
-    IDS_TIME_DAYS_FEW, IDS_TIME_DAYS_MANY
-  }
-} };
-
-// Different format types.
-enum FormatType {
-  FORMAT_ELAPSED,
-  FORMAT_REMAINING,
-  FORMAT_REMAINING_LONG,
-  FORMAT_DURATION_SHORT,
-  FORMAT_DURATION_LONG,
-};
-
-class TimeFormatter {
-  public:
-    const std::vector<icu::PluralFormat*>& formatter(FormatType format_type) {
-      switch (format_type) {
-        case FORMAT_ELAPSED:
-          return time_elapsed_formatter_.get();
-        case FORMAT_REMAINING:
-          return time_left_formatter_.get();
-        case FORMAT_REMAINING_LONG:
-          return time_left_long_formatter_.get();
-        case FORMAT_DURATION_SHORT:
-          return time_duration_short_formatter_.get();
-        case FORMAT_DURATION_LONG:
-          return time_duration_long_formatter_.get();
-        default:
-          NOTREACHED();
-          return time_duration_short_formatter_.get();
-      }
-    }
-  private:
-    static const MessageIDs& GetMessageIDs(FormatType format_type) {
-      switch (format_type) {
-        case FORMAT_ELAPSED:
-          return kTimeElapsedMessageIDs;
-        case FORMAT_REMAINING:
-          return kTimeRemainingMessageIDs;
-        case FORMAT_REMAINING_LONG:
-          return kTimeRemainingLongMessageIDs;
-        case FORMAT_DURATION_SHORT:
-          return kTimeDurationShortMessageIDs;
-        case FORMAT_DURATION_LONG:
-          return kTimeDurationLongMessageIDs;
-        default:
-          NOTREACHED();
-          return kTimeDurationShortMessageIDs;
-      }
-    }
-
-    static const char* GetFallbackFormatSuffix(FormatType format_type) {
-      switch (format_type) {
-        case FORMAT_ELAPSED:
-          return kFallbackFormatSuffixAgo;
-        case FORMAT_REMAINING:
-        case FORMAT_REMAINING_LONG:
-          return kFallbackFormatSuffixLeft;
-        case FORMAT_DURATION_SHORT:
-        case FORMAT_DURATION_LONG:
-          return kFallbackFormatSuffixDuration;
-        default:
-          NOTREACHED();
-          return kFallbackFormatSuffixDuration;
-      }
-    }
-
-    TimeFormatter() {
-      BuildFormats(FORMAT_ELAPSED, &time_elapsed_formatter_);
-      BuildFormats(FORMAT_REMAINING, &time_left_formatter_);
-      BuildFormats(FORMAT_REMAINING_LONG, &time_left_long_formatter_);
-      BuildFormats(FORMAT_DURATION_SHORT, &time_duration_short_formatter_);
-      BuildFormats(FORMAT_DURATION_LONG, &time_duration_long_formatter_);
-    }
-    ~TimeFormatter() {
-    }
-    friend struct base::DefaultLazyInstanceTraits<TimeFormatter>;
-
-    ScopedVector<icu::PluralFormat> time_elapsed_formatter_;
-    ScopedVector<icu::PluralFormat> time_left_formatter_;
-    ScopedVector<icu::PluralFormat> time_left_long_formatter_;
-    ScopedVector<icu::PluralFormat> time_duration_short_formatter_;
-    ScopedVector<icu::PluralFormat> time_duration_long_formatter_;
-    static void BuildFormats(FormatType format_type,
-                             ScopedVector<icu::PluralFormat>* time_formats);
-    static icu::PluralFormat* createFallbackFormat(
-        const icu::PluralRules& rules, int index, FormatType format_type);
-
-    DISALLOW_COPY_AND_ASSIGN(TimeFormatter);
-};
-
-static base::LazyInstance<TimeFormatter> g_time_formatter =
+static base::LazyInstance<FormatterContainer> g_container =
     LAZY_INSTANCE_INITIALIZER;
 
-void TimeFormatter::BuildFormats(
-    FormatType format_type, ScopedVector<icu::PluralFormat>* time_formats) {
-  const MessageIDs& message_ids = GetMessageIDs(format_type);
-
-  for (int i = 0; i < 4; ++i) {
-    icu::UnicodeString pattern;
-    std::vector<int> ids;
-    for (size_t j = 0; j < arraysize(message_ids.ids[i]); ++j) {
-      ids.push_back(message_ids.ids[i][j]);
-    }
-    scoped_ptr<icu::PluralFormat> format = l10n_util::BuildPluralFormat(ids);
-    if (format) {
-      time_formats->push_back(format.release());
-    } else {
-      scoped_ptr<icu::PluralRules> rules(l10n_util::BuildPluralRules());
-      time_formats->push_back(createFallbackFormat(*rules, i, format_type));
-    }
-  }
-}
-
-// Create a hard-coded fallback plural format. This will never be called
-// unless translators make a mistake.
-icu::PluralFormat* TimeFormatter::createFallbackFormat(
-    const icu::PluralRules& rules, int index, FormatType format_type) {
-  const icu::UnicodeString kUnits[4][2] = {
-    { UNICODE_STRING_SIMPLE("sec"), UNICODE_STRING_SIMPLE("secs") },
-    { UNICODE_STRING_SIMPLE("min"), UNICODE_STRING_SIMPLE("mins") },
-    { UNICODE_STRING_SIMPLE("hour"), UNICODE_STRING_SIMPLE("hours") },
-    { UNICODE_STRING_SIMPLE("day"), UNICODE_STRING_SIMPLE("days") }
-  };
-  icu::UnicodeString suffix(GetFallbackFormatSuffix(format_type), -1, US_INV);
-  icu::UnicodeString pattern;
-  if (rules.isKeyword(UNICODE_STRING_SIMPLE("one"))) {
-    pattern += UNICODE_STRING_SIMPLE("one{# ") + kUnits[index][0] + suffix;
-  }
-  pattern += UNICODE_STRING_SIMPLE(" other{# ") + kUnits[index][1] + suffix;
-  UErrorCode err = U_ZERO_ERROR;
-  icu::PluralFormat* format = new icu::PluralFormat(rules, pattern, err);
-  DCHECK(U_SUCCESS(err));
-  return format;
-}
-
-base::string16 FormatTimeImpl(const TimeDelta& delta, FormatType format_type) {
+// static
+base::string16 TimeFormat::FormatTimeImpl(const FormatterContainer& container,
+                                          Type type,
+                                          Length length,
+                                          int cutoff,
+                                          const TimeDelta& delta) {
   if (delta < TimeDelta::FromSeconds(0)) {
     NOTREACHED() << "Negative duration";
     return base::string16();
   }
 
-  const std::vector<icu::PluralFormat*>& formatters =
-    g_time_formatter.Get().formatter(format_type);
-
-  UErrorCode error = U_ZERO_ERROR;
   icu::UnicodeString time_string;
 
   const TimeDelta one_minute(TimeDelta::FromMinutes(1));
   const TimeDelta one_hour(TimeDelta::FromHours(1));
   const TimeDelta one_day(TimeDelta::FromDays(1));
 
   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));
 
   // Less than 59.5 seconds gets "X seconds left", anything larger is

[bartfab (slow), 2014/02/18 12:04:04]

Nit, here and below: Comments like this one go inside the block, not before it:

if (delta < one_minute - half_second) {
  // Less than 59.5 seconds gets "X seconds left", anything larger is
  // rounded to minutes.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

   // rounded to minutes.
   if (delta < one_minute - half_second) {
-    const int seconds = static_cast<int>((delta + half_second).InSeconds());
-    time_string = formatters[0]->format(seconds, error);
+    int seconds = static_cast<int>((delta + half_second).InSeconds());
+    container.Get(type, length)->Format(Formatter::SEC, seconds, time_string);
 
   // Less than 59.5 minutes gets "X minutes left", anything larger is
   // rounded to hours.
-  } else if (delta < one_hour - half_minute) {
-    const int minutes = (delta + half_minute).InMinutes();
-    time_string = formatters[1]->format(minutes, error);
+  } else if (delta < one_hour - (cutoff<60 ? half_minute : half_second)) {

[bartfab (slow), 2014/02/18 12:04:04]

1) Please update the comment to explain where the choice between |half_minute|
and |half_second| comes from.
2) Nit: Add spaces around <

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+    if (delta < cutoff * one_minute - half_second) {

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Add a comment that explains what these if/else branches are about.

[Thiemo Nagel, 2014/02/19 17:08:44]

This (hopefully) is now explained in time_format.h very well, I'd rather let the
code speak for itself here.

+      int minutes = (delta + half_second).InMinutes();

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+      int seconds = static_cast<int>(

[bartfab (slow), 2014/02/18 12:04:04]

Nit 1: const.
Nit 2: Would it not be simpler to do this instead:

const int seconds = (delta + half_second).InSeconds() % 60;

[Thiemo Nagel, 2014/02/19 17:08:44]

Would that not imply using exactly the kind of knowledge that TimeDelta wants to
abstract away?

[bartfab (slow), 2014/02/20 16:31:22]

I don't think TimeDelta is trying to abstract away the fact that a minute has 60
seconds. What TimeDelta does is to store an arbitrarily long amount of time,
allowing you convert between units. Once you know you want seconds, it seems
perfectly fine to call InSeconds() % 60.

[Thiemo Nagel, 2014/02/22 21:44:09]

Done.

+          (delta - TimeDelta::FromMinutes(minutes) + half_second).InSeconds());
+      container.Get(type, length)->Format(Formatter::MIN_SEC, minutes, seconds,
+                                          time_string);
+    } else {
+      int minutes = (delta + half_minute).InMinutes();

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+      container.Get(type, length)->Format(Formatter::MIN, minutes, time_string);
+    }
 
   // Less than 23.5 hours gets "X hours left", anything larger is
   // rounded to days.
-  } else if (delta < one_day - half_hour) {
-    const int hours = (delta + half_hour).InHours();
-    time_string = formatters[2]->format(hours, error);
+  } else if (delta < one_day - (cutoff<24 ? half_hour : half_minute)) {

[bartfab (slow), 2014/02/18 12:04:04]

1) Please update the comment to explain where the choice between |half_hour| and
|half_minute| comes from.
2) Nit: Add spaces around <

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+    if (delta < cutoff * one_hour - half_minute) {

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Add a comment that explains what these if/else branches are about.

[Thiemo Nagel, 2014/02/19 17:08:44]

see above

+      int hours = (delta + half_minute).InHours();

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+      int minutes =

[bartfab (slow), 2014/02/18 12:04:04]

Nit 1: const.
Nit 2: Would it not be simpler to do this instead:

const int minutes = (delta + half_minute).InMinutes() % 60;

[Thiemo Nagel, 2014/02/19 17:08:44]

see above

+          (delta - TimeDelta::FromHours(hours) + half_minute).InMinutes();
+      container.Get(type, length)->Format(Formatter::HOUR_MIN, hours, minutes,
+                                          time_string);
+    } else {
+      int hours = (delta + half_hour).InHours();

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+      container.Get(type, length)->Format(Formatter::HOUR, hours, time_string);
+    }
 
   // Anything bigger gets "X days left".
   } else {
-    const int days = (delta + half_day).InDays();
-    time_string = formatters[3]->format(days, error);
+    if (delta < cutoff * one_day - half_hour) {

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Add a comment that explains what these if/else branches are about.

[Thiemo Nagel, 2014/02/19 17:08:44]

see above

+      int days = (delta + half_hour).InDays();

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+      int hours = (delta - TimeDelta::FromDays(days) + half_hour).InHours();

[bartfab (slow), 2014/02/18 12:04:04]

Nit 1: const.
Nit 2: Would it not be simpler to do this instead:

const int hours = (delta + half_hour).InHours() % 24;

[Thiemo Nagel, 2014/02/19 17:08:44]

see above

+      container.Get(type, length)->Format(Formatter::DAY_HOUR, days, hours,
+                                          time_string);
+    } else {
+      int days = (delta + half_day).InDays();

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+      container.Get(type, length)->Format(Formatter::DAY, days, time_string);
+    }
   }
 
   // With the fallback added, this should never fail.

[bartfab (slow), 2014/02/18 12:04:04]

Nit: IIUC, this comment referred to the DCHECK() just below it that you removed.
Hence, you should remove the comment as well.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

-  DCHECK(U_SUCCESS(error));
   int capacity = time_string.length() + 1;

[bartfab (slow), 2014/02/18 12:04:04]

Nit: const.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

   DCHECK_GT(capacity, 1);
   base::string16 result;
+  UErrorCode error = U_ZERO_ERROR;
   time_string.extract(static_cast<UChar*>(WriteInto(&result, capacity)),

[bartfab (slow), 2014/02/18 12:04:04]

Nit: #include "base/strings/string_util.h"

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

                       capacity, error);
   DCHECK(U_SUCCESS(error));
   return result;
 }
 
-}  // namespace
-
-namespace ui {
-
 // static
-base::string16 TimeFormat::TimeElapsed(const TimeDelta& delta) {
-  return FormatTimeImpl(delta, FORMAT_ELAPSED);
+base::string16 TimeFormat::Simple(TimeFormat::Type type,
+                                  TimeFormat::Length length,
+                                  const base::TimeDelta& delta) {
+  return Detailed(type, length, 0, delta);

[bartfab (slow), 2014/02/18 12:04:04]

Nit: I think it would be clearer if you just called FormatTimeImpl() from here.
One less indirection to follow when trying to understand how this works.

[Thiemo Nagel, 2014/02/19 17:08:44]

Obsolete now as FormatTimeImpl() has been removed.

 }
 
 // static
-base::string16 TimeFormat::TimeRemaining(const TimeDelta& delta) {
-  return FormatTimeImpl(delta, FORMAT_REMAINING);
+base::string16 TimeFormat::Detailed(TimeFormat::Type type,
+                                    TimeFormat::Length length,
+                                    int cutoff,
+                                    const base::TimeDelta& delta) {
+  return FormatTimeImpl(g_container.Get(), type, length, cutoff, delta);
 }
 
 // static
-base::string16 TimeFormat::TimeRemainingLong(const TimeDelta& delta) {
-  return FormatTimeImpl(delta, FORMAT_REMAINING_LONG);
-}
-
-// static
-base::string16 TimeFormat::TimeDurationShort(const TimeDelta& delta) {
-  return FormatTimeImpl(delta, FORMAT_DURATION_SHORT);
-}
-
-// static
-base::string16 TimeFormat::TimeDurationLong(const TimeDelta& delta) {
-  return FormatTimeImpl(delta, FORMAT_DURATION_LONG);
-}
-
-// static
 base::string16 TimeFormat::RelativeDate(
     const Time& time,
     const Time* optional_midnight_today) {
   Time midnight_today = optional_midnight_today ? *optional_midnight_today :
       Time::Now().LocalMidnight();
   TimeDelta day = TimeDelta::FromMicroseconds(Time::kMicrosecondsPerDay);
   Time tomorrow = midnight_today + day;
   Time yesterday = midnight_today - day;
   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