Prepare Chromium and Blink for ICU 59

base/i18n/time_formatting.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 "base/i18n/time_formatting.h"
 
 #include <stddef.h>
 
 #include <memory>
 
+#include "base/i18n/unicodestring.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "third_party/icu/source/common/unicode/utypes.h"
 #include "third_party/icu/source/i18n/unicode/datefmt.h"
 #include "third_party/icu/source/i18n/unicode/dtitvfmt.h"
 #include "third_party/icu/source/i18n/unicode/dtptngen.h"
 #include "third_party/icu/source/i18n/unicode/fmtable.h"
 #include "third_party/icu/source/i18n/unicode/measfmt.h"
 #include "third_party/icu/source/i18n/unicode/smpdtfmt.h"
 
 namespace base {
 namespace {
 
 string16 TimeFormat(const icu::DateFormat* formatter,
                     const Time& time) {
   DCHECK(formatter);
   icu::UnicodeString date_string;
 
   formatter->format(static_cast<UDate>(time.ToDoubleT() * 1000), date_string);
-  return string16(date_string.getBuffer(),
-                  static_cast<size_t>(date_string.length()));
+  return i18n::UnicodeStringToString16(date_string);
 }
 
 string16 TimeFormatWithoutAmPm(const icu::DateFormat* formatter,
                                const Time& time) {
   DCHECK(formatter);
   icu::UnicodeString time_string;
 
   icu::FieldPosition ampm_field(icu::DateFormat::kAmPmField);
   formatter->format(
       static_cast<UDate>(time.ToDoubleT() * 1000), time_string, ampm_field);
   int ampm_length = ampm_field.getEndIndex() - ampm_field.getBeginIndex();
   if (ampm_length) {
     int begin = ampm_field.getBeginIndex();
     // Doesn't include any spacing before the field.
     if (begin)
       begin--;
     time_string.removeBetween(begin, ampm_field.getEndIndex());
   }
-  return string16(time_string.getBuffer(),
-                  static_cast<size_t>(time_string.length()));
+  return i18n::UnicodeStringToString16(time_string);
 }
 
 icu::SimpleDateFormat CreateSimpleDateFormatter(const char* pattern) {
   // Generate a locale-dependent format pattern. The generator will take
   // care of locale-dependent formatting issues like which separator to
   // use (some locales use '.' instead of ':'), and where to put the am/pm
   // marker.
   UErrorCode status = U_ZERO_ERROR;
   std::unique_ptr<icu::DateTimePatternGenerator> generator(
       icu::DateTimePatternGenerator::createInstance(status));
@@ skipping 144 matching lines @@
   }
 
   icu::UnicodeString formatted;
   icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
   measure_format.formatMeasures(measures, 2, formatted, ignore, status);
   if (U_FAILURE(status)) {
     LOG(ERROR) << "formatMeasures failed: " << u_errorName(status);
     return false;
   }
 
-  *out = base::string16(formatted.getBuffer(), formatted.length());
+  *out = i18n::UnicodeStringToString16(formatted);
   return true;
 }
 
 bool TimeDurationFormatWithSeconds(const TimeDelta time,
                                    const DurationFormatWidth width,
                                    string16* out) {
   DCHECK(out);
   UErrorCode status = U_ZERO_ERROR;
   const int64_t total_seconds = static_cast<int>(time.InSecondsF() + 0.5);
   const int hours = total_seconds / 3600;
   const int minutes = (total_seconds - hours * 3600) / 60;
   const int seconds = total_seconds % 60;
   UMeasureFormatWidth u_width = DurationWidthToMeasureWidth(width);
 
   const icu::Measure measures[] = {
       icu::Measure(hours, icu::MeasureUnit::createHour(status), status),
       icu::Measure(minutes, icu::MeasureUnit::createMinute(status), status),
       icu::Measure(seconds, icu::MeasureUnit::createSecond(status), status)};
   icu::MeasureFormat measure_format(icu::Locale::getDefault(), u_width, status);
   icu::UnicodeString formatted;
   icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
   measure_format.formatMeasures(measures, 3, formatted, ignore, status);
-  *out = base::string16(formatted.getBuffer(), formatted.length());
+  *out = i18n::UnicodeStringToString16(formatted);
   return U_SUCCESS(status) == TRUE;
 }
 
 string16 DateIntervalFormat(const Time& begin_time,
                             const Time& end_time,
                             DateFormat format) {
   UErrorCode status = U_ZERO_ERROR;
 
   std::unique_ptr<icu::DateIntervalFormat> formatter(
       icu::DateIntervalFormat::createInstance(DateFormatToString(format),
                                               status));
 
   icu::FieldPosition pos = 0;
   UDate start_date = static_cast<UDate>(begin_time.ToDoubleT() * 1000);
   UDate end_date = static_cast<UDate>(end_time.ToDoubleT() * 1000);
   icu::DateInterval interval(start_date, end_date);
   icu::UnicodeString formatted;
   formatter->format(&interval, formatted, pos, status);
-  return string16(formatted.getBuffer(),
-                  static_cast<size_t>(formatted.length()));
+  return i18n::UnicodeStringToString16(formatted);
 }
 
 HourClockType GetHourClockType() {
   // TODO(satorux,jshin): Rework this with ures_getByKeyWithFallback()
   // once it becomes public. The short time format can be found at
   // "calendar/gregorian/DateTimePatterns/3" in the resources.
   std::unique_ptr<icu::SimpleDateFormat> formatter(
       static_cast<icu::SimpleDateFormat*>(
           icu::DateFormat::createTimeInstance(icu::DateFormat::kShort)));
   // Retrieve the short time format.
@@ skipping 23 matching lines @@
   // See http://userguide.icu-project.org/formatparse/datetime for details
   // about the date/time format syntax.
   if (pattern_unicode.indexOf('a') == -1) {
     return k24HourClock;
   } else {
     return k12HourClock;
   }
 }
 
 }  // namespace base