Remove base/i18n
Change-Id: Ic84e5156febcca4e6813ca30fd0a245664c84648
Reviewed-on: https://gn-review.googlesource.com/1421
Reviewed-by: Brett Wilson <brettw@chromium.org>
Commit-Queue: Scott Graham <scottmg@chromium.org>
diff --git a/base/i18n/OWNERS b/base/i18n/OWNERS
deleted file mode 100644
index d717b8d..0000000
--- a/base/i18n/OWNERS
+++ /dev/null
@@ -1 +0,0 @@
-jshin@chromium.org
diff --git a/base/i18n/base_i18n_export.h b/base/i18n/base_i18n_export.h
deleted file mode 100644
index e8a2add..0000000
--- a/base/i18n/base_i18n_export.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_BASE_I18N_EXPORT_H_
-#define BASE_I18N_BASE_I18N_EXPORT_H_
-
-#if defined(COMPONENT_BUILD)
-#if defined(WIN32)
-
-#if defined(BASE_I18N_IMPLEMENTATION)
-#define BASE_I18N_EXPORT __declspec(dllexport)
-#else
-#define BASE_I18N_EXPORT __declspec(dllimport)
-#endif // defined(BASE_I18N_IMPLEMENTATION)
-
-#else // defined(WIN32)
-#if defined(BASE_I18N_IMPLEMENTATION)
-#define BASE_I18N_EXPORT __attribute__((visibility("default")))
-#else
-#define BASE_I18N_EXPORT
-#endif
-#endif
-
-#else // defined(COMPONENT_BUILD)
-#define BASE_I18N_EXPORT
-#endif
-
-#endif // BASE_I18N_BASE_I18N_EXPORT_H_
diff --git a/base/i18n/base_i18n_switches.cc b/base/i18n/base_i18n_switches.cc
deleted file mode 100644
index 103d665..0000000
--- a/base/i18n/base_i18n_switches.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2015 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/base_i18n_switches.h"
-
-namespace switches {
-
-// Force the UI to a specific direction. Valid values are "ltr" (left-to-right)
-// and "rtl" (right-to-left).
-const char kForceUIDirection[] = "force-ui-direction";
-
-// Force the text rendering to a specific direction. Valid values are "ltr"
-// (left-to-right) and "rtl" (right-to-left). Only tested meaningfully with
-// RTL.
-const char kForceTextDirection[] = "force-text-direction";
-
-const char kForceDirectionLTR[] = "ltr";
-const char kForceDirectionRTL[] = "rtl";
-
-} // namespace switches
diff --git a/base/i18n/base_i18n_switches.h b/base/i18n/base_i18n_switches.h
deleted file mode 100644
index d1ba690..0000000
--- a/base/i18n/base_i18n_switches.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef BASE_I18N_BASE_I18N_SWITCHES_H_
-#define BASE_I18N_BASE_I18N_SWITCHES_H_
-
-#include "base/i18n/base_i18n_export.h"
-
-namespace switches {
-
-BASE_I18N_EXPORT extern const char kForceUIDirection[];
-BASE_I18N_EXPORT extern const char kForceTextDirection[];
-
-// kForce*Direction choices for the switches above.
-BASE_I18N_EXPORT extern const char kForceDirectionLTR[];
-BASE_I18N_EXPORT extern const char kForceDirectionRTL[];
-
-} // namespace switches
-
-#endif // BASE_I18N_BASE_I18N_SWITCHES_H_
diff --git a/base/i18n/bidi_line_iterator.cc b/base/i18n/bidi_line_iterator.cc
deleted file mode 100644
index 3f7f868..0000000
--- a/base/i18n/bidi_line_iterator.cc
+++ /dev/null
@@ -1,119 +0,0 @@
-// 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/bidi_line_iterator.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace i18n {
-
-namespace {
-
-UBiDiLevel GetParagraphLevelForDirection(TextDirection direction) {
- switch (direction) {
- case UNKNOWN_DIRECTION:
- return UBIDI_DEFAULT_LTR;
- break;
- case RIGHT_TO_LEFT:
- return 1; // Highest RTL level.
- break;
- case LEFT_TO_RIGHT:
- return 0; // Highest LTR level.
- break;
- default:
- NOTREACHED();
- return 0;
- }
-}
-
-// Overrides the default bidi class for a given character, for the custom
-// "AS_URL" behavior. Returns U_BIDI_CLASS_DEFAULT to defer to the default ICU
-// behavior.
-//
-// Matches the C callback interface of ICU's UBiDiClassCallback type (which is
-// why there is an unused argument).
-UCharDirection GetURLBiDiClassCallback(const void* /*unused*/, UChar32 c) {
- // Note: Use a switch statement instead of strchr() to avoid iterating over a
- // string for each character (the switch allows for much better compiler
- // optimization).
- switch (c) {
- // The set of characters that delimit URL components (separating the scheme,
- // username, password, domain labels, host, path segments, query
- // names/values and fragment).
- case '#':
- case '&':
- case '.':
- case '/':
- case ':':
- case '=':
- case '?':
- case '@':
- // Treat all of these characters as strong LTR, which effectively
- // surrounds all of the text components of a URL (e.g., the domain labels
- // and path segments) in a left-to-right embedding. This ensures that the
- // URL components read from left to right, regardless of any RTL
- // characters. (Within each component, RTL sequences are rendered from
- // right to left as expected.)
- return U_LEFT_TO_RIGHT;
- default:
- return U_BIDI_CLASS_DEFAULT;
- }
-}
-
-} // namespace
-
-BiDiLineIterator::BiDiLineIterator() : bidi_(nullptr) {}
-
-BiDiLineIterator::~BiDiLineIterator() {
- if (bidi_) {
- ubidi_close(bidi_);
- bidi_ = nullptr;
- }
-}
-
-bool BiDiLineIterator::Open(const string16& text,
- TextDirection direction,
- CustomBehavior behavior) {
- DCHECK(!bidi_);
- UErrorCode error = U_ZERO_ERROR;
- bidi_ = ubidi_openSized(static_cast<int>(text.length()), 0, &error);
- if (U_FAILURE(error))
- return false;
-
- if (behavior == CustomBehavior::AS_URL) {
- ubidi_setClassCallback(bidi_, GetURLBiDiClassCallback, nullptr, nullptr,
- nullptr, &error);
- if (U_FAILURE(error))
- return false;
- }
-
- ubidi_setPara(bidi_, text.data(), static_cast<int>(text.length()),
- GetParagraphLevelForDirection(direction), nullptr, &error);
- return (U_SUCCESS(error));
-}
-
-int BiDiLineIterator::CountRuns() const {
- DCHECK(bidi_ != nullptr);
- UErrorCode error = U_ZERO_ERROR;
- const int runs = ubidi_countRuns(bidi_, &error);
- return U_SUCCESS(error) ? runs : 0;
-}
-
-UBiDiDirection BiDiLineIterator::GetVisualRun(int index,
- int* start,
- int* length) const {
- DCHECK(bidi_ != nullptr);
- return ubidi_getVisualRun(bidi_, index, start, length);
-}
-
-void BiDiLineIterator::GetLogicalRun(int start,
- int* end,
- UBiDiLevel* level) const {
- DCHECK(bidi_ != nullptr);
- ubidi_getLogicalRun(bidi_, start, end, level);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/bidi_line_iterator.h b/base/i18n/bidi_line_iterator.h
deleted file mode 100644
index d840f61..0000000
--- a/base/i18n/bidi_line_iterator.h
+++ /dev/null
@@ -1,60 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_BIDI_LINE_ITERATOR_H_
-#define BASE_I18N_BIDI_LINE_ITERATOR_H_
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/i18n/rtl.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "third_party/icu/source/common/unicode/ubidi.h"
-#include "third_party/icu/source/common/unicode/uchar.h"
-
-namespace base {
-namespace i18n {
-
-// A simple wrapper class for the bidirectional iterator of ICU.
-// This class uses the bidirectional iterator of ICU to split a line of
-// bidirectional texts into visual runs in its display order.
-class BASE_I18N_EXPORT BiDiLineIterator {
- public:
- // Specifies some alternative iteration behavior.
- enum class CustomBehavior {
- // No special behavior.
- NONE,
- // Treat URL delimiter characters as strong LTR. This is a special treatment
- // for URLs that purposefully violates the URL Standard, as an experiment.
- // It should only be used behind a flag.
- AS_URL
- };
-
- BiDiLineIterator();
- ~BiDiLineIterator();
-
- // Initializes the bidirectional iterator with the specified text. Returns
- // whether initialization succeeded.
- bool Open(const string16& text,
- TextDirection direction,
- CustomBehavior behavior);
-
- // Returns the number of visual runs in the text, or zero on error.
- int CountRuns() const;
-
- // Gets the logical offset, length, and direction of the specified visual run.
- UBiDiDirection GetVisualRun(int index, int* start, int* length) const;
-
- // Given a start position, figure out where the run ends (and the BiDiLevel).
- void GetLogicalRun(int start, int* end, UBiDiLevel* level) const;
-
- private:
- UBiDi* bidi_;
-
- DISALLOW_COPY_AND_ASSIGN(BiDiLineIterator);
-};
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_BIDI_LINE_ITERATOR_H_
diff --git a/base/i18n/break_iterator.cc b/base/i18n/break_iterator.cc
deleted file mode 100644
index 251cd00..0000000
--- a/base/i18n/break_iterator.cc
+++ /dev/null
@@ -1,191 +0,0 @@
-// 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/break_iterator.h"
-
-#include <stdint.h>
-
-#include "base/logging.h"
-#include "third_party/icu/source/common/unicode/ubrk.h"
-#include "third_party/icu/source/common/unicode/uchar.h"
-#include "third_party/icu/source/common/unicode/ustring.h"
-
-namespace base {
-namespace i18n {
-
-const size_t npos = static_cast<size_t>(-1);
-
-BreakIterator::BreakIterator(const StringPiece16& str, BreakType break_type)
- : iter_(nullptr),
- string_(str),
- break_type_(break_type),
- prev_(npos),
- pos_(0) {}
-
-BreakIterator::BreakIterator(const StringPiece16& str, const string16& rules)
- : iter_(nullptr),
- string_(str),
- rules_(rules),
- break_type_(RULE_BASED),
- prev_(npos),
- pos_(0) {}
-
-BreakIterator::~BreakIterator() {
- if (iter_)
- ubrk_close(static_cast<UBreakIterator*>(iter_));
-}
-
-bool BreakIterator::Init() {
- UErrorCode status = U_ZERO_ERROR;
- UParseError parse_error;
- UBreakIteratorType break_type;
- switch (break_type_) {
- case BREAK_CHARACTER:
- break_type = UBRK_CHARACTER;
- break;
- case BREAK_WORD:
- break_type = UBRK_WORD;
- break;
- case BREAK_LINE:
- case BREAK_NEWLINE:
- case RULE_BASED: // (Keep compiler happy, break_type not used in this case)
- break_type = UBRK_LINE;
- break;
- default:
- NOTREACHED() << "invalid break_type_";
- return false;
- }
- if (break_type_ == RULE_BASED) {
- iter_ = ubrk_openRules(rules_.c_str(),
- static_cast<int32_t>(rules_.length()),
- string_.data(),
- static_cast<int32_t>(string_.size()),
- &parse_error,
- &status);
- if (U_FAILURE(status)) {
- NOTREACHED() << "ubrk_openRules failed to parse rule string at line "
- << parse_error.line << ", offset " << parse_error.offset;
- }
- } else {
- iter_ = ubrk_open(break_type, nullptr, string_.data(),
- static_cast<int32_t>(string_.size()), &status);
- if (U_FAILURE(status)) {
- NOTREACHED() << "ubrk_open failed for type " << break_type
- << " with error " << status;
- }
- }
-
- if (U_FAILURE(status)) {
- return false;
- }
-
- // Move the iterator to the beginning of the string.
- ubrk_first(static_cast<UBreakIterator*>(iter_));
- return true;
-}
-
-bool BreakIterator::Advance() {
- int32_t pos;
- int32_t status;
- prev_ = pos_;
- switch (break_type_) {
- case BREAK_CHARACTER:
- case BREAK_WORD:
- case BREAK_LINE:
- case RULE_BASED:
- pos = ubrk_next(static_cast<UBreakIterator*>(iter_));
- if (pos == UBRK_DONE) {
- pos_ = npos;
- return false;
- }
- pos_ = static_cast<size_t>(pos);
- return true;
- case BREAK_NEWLINE:
- do {
- pos = ubrk_next(static_cast<UBreakIterator*>(iter_));
- if (pos == UBRK_DONE)
- break;
- pos_ = static_cast<size_t>(pos);
- status = ubrk_getRuleStatus(static_cast<UBreakIterator*>(iter_));
- } while (status >= UBRK_LINE_SOFT && status < UBRK_LINE_SOFT_LIMIT);
- if (pos == UBRK_DONE && prev_ == pos_) {
- pos_ = npos;
- return false;
- }
- return true;
- default:
- NOTREACHED() << "invalid break_type_";
- return false;
- }
-}
-
-bool BreakIterator::SetText(const base::char16* text, const size_t length) {
- UErrorCode status = U_ZERO_ERROR;
- ubrk_setText(static_cast<UBreakIterator*>(iter_),
- text, length, &status);
- pos_ = 0; // implicit when ubrk_setText is done
- prev_ = npos;
- if (U_FAILURE(status)) {
- NOTREACHED() << "ubrk_setText failed";
- return false;
- }
- string_ = StringPiece16(text, length);
- return true;
-}
-
-bool BreakIterator::IsWord() const {
- return GetWordBreakStatus() == IS_WORD_BREAK;
-}
-
-BreakIterator::WordBreakStatus BreakIterator::GetWordBreakStatus() const {
- int32_t status = ubrk_getRuleStatus(static_cast<UBreakIterator*>(iter_));
- if (break_type_ != BREAK_WORD && break_type_ != RULE_BASED)
- return IS_LINE_OR_CHAR_BREAK;
- // In ICU 60, trying to advance past the end of the text does not change
- // |status| so that |pos_| has to be checked as well as |status|.
- // See http://bugs.icu-project.org/trac/ticket/13447 .
- return (status == UBRK_WORD_NONE || pos_ == npos) ? IS_SKIPPABLE_WORD
- : IS_WORD_BREAK;
-}
-
-bool BreakIterator::IsEndOfWord(size_t position) const {
- if (break_type_ != BREAK_WORD && break_type_ != RULE_BASED)
- return false;
-
- UBreakIterator* iter = static_cast<UBreakIterator*>(iter_);
- UBool boundary = ubrk_isBoundary(iter, static_cast<int32_t>(position));
- int32_t status = ubrk_getRuleStatus(iter);
- return (!!boundary && status != UBRK_WORD_NONE);
-}
-
-bool BreakIterator::IsStartOfWord(size_t position) const {
- if (break_type_ != BREAK_WORD && break_type_ != RULE_BASED)
- return false;
-
- UBreakIterator* iter = static_cast<UBreakIterator*>(iter_);
- UBool boundary = ubrk_isBoundary(iter, static_cast<int32_t>(position));
- ubrk_next(iter);
- int32_t next_status = ubrk_getRuleStatus(iter);
- return (!!boundary && next_status != UBRK_WORD_NONE);
-}
-
-bool BreakIterator::IsGraphemeBoundary(size_t position) const {
- if (break_type_ != BREAK_CHARACTER)
- return false;
-
- UBreakIterator* iter = static_cast<UBreakIterator*>(iter_);
- return !!ubrk_isBoundary(iter, static_cast<int32_t>(position));
-}
-
-string16 BreakIterator::GetString() const {
- return GetStringPiece().as_string();
-}
-
-StringPiece16 BreakIterator::GetStringPiece() const {
- DCHECK(prev_ != npos && pos_ != npos);
- return string_.substr(prev_, pos_ - prev_);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/break_iterator.h b/base/i18n/break_iterator.h
deleted file mode 100644
index dc30b64..0000000
--- a/base/i18n/break_iterator.h
+++ /dev/null
@@ -1,182 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_BREAK_ITERATOR_H_
-#define BASE_I18N_BREAK_ITERATOR_H_
-
-#include <stddef.h>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
-// The BreakIterator class iterates through the words, word breaks, and
-// line breaks in a UTF-16 string.
-//
-// It provides several modes, BREAK_WORD, BREAK_LINE, and BREAK_NEWLINE,
-// which modify how characters are aggregated into the returned string.
-//
-// Under BREAK_WORD mode, once a word is encountered any non-word
-// characters are not included in the returned string (e.g. in the
-// UTF-16 equivalent of the string " foo bar! ", the word breaks are at
-// the periods in ". .foo. .bar.!. .").
-// Note that Chinese/Japanese/Thai do not use spaces between words so that
-// boundaries can fall in the middle of a continuous run of non-space /
-// non-punctuation characters.
-//
-// Under BREAK_LINE mode, once a line breaking opportunity is encountered,
-// any non-word characters are included in the returned string, breaking
-// only when a space-equivalent character or a line breaking opportunity
-// is encountered (e.g. in the UTF16-equivalent of the string " foo bar! ",
-// the breaks are at the periods in ". .foo .bar! .").
-//
-// Note that lines can be broken at any character/syllable/grapheme cluster
-// boundary in Chinese/Japanese/Korean and at word boundaries in Thai
-// (Thai does not use spaces between words). Therefore, this is NOT the same
-// as breaking only at space-equivalent characters where its former
-// name (BREAK_SPACE) implied.
-//
-// Under BREAK_NEWLINE mode, all characters are included in the returned
-// string, breaking only when a newline-equivalent character is encountered
-// (eg. in the UTF-16 equivalent of the string "foo\nbar!\n\n", the line
-// breaks are at the periods in ".foo\n.bar\n.\n.").
-//
-// To extract the words from a string, move a BREAK_WORD BreakIterator
-// through the string and test whether IsWord() is true. E.g.,
-// BreakIterator iter(str, BreakIterator::BREAK_WORD);
-// if (!iter.Init())
-// return false;
-// while (iter.Advance()) {
-// if (iter.IsWord()) {
-// // Region [iter.prev(), iter.pos()) contains a word.
-// VLOG(1) << "word: " << iter.GetString();
-// }
-// }
-
-namespace base {
-namespace i18n {
-
-class BASE_I18N_EXPORT BreakIterator {
- public:
- enum BreakType {
- BREAK_WORD,
- BREAK_LINE,
- // TODO(jshin): Remove this after reviewing call sites.
- // If call sites really need break only on space-like characters
- // implement it separately.
- BREAK_SPACE = BREAK_LINE,
- BREAK_NEWLINE,
- BREAK_CHARACTER,
- // But don't remove this one!
- RULE_BASED,
- };
-
- enum WordBreakStatus {
- // The end of text that the iterator recognizes as word characters.
- // Non-word characters are things like punctuation and spaces.
- IS_WORD_BREAK,
- // Characters that the iterator can skip past, such as punctuation,
- // whitespace, and, if using RULE_BASED mode, characters from another
- // character set.
- IS_SKIPPABLE_WORD,
- // Only used if not in BREAK_WORD or RULE_BASED mode. This is returned for
- // newlines, line breaks, and character breaks.
- IS_LINE_OR_CHAR_BREAK
- };
-
- // Requires |str| to live as long as the BreakIterator does.
- BreakIterator(const StringPiece16& str, BreakType break_type);
- // Make a rule-based iterator. BreakType == RULE_BASED is implied.
- // TODO(andrewhayden): This signature could easily be misinterpreted as
- // "(const string16& str, const string16& locale)". We should do something
- // better.
- BreakIterator(const StringPiece16& str, const string16& rules);
- ~BreakIterator();
-
- // Init() must be called before any of the iterators are valid.
- // Returns false if ICU failed to initialize.
- bool Init();
-
- // Advance to the next break. Returns false if we've run past the end of
- // the string. (Note that the very last "break" is after the final
- // character in the string, and when we advance to that position it's the
- // last time Advance() returns true.)
- bool Advance();
-
- // Updates the text used by the iterator, resetting the iterator as if
- // if Init() had been called again. Any old state is lost. Returns true
- // unless there is an error setting the text.
- bool SetText(const base::char16* text, const size_t length);
-
- // Under BREAK_WORD mode, returns true if the break we just hit is the
- // end of a word. (Otherwise, the break iterator just skipped over e.g.
- // whitespace or punctuation.) Under BREAK_LINE and BREAK_NEWLINE modes,
- // this distinction doesn't apply and it always returns false.
- bool IsWord() const;
-
- // Under BREAK_WORD mode:
- // - Returns IS_SKIPPABLE_WORD if non-word characters, such as punctuation or
- // spaces, are found.
- // - Returns IS_WORD_BREAK if the break we just hit is the end of a sequence
- // of word characters.
- // Under RULE_BASED mode:
- // - Returns IS_SKIPPABLE_WORD if characters outside the rules' character set
- // or non-word characters, such as punctuation or spaces, are found.
- // - Returns IS_WORD_BREAK if the break we just hit is the end of a sequence
- // of word characters that are in the rules' character set.
- // Not under BREAK_WORD or RULE_BASED mode:
- // - Returns IS_LINE_OR_CHAR_BREAK.
- BreakIterator::WordBreakStatus GetWordBreakStatus() const;
-
- // Under BREAK_WORD mode, returns true if |position| is at the end of word or
- // at the start of word. It always returns false under BREAK_LINE and
- // BREAK_NEWLINE modes.
- bool IsEndOfWord(size_t position) const;
- bool IsStartOfWord(size_t position) const;
-
- // Under BREAK_CHARACTER mode, returns whether |position| is a Unicode
- // grapheme boundary.
- bool IsGraphemeBoundary(size_t position) const;
-
- // Returns the string between prev() and pos().
- // Advance() must have been called successfully at least once for pos() to
- // have advanced to somewhere useful.
- string16 GetString() const;
-
- StringPiece16 GetStringPiece() const;
-
- // Returns the value of pos() returned before Advance() was last called.
- size_t prev() const { return prev_; }
-
- // Returns the current break position within the string,
- // or BreakIterator::npos when done.
- size_t pos() const { return pos_; }
-
- private:
- // ICU iterator, avoiding ICU ubrk.h dependence.
- // This is actually an ICU UBreakiterator* type, which turns out to be
- // a typedef for a void* in the ICU headers. Using void* directly prevents
- // callers from needing access to the ICU public headers directory.
- void* iter_;
-
- // The string we're iterating over. Can be changed with SetText(...)
- StringPiece16 string_;
-
- // Rules for our iterator. Mutually exclusive with break_type_.
- const string16 rules_;
-
- // The breaking style (word/space/newline). Mutually exclusive with rules_
- BreakType break_type_;
-
- // Previous and current iterator positions.
- size_t prev_, pos_;
-
- DISALLOW_COPY_AND_ASSIGN(BreakIterator);
-};
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_BREAK_ITERATOR_H_
diff --git a/base/i18n/build_utf8_validator_tables.cc b/base/i18n/build_utf8_validator_tables.cc
deleted file mode 100644
index 0cdcc35..0000000
--- a/base/i18n/build_utf8_validator_tables.cc
+++ /dev/null
@@ -1,470 +0,0 @@
-// Copyright 2014 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.
-
-// Create a state machine for validating UTF-8. The algorithm in brief:
-// 1. Convert the complete unicode range of code points, except for the
-// surrogate code points, to an ordered array of sequences of bytes in
-// UTF-8.
-// 2. Convert individual bytes to ranges, starting from the right of each byte
-// sequence. For each range, ensure the bytes on the left and the ranges
-// on the right are the identical.
-// 3. Convert the resulting list of ranges into a state machine, collapsing
-// identical states.
-// 4. Convert the state machine to an array of bytes.
-// 5. Output as a C++ file.
-//
-// To use:
-// $ ninja -C out/Release build_utf8_validator_tables
-// $ out/Release/build_utf8_validator_tables
-// --output=base/i18n/utf8_validator_tables.cc
-// $ git add base/i18n/utf8_validator_tables.cc
-//
-// Because the table is not expected to ever change, it is checked into the
-// repository rather than being regenerated at build time.
-//
-// This code uses type uint8_t throughout to represent bytes, to avoid
-// signed/unsigned char confusion.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <algorithm>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/strings/stringprintf.h"
-#include "third_party/icu/source/common/unicode/utf8.h"
-
-namespace {
-
-const char kHelpText[] =
- "Usage: build_utf8_validator_tables [ --help ] [ --output=<file> ]\n";
-
-const char kProlog[] =
- "// Copyright 2013 The Chromium Authors. All rights reserved.\n"
- "// Use of this source code is governed by a BSD-style license that can "
- "be\n"
- "// found in the LICENSE file.\n"
- "\n"
- "// This file is auto-generated by build_utf8_validator_tables.\n"
- "// DO NOT EDIT.\n"
- "\n"
- "#include \"base/i18n/utf8_validator_tables.h\"\n"
- "\n"
- "namespace base {\n"
- "namespace internal {\n"
- "\n"
- "const uint8_t kUtf8ValidatorTables[] = {\n";
-
-const char kEpilog[] =
- "};\n"
- "\n"
- "const size_t kUtf8ValidatorTablesSize = arraysize(kUtf8ValidatorTables);\n"
- "\n"
- "} // namespace internal\n"
- "} // namespace base\n";
-
-// Ranges are inclusive at both ends--they represent [from, to]
-class Range {
- public:
- // Ranges always start with just one byte.
- explicit Range(uint8_t value) : from_(value), to_(value) {}
-
- // Range objects are copyable and assignable to be used in STL
- // containers. Since they only contain non-pointer POD types, the default copy
- // constructor, assignment operator and destructor will work.
-
- // Add a byte to the range. We intentionally only support adding a byte at the
- // end, since that is the only operation the code needs.
- void AddByte(uint8_t to) {
- CHECK(to == to_ + 1);
- to_ = to;
- }
-
- uint8_t from() const { return from_; }
- uint8_t to() const { return to_; }
-
- bool operator<(const Range& rhs) const {
- return (from() < rhs.from() || (from() == rhs.from() && to() < rhs.to()));
- }
-
- bool operator==(const Range& rhs) const {
- return from() == rhs.from() && to() == rhs.to();
- }
-
- private:
- uint8_t from_;
- uint8_t to_;
-};
-
-// A vector of Ranges is like a simple regular expression--it corresponds to
-// a set of strings of the same length that have bytes in each position in
-// the appropriate range.
-typedef std::vector<Range> StringSet;
-
-// A UTF-8 "character" is represented by a sequence of bytes.
-typedef std::vector<uint8_t> Character;
-
-// In the second stage of the algorithm, we want to convert a large list of
-// Characters into a small list of StringSets.
-struct Pair {
- Character character;
- StringSet set;
-};
-
-typedef std::vector<Pair> PairVector;
-
-// A class to print a table of numbers in the same style as clang-format.
-class TablePrinter {
- public:
- explicit TablePrinter(FILE* stream)
- : stream_(stream), values_on_this_line_(0), current_offset_(0) {}
-
- void PrintValue(uint8_t value) {
- if (values_on_this_line_ == 0) {
- fputs(" ", stream_);
- } else if (values_on_this_line_ == kMaxValuesPerLine) {
- fprintf(stream_, " // 0x%02x\n ", current_offset_);
- values_on_this_line_ = 0;
- }
- fprintf(stream_, " 0x%02x,", static_cast<int>(value));
- ++values_on_this_line_;
- ++current_offset_;
- }
-
- void NewLine() {
- while (values_on_this_line_ < kMaxValuesPerLine) {
- fputs(" ", stream_);
- ++values_on_this_line_;
- }
- fprintf(stream_, " // 0x%02x\n", current_offset_);
- values_on_this_line_ = 0;
- }
-
- private:
- // stdio stream. Not owned.
- FILE* stream_;
-
- // Number of values so far printed on this line.
- int values_on_this_line_;
-
- // Total values printed so far.
- int current_offset_;
-
- static const int kMaxValuesPerLine = 8;
-
- DISALLOW_COPY_AND_ASSIGN(TablePrinter);
-};
-
-// Start by filling a PairVector with characters. The resulting vector goes from
-// "\x00" to "\xf4\x8f\xbf\xbf".
-PairVector InitializeCharacters() {
- PairVector vector;
- for (int i = 0; i <= 0x10FFFF; ++i) {
- if (i >= 0xD800 && i < 0xE000) {
- // Surrogate codepoints are not permitted. Non-character code points are
- // explicitly permitted.
- continue;
- }
- uint8_t bytes[4];
- unsigned int offset = 0;
- UBool is_error = false;
- U8_APPEND(bytes, offset, arraysize(bytes), i, is_error);
- DCHECK(!is_error);
- DCHECK_GT(offset, 0u);
- DCHECK_LE(offset, arraysize(bytes));
- Pair pair = {Character(bytes, bytes + offset), StringSet()};
- vector.push_back(pair);
- }
- return vector;
-}
-
-// Construct a new Pair from |character| and the concatenation of |new_range|
-// and |existing_set|, and append it to |pairs|.
-void ConstructPairAndAppend(const Character& character,
- const Range& new_range,
- const StringSet& existing_set,
- PairVector* pairs) {
- Pair new_pair = {character, StringSet(1, new_range)};
- new_pair.set.insert(
- new_pair.set.end(), existing_set.begin(), existing_set.end());
- pairs->push_back(new_pair);
-}
-
-// Each pass over the PairVector strips one byte off the right-hand-side of the
-// characters and adds a range to the set on the right. For example, the first
-// pass converts the range from "\xe0\xa0\x80" to "\xe0\xa0\xbf" to ("\xe0\xa0",
-// [\x80-\xbf]), then the second pass converts the range from ("\xe0\xa0",
-// [\x80-\xbf]) to ("\xe0\xbf", [\x80-\xbf]) to ("\xe0",
-// [\xa0-\xbf][\x80-\xbf]).
-void MoveRightMostCharToSet(PairVector* pairs) {
- PairVector new_pairs;
- PairVector::const_iterator it = pairs->begin();
- while (it != pairs->end() && it->character.empty()) {
- new_pairs.push_back(*it);
- ++it;
- }
- CHECK(it != pairs->end());
- Character unconverted_bytes(it->character.begin(), it->character.end() - 1);
- Range new_range(it->character.back());
- StringSet converted = it->set;
- ++it;
- while (it != pairs->end()) {
- const Pair& current_pair = *it++;
- if (current_pair.character.size() == unconverted_bytes.size() + 1 &&
- std::equal(unconverted_bytes.begin(),
- unconverted_bytes.end(),
- current_pair.character.begin()) &&
- converted == current_pair.set) {
- // The particular set of UTF-8 codepoints we are validating guarantees
- // that each byte range will be contiguous. This would not necessarily be
- // true for an arbitrary set of UTF-8 codepoints.
- DCHECK_EQ(new_range.to() + 1, current_pair.character.back());
- new_range.AddByte(current_pair.character.back());
- continue;
- }
- ConstructPairAndAppend(unconverted_bytes, new_range, converted, &new_pairs);
- unconverted_bytes = Character(current_pair.character.begin(),
- current_pair.character.end() - 1);
- new_range = Range(current_pair.character.back());
- converted = current_pair.set;
- }
- ConstructPairAndAppend(unconverted_bytes, new_range, converted, &new_pairs);
- new_pairs.swap(*pairs);
-}
-
-void MoveAllCharsToSets(PairVector* pairs) {
- // Since each pass of the function moves one character, and UTF-8 sequences
- // are at most 4 characters long, this simply runs the algorithm four times.
- for (int i = 0; i < 4; ++i) {
- MoveRightMostCharToSet(pairs);
- }
-#if DCHECK_IS_ON()
- for (PairVector::const_iterator it = pairs->begin(); it != pairs->end();
- ++it) {
- DCHECK(it->character.empty());
- }
-#endif
-}
-
-// Logs the generated string sets in regular-expression style, ie. [\x00-\x7f],
-// [\xc2-\xdf][\x80-\xbf], etc. This can be a useful sanity-check that the
-// algorithm is working. Use the command-line option
-// --vmodule=build_utf8_validator_tables=1 to see this output.
-void LogStringSets(const PairVector& pairs) {
- for (PairVector::const_iterator pair_it = pairs.begin();
- pair_it != pairs.end();
- ++pair_it) {
- std::string set_as_string;
- for (StringSet::const_iterator set_it = pair_it->set.begin();
- set_it != pair_it->set.end();
- ++set_it) {
- set_as_string += base::StringPrintf("[\\x%02x-\\x%02x]",
- static_cast<int>(set_it->from()),
- static_cast<int>(set_it->to()));
- }
- VLOG(1) << set_as_string;
- }
-}
-
-// A single state in the state machine is represented by a sorted vector of
-// start bytes and target states. All input bytes in the range between the start
-// byte and the next entry in the vector (or 0xFF) result in a transition to the
-// target state.
-struct StateRange {
- uint8_t from;
- uint8_t target_state;
-};
-
-typedef std::vector<StateRange> State;
-
-// Generates a state where all bytes go to state 1 (invalid). This is also used
-// as an initialiser for other states (since bytes from outside the desired
-// range are invalid).
-State GenerateInvalidState() {
- const StateRange range = {0, 1};
- return State(1, range);
-}
-
-// A map from a state (ie. a set of strings which will match from this state) to
-// a number (which is an index into the array of states).
-typedef std::map<StringSet, uint8_t> StateMap;
-
-// Create a new state corresponding to |set|, add it |states| and |state_map|
-// and return the index it was given in |states|.
-uint8_t MakeState(const StringSet& set,
- std::vector<State>* states,
- StateMap* state_map) {
- DCHECK(!set.empty());
- const Range& range = set.front();
- const StringSet rest(set.begin() + 1, set.end());
- const StateMap::const_iterator where = state_map->find(rest);
- const uint8_t target_state = where == state_map->end()
- ? MakeState(rest, states, state_map)
- : where->second;
- DCHECK_LT(0, range.from());
- DCHECK_LT(range.to(), 0xFF);
- const StateRange new_state_initializer[] = {
- {0, 1},
- {range.from(), target_state},
- {static_cast<uint8_t>(range.to() + 1), 1}};
- states->push_back(
- State(new_state_initializer,
- new_state_initializer + arraysize(new_state_initializer)));
- const uint8_t new_state_number =
- base::checked_cast<uint8_t>(states->size() - 1);
- CHECK(state_map->insert(std::make_pair(set, new_state_number)).second);
- return new_state_number;
-}
-
-std::vector<State> GenerateStates(const PairVector& pairs) {
- // States 0 and 1 are the initial/valid state and invalid state, respectively.
- std::vector<State> states(2, GenerateInvalidState());
- StateMap state_map;
- state_map.insert(std::make_pair(StringSet(), 0));
- for (PairVector::const_iterator it = pairs.begin(); it != pairs.end(); ++it) {
- DCHECK(it->character.empty());
- DCHECK(!it->set.empty());
- const Range& range = it->set.front();
- const StringSet rest(it->set.begin() + 1, it->set.end());
- const StateMap::const_iterator where = state_map.find(rest);
- const uint8_t target_state = where == state_map.end()
- ? MakeState(rest, &states, &state_map)
- : where->second;
- if (states[0].back().from == range.from()) {
- DCHECK_EQ(1, states[0].back().target_state);
- states[0].back().target_state = target_state;
- DCHECK_LT(range.to(), 0xFF);
- const StateRange new_range = {static_cast<uint8_t>(range.to() + 1), 1};
- states[0].push_back(new_range);
- } else {
- DCHECK_LT(range.to(), 0xFF);
- const StateRange new_range_initializer[] = {
- {range.from(), target_state},
- {static_cast<uint8_t>(range.to() + 1), 1}};
- states[0]
- .insert(states[0].end(),
- new_range_initializer,
- new_range_initializer + arraysize(new_range_initializer));
- }
- }
- return states;
-}
-
-// Output the generated states as a C++ table. Two tricks are used to compact
-// the table: each state in the table starts with a shift value which indicates
-// how many bits we can discard from the right-hand-side of the byte before
-// doing the table lookup. Secondly, only the state-transitions for bytes
-// with the top-bit set are included in the table; bytes without the top-bit set
-// are just ASCII and are handled directly by the code.
-void PrintStates(const std::vector<State>& states, FILE* stream) {
- // First calculate the start-offset of each state. This allows the state
- // machine to jump directly to the correct offset, avoiding an extra
- // indirection. State 0 starts at offset 0.
- std::vector<uint8_t> state_offset(1, 0);
- std::vector<uint8_t> shifts;
- uint8_t pos = 0;
-
- for (std::vector<State>::const_iterator state_it = states.begin();
- state_it != states.end();
- ++state_it) {
- // We want to set |shift| to the (0-based) index of the least-significant
- // set bit in any of the ranges for this state, since this tells us how many
- // bits we can discard and still determine what range a byte lies in. Sadly
- // it appears that ffs() is not portable, so we do it clumsily.
- uint8_t shift = 7;
- for (State::const_iterator range_it = state_it->begin();
- range_it != state_it->end();
- ++range_it) {
- while (shift > 0 && range_it->from % (1 << shift) != 0) {
- --shift;
- }
- }
- shifts.push_back(shift);
- pos += 1 + (1 << (7 - shift));
- state_offset.push_back(pos);
- }
-
- DCHECK_EQ(129, state_offset[1]);
-
- fputs(kProlog, stream);
- TablePrinter table_printer(stream);
-
- for (uint8_t state_index = 0; state_index < states.size(); ++state_index) {
- const uint8_t shift = shifts[state_index];
- uint8_t next_range = 0;
- uint8_t target_state = 1;
- fprintf(stream,
- " // State %d, offset 0x%02x\n",
- static_cast<int>(state_index),
- static_cast<int>(state_offset[state_index]));
- table_printer.PrintValue(shift);
- for (int i = 0; i < 0x100; i += (1 << shift)) {
- if (next_range < states[state_index].size() &&
- states[state_index][next_range].from == i) {
- target_state = states[state_index][next_range].target_state;
- ++next_range;
- }
- if (i >= 0x80) {
- table_printer.PrintValue(state_offset[target_state]);
- }
- }
- table_printer.NewLine();
- }
-
- fputs(kEpilog, stream);
-}
-
-} // namespace
-
-int main(int argc, char* argv[]) {
- base::CommandLine::Init(argc, argv);
- logging::LoggingSettings settings;
- settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
- logging::InitLogging(settings);
- if (base::CommandLine::ForCurrentProcess()->HasSwitch("help")) {
- fwrite(kHelpText, 1, arraysize(kHelpText), stdout);
- exit(EXIT_SUCCESS);
- }
- base::FilePath filename =
- base::CommandLine::ForCurrentProcess()->GetSwitchValuePath("output");
-
- FILE* output = stdout;
- if (!filename.empty()) {
- output = base::OpenFile(filename, "wb");
- if (!output)
- PLOG(FATAL) << "Couldn't open '" << filename.AsUTF8Unsafe()
- << "' for writing";
- }
-
- // Step 1: Enumerate the characters
- PairVector pairs = InitializeCharacters();
- // Step 2: Convert to sets.
- MoveAllCharsToSets(&pairs);
- if (VLOG_IS_ON(1)) {
- LogStringSets(pairs);
- }
- // Step 3: Generate states.
- std::vector<State> states = GenerateStates(pairs);
- // Step 4/5: Print output
- PrintStates(states, output);
-
- if (!filename.empty()) {
- if (!base::CloseFile(output))
- PLOG(FATAL) << "Couldn't finish writing '" << filename.AsUTF8Unsafe()
- << "'";
- }
-
- return EXIT_SUCCESS;
-}
diff --git a/base/i18n/case_conversion.cc b/base/i18n/case_conversion.cc
deleted file mode 100644
index a4a104c..0000000
--- a/base/i18n/case_conversion.cc
+++ /dev/null
@@ -1,90 +0,0 @@
-// 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/case_conversion.h"
-
-#include <stdint.h>
-
-#include "base/numerics/safe_conversions.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_util.h"
-#include "third_party/icu/source/common/unicode/uchar.h"
-#include "third_party/icu/source/common/unicode/unistr.h"
-#include "third_party/icu/source/common/unicode/ustring.h"
-
-namespace base {
-namespace i18n {
-
-namespace {
-
-// Provides a uniform interface for upper/lower/folding which take take
-// slightly varying parameters.
-typedef int32_t (*CaseMapperFunction)(UChar* dest, int32_t dest_capacity,
- const UChar* src, int32_t src_length,
- UErrorCode* error);
-
-int32_t ToUpperMapper(UChar* dest, int32_t dest_capacity,
- const UChar* src, int32_t src_length,
- UErrorCode* error) {
- // Use default locale.
- return u_strToUpper(dest, dest_capacity, src, src_length, nullptr, error);
-}
-
-int32_t ToLowerMapper(UChar* dest, int32_t dest_capacity,
- const UChar* src, int32_t src_length,
- UErrorCode* error) {
- // Use default locale.
- return u_strToLower(dest, dest_capacity, src, src_length, nullptr, error);
-}
-
-int32_t FoldCaseMapper(UChar* dest, int32_t dest_capacity,
- const UChar* src, int32_t src_length,
- UErrorCode* error) {
- return u_strFoldCase(dest, dest_capacity, src, src_length,
- U_FOLD_CASE_DEFAULT, error);
-}
-
-// Provides similar functionality as UnicodeString::caseMap but on string16.
-string16 CaseMap(StringPiece16 string, CaseMapperFunction case_mapper) {
- string16 dest;
- if (string.empty())
- return dest;
-
- // Provide an initial guess that the string length won't change. The typical
- // strings we use will very rarely change length in this process, so don't
- // optimize for that case.
- dest.resize(string.size());
-
- UErrorCode error;
- do {
- error = U_ZERO_ERROR;
-
- // ICU won't terminate the string if there's not enough room for the null
- // terminator, but will otherwise. So we don't need to save room for that.
- // Don't use WriteInto, which assumes null terminators.
- int32_t new_length = case_mapper(
- &dest[0], saturated_cast<int32_t>(dest.size()),
- string.data(), saturated_cast<int32_t>(string.size()),
- &error);
- dest.resize(new_length);
- } while (error == U_BUFFER_OVERFLOW_ERROR);
- return dest;
-}
-
-} // namespace
-
-string16 ToLower(StringPiece16 string) {
- return CaseMap(string, &ToLowerMapper);
-}
-
-string16 ToUpper(StringPiece16 string) {
- return CaseMap(string, &ToUpperMapper);
-}
-
-string16 FoldCase(StringPiece16 string) {
- return CaseMap(string, &FoldCaseMapper);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/case_conversion.h b/base/i18n/case_conversion.h
deleted file mode 100644
index 0631a80..0000000
--- a/base/i18n/case_conversion.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_CASE_CONVERSION_H_
-#define BASE_I18N_CASE_CONVERSION_H_
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-namespace i18n {
-
-// UNICODE CASE-HANDLING ADVICE
-//
-// In English it's always safe to convert to upper-case or lower-case text
-// and get a good answer. But some languages have rules specific to those
-// locales. One example is the Turkish I:
-// http://www.i18nguy.com/unicode/turkish-i18n.html
-//
-// ToLower/ToUpper use the current ICU locale which will take into account
-// the user language preference. Use this when dealing with user typing.
-//
-// FoldCase canonicalizes to a standardized form independent of the current
-// locale. Use this when comparing general Unicode strings that don't
-// necessarily belong in the user's current locale (like commands, protocol
-// names, other strings from the web) for case-insensitive equality.
-//
-// Note that case conversions will change the length of the string in some
-// not-uncommon cases. Never assume that the output is the same length as
-// the input.
-
-// Returns the lower case equivalent of string. Uses ICU's current locale.
-BASE_I18N_EXPORT string16 ToLower(StringPiece16 string);
-
-// Returns the upper case equivalent of string. Uses ICU's current locale.
-BASE_I18N_EXPORT string16 ToUpper(StringPiece16 string);
-
-// Convert the given string to a canonical case, independent of the current
-// locale. For ASCII the canonical form is lower case.
-// See http://unicode.org/faq/casemap_charprop.html#2
-BASE_I18N_EXPORT string16 FoldCase(StringPiece16 string);
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_CASE_CONVERSION_H_
diff --git a/base/i18n/char_iterator.cc b/base/i18n/char_iterator.cc
deleted file mode 100644
index d80b8b6..0000000
--- a/base/i18n/char_iterator.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-// 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/char_iterator.h"
-
-#include "third_party/icu/source/common/unicode/utf8.h"
-#include "third_party/icu/source/common/unicode/utf16.h"
-
-namespace base {
-namespace i18n {
-
-UTF8CharIterator::UTF8CharIterator(const std::string* str)
- : str_(reinterpret_cast<const uint8_t*>(str->data())),
- len_(str->size()),
- array_pos_(0),
- next_pos_(0),
- char_pos_(0),
- char_(0) {
- if (len_)
- U8_NEXT(str_, next_pos_, len_, char_);
-}
-
-UTF8CharIterator::~UTF8CharIterator() = default;
-
-bool UTF8CharIterator::Advance() {
- if (array_pos_ >= len_)
- return false;
-
- array_pos_ = next_pos_;
- char_pos_++;
- if (next_pos_ < len_)
- U8_NEXT(str_, next_pos_, len_, char_);
-
- return true;
-}
-
-UTF16CharIterator::UTF16CharIterator(const string16* str)
- : str_(reinterpret_cast<const char16*>(str->data())),
- len_(str->size()),
- array_pos_(0),
- next_pos_(0),
- char_pos_(0),
- char_(0) {
- if (len_)
- ReadChar();
-}
-
-UTF16CharIterator::UTF16CharIterator(const char16* str, size_t str_len)
- : str_(str),
- len_(str_len),
- array_pos_(0),
- next_pos_(0),
- char_pos_(0),
- char_(0) {
- if (len_)
- ReadChar();
-}
-
-UTF16CharIterator::~UTF16CharIterator() = default;
-
-bool UTF16CharIterator::Advance() {
- if (array_pos_ >= len_)
- return false;
-
- array_pos_ = next_pos_;
- char_pos_++;
- if (next_pos_ < len_)
- ReadChar();
-
- return true;
-}
-
-void UTF16CharIterator::ReadChar() {
- // This is actually a huge macro, so is worth having in a separate function.
- U16_NEXT(str_, next_pos_, len_, char_);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/char_iterator.h b/base/i18n/char_iterator.h
deleted file mode 100644
index 33f2934..0000000
--- a/base/i18n/char_iterator.h
+++ /dev/null
@@ -1,134 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_CHAR_ITERATOR_H_
-#define BASE_I18N_CHAR_ITERATOR_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "build_config.h"
-
-// The CharIterator classes iterate through the characters in UTF8 and
-// UTF16 strings. Example usage:
-//
-// UTF8CharIterator iter(&str);
-// while (!iter.end()) {
-// VLOG(1) << iter.get();
-// iter.Advance();
-// }
-
-#if defined(OS_WIN)
-typedef unsigned char uint8_t;
-#endif
-
-namespace base {
-namespace i18n {
-
-class BASE_I18N_EXPORT UTF8CharIterator {
- public:
- // Requires |str| to live as long as the UTF8CharIterator does.
- explicit UTF8CharIterator(const std::string* str);
- ~UTF8CharIterator();
-
- // Return the starting array index of the current character within the
- // string.
- int32_t array_pos() const { return array_pos_; }
-
- // Return the logical index of the current character, independent of the
- // number of bytes each character takes.
- int32_t char_pos() const { return char_pos_; }
-
- // Return the current char.
- int32_t get() const { return char_; }
-
- // Returns true if we're at the end of the string.
- bool end() const { return array_pos_ == len_; }
-
- // Advance to the next actual character. Returns false if we're at the
- // end of the string.
- bool Advance();
-
- private:
- // The string we're iterating over.
- const uint8_t* str_;
-
- // The length of the encoded string.
- int32_t len_;
-
- // Array index.
- int32_t array_pos_;
-
- // The next array index.
- int32_t next_pos_;
-
- // Character index.
- int32_t char_pos_;
-
- // The current character.
- int32_t char_;
-
- DISALLOW_COPY_AND_ASSIGN(UTF8CharIterator);
-};
-
-class BASE_I18N_EXPORT UTF16CharIterator {
- public:
- // Requires |str| to live as long as the UTF16CharIterator does.
- explicit UTF16CharIterator(const string16* str);
- UTF16CharIterator(const char16* str, size_t str_len);
- ~UTF16CharIterator();
-
- // Return the starting array index of the current character within the
- // string.
- int32_t array_pos() const { return array_pos_; }
-
- // Return the logical index of the current character, independent of the
- // number of codewords each character takes.
- int32_t char_pos() const { return char_pos_; }
-
- // Return the current char.
- int32_t get() const { return char_; }
-
- // Returns true if we're at the end of the string.
- bool end() const { return array_pos_ == len_; }
-
- // Advance to the next actual character. Returns false if we're at the
- // end of the string.
- bool Advance();
-
- private:
- // Fills in the current character we found and advances to the next
- // character, updating all flags as necessary.
- void ReadChar();
-
- // The string we're iterating over.
- const char16* str_;
-
- // The length of the encoded string.
- int32_t len_;
-
- // Array index.
- int32_t array_pos_;
-
- // The next array index.
- int32_t next_pos_;
-
- // Character index.
- int32_t char_pos_;
-
- // The current character.
- int32_t char_;
-
- DISALLOW_COPY_AND_ASSIGN(UTF16CharIterator);
-};
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_CHAR_ITERATOR_H_
diff --git a/base/i18n/character_encoding.cc b/base/i18n/character_encoding.cc
deleted file mode 100644
index a1068c3..0000000
--- a/base/i18n/character_encoding.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2016 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/character_encoding.h"
-
-#include "base/macros.h"
-#include "third_party/icu/source/common/unicode/ucnv.h"
-
-namespace base {
-namespace {
-
-// An array of all supported canonical encoding names.
-const char* const kCanonicalEncodingNames[] = {
- "Big5", "EUC-JP", "EUC-KR", "gb18030",
- "GBK", "IBM866", "ISO-2022-JP", "ISO-8859-10",
- "ISO-8859-13", "ISO-8859-14", "ISO-8859-15", "ISO-8859-16",
- "ISO-8859-2", "ISO-8859-3", "ISO-8859-4", "ISO-8859-5",
- "ISO-8859-6", "ISO-8859-7", "ISO-8859-8", "ISO-8859-8-I",
- "KOI8-R", "KOI8-U", "macintosh", "Shift_JIS",
- "UTF-16LE", "UTF-8", "windows-1250", "windows-1251",
- "windows-1252", "windows-1253", "windows-1254", "windows-1255",
- "windows-1256", "windows-1257", "windows-1258", "windows-874"};
-
-} // namespace
-
-std::string GetCanonicalEncodingNameByAliasName(const std::string& alias_name) {
- for (auto* encoding_name : kCanonicalEncodingNames) {
- if (alias_name == encoding_name)
- return alias_name;
- }
- static const char* kStandards[3] = {"HTML", "MIME", "IANA"};
- for (auto* standard : kStandards) {
- UErrorCode error_code = U_ZERO_ERROR;
- const char* canonical_name =
- ucnv_getStandardName(alias_name.c_str(), standard, &error_code);
- if (U_SUCCESS(error_code) && canonical_name)
- return canonical_name;
- }
- return std::string();
-}
-} // namespace base
diff --git a/base/i18n/character_encoding.h b/base/i18n/character_encoding.h
deleted file mode 100644
index 974cb5a..0000000
--- a/base/i18n/character_encoding.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2016 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.
-
-#ifndef BASE_I18N_CHARACTER_ENCODING_H_
-#define BASE_I18N_CHARACTER_ENCODING_H_
-
-#include <string>
-
-#include "base/i18n/base_i18n_export.h"
-
-namespace base {
-
-// Return canonical encoding name according to the encoding alias name.
-BASE_I18N_EXPORT std::string GetCanonicalEncodingNameByAliasName(
- const std::string& alias_name);
-
-} // namespace base
-
-#endif // BASE_I18N_CHARACTER_ENCODING_H_
diff --git a/base/i18n/encoding_detection.cc b/base/i18n/encoding_detection.cc
deleted file mode 100644
index f6bbf4a..0000000
--- a/base/i18n/encoding_detection.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2016 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/encoding_detection.h"
-
-#include "build_config.h"
-#include "third_party/ced/src/compact_enc_det/compact_enc_det.h"
-
-// third_party/ced/src/util/encodings/encodings.h, which is included
-// by the include above, undefs UNICODE because that is a macro used
-// internally in ced. If we later in the same translation unit do
-// anything related to Windows or Windows headers those will then use
-// the ASCII versions which we do not want. To avoid that happening in
-// jumbo builds, we redefine UNICODE again here.
-#if defined(OS_WIN)
-#define UNICODE 1
-#endif // OS_WIN
-
-namespace base {
-
-bool DetectEncoding(const std::string& text, std::string* encoding) {
- int consumed_bytes;
- bool is_reliable;
- Encoding enc = CompactEncDet::DetectEncoding(
- text.c_str(), text.length(), nullptr, nullptr, nullptr,
- UNKNOWN_ENCODING,
- UNKNOWN_LANGUAGE,
- CompactEncDet::QUERY_CORPUS, // plain text
- false, // Include 7-bit encodings
- &consumed_bytes,
- &is_reliable);
-
- if (enc == UNKNOWN_ENCODING)
- return false;
-
- *encoding = MimeEncodingName(enc);
- return true;
-}
-} // namespace base
diff --git a/base/i18n/encoding_detection.h b/base/i18n/encoding_detection.h
deleted file mode 100644
index c8e660c..0000000
--- a/base/i18n/encoding_detection.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2016 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.
-
-#ifndef BASE_I18N_ENCODING_DETECTION_H_
-#define BASE_I18N_ENCODING_DETECTION_H_
-
-#include <string>
-
-#include "base/compiler_specific.h"
-#include "base/i18n/base_i18n_export.h"
-
-namespace base {
-
-// Detect encoding of |text| and put the name of encoding in |encoding|.
-// Returns true on success.
-BASE_I18N_EXPORT bool DetectEncoding(const std::string& text,
- std::string* encoding) WARN_UNUSED_RESULT;
-} // namespace base
-
-#endif // BASE_I18N_ENCODING_DETECTION_H_
diff --git a/base/i18n/file_util_icu.cc b/base/i18n/file_util_icu.cc
deleted file mode 100644
index 20a7d2d..0000000
--- a/base/i18n/file_util_icu.cc
+++ /dev/null
@@ -1,179 +0,0 @@
-// 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.
-
-// File utilities that use the ICU library go in this file.
-
-#include "base/i18n/file_util_icu.h"
-
-#include <stdint.h>
-
-#include <memory>
-
-#include "base/files/file_path.h"
-#include "base/i18n/icu_string_conversions.h"
-#include "base/i18n/string_compare.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/strings/string_util.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "third_party/icu/source/common/unicode/uniset.h"
-#include "third_party/icu/source/i18n/unicode/coll.h"
-
-namespace base {
-namespace i18n {
-
-namespace {
-
-class IllegalCharacters {
- public:
- static IllegalCharacters* GetInstance() {
- return Singleton<IllegalCharacters>::get();
- }
-
- bool DisallowedEverywhere(UChar32 ucs4) {
- return !!illegal_anywhere_->contains(ucs4);
- }
-
- bool DisallowedLeadingOrTrailing(UChar32 ucs4) {
- return !!illegal_at_ends_->contains(ucs4);
- }
-
- bool IsAllowedName(const string16& s) {
- return s.empty() || (!!illegal_anywhere_->containsNone(
- icu::UnicodeString(s.c_str(), s.size())) &&
- !illegal_at_ends_->contains(*s.begin()) &&
- !illegal_at_ends_->contains(*s.rbegin()));
- }
-
- private:
- friend class Singleton<IllegalCharacters>;
- friend struct DefaultSingletonTraits<IllegalCharacters>;
-
- IllegalCharacters();
- ~IllegalCharacters() = default;
-
- // set of characters considered invalid anywhere inside a filename.
- std::unique_ptr<icu::UnicodeSet> illegal_anywhere_;
-
- // set of characters considered invalid at either end of a filename.
- std::unique_ptr<icu::UnicodeSet> illegal_at_ends_;
-
- DISALLOW_COPY_AND_ASSIGN(IllegalCharacters);
-};
-
-IllegalCharacters::IllegalCharacters() {
- UErrorCode everywhere_status = U_ZERO_ERROR;
- UErrorCode ends_status = U_ZERO_ERROR;
- // Control characters, formatting characters, non-characters, path separators,
- // and some printable ASCII characters regarded as dangerous ('"*/:<>?\\').
- // See http://blogs.msdn.com/michkap/archive/2006/11/03/941420.aspx
- // and http://msdn2.microsoft.com/en-us/library/Aa365247.aspx
- // Note that code points in the "Other, Format" (Cf) category are ignored on
- // HFS+ despite the ZERO_WIDTH_JOINER and ZERO_WIDTH_NON-JOINER being
- // legitimate in Arabic and some S/SE Asian scripts. In addition tilde (~) is
- // also excluded due to the possibility of interacting poorly with short
- // filenames on VFAT. (Related to CVE-2014-9390)
- illegal_anywhere_.reset(new icu::UnicodeSet(
- UNICODE_STRING_SIMPLE("[[\"~*/:<>?\\\\|][:Cc:][:Cf:]]"),
- everywhere_status));
- illegal_at_ends_.reset(new icu::UnicodeSet(
- UNICODE_STRING_SIMPLE("[[:WSpace:][.]]"), ends_status));
- DCHECK(U_SUCCESS(everywhere_status));
- DCHECK(U_SUCCESS(ends_status));
-
- // Add non-characters. If this becomes a performance bottleneck by
- // any chance, do not add these to |set| and change IsFilenameLegal()
- // to check |ucs4 & 0xFFFEu == 0xFFFEu|, in addiition to calling
- // IsAllowedName().
- illegal_anywhere_->add(0xFDD0, 0xFDEF);
- for (int i = 0; i <= 0x10; ++i) {
- int plane_base = 0x10000 * i;
- illegal_anywhere_->add(plane_base + 0xFFFE, plane_base + 0xFFFF);
- }
- illegal_anywhere_->freeze();
- illegal_at_ends_->freeze();
-}
-
-} // namespace
-
-bool IsFilenameLegal(const string16& file_name) {
- return IllegalCharacters::GetInstance()->IsAllowedName(file_name);
-}
-
-void ReplaceIllegalCharactersInPath(FilePath::StringType* file_name,
- char replace_char) {
- IllegalCharacters* illegal = IllegalCharacters::GetInstance();
-
- DCHECK(!(illegal->DisallowedEverywhere(replace_char)));
- DCHECK(!(illegal->DisallowedLeadingOrTrailing(replace_char)));
-
- int cursor = 0; // The ICU macros expect an int.
- while (cursor < static_cast<int>(file_name->size())) {
- int char_begin = cursor;
- uint32_t code_point;
-#if defined(OS_WIN)
- // Windows uses UTF-16 encoding for filenames.
- U16_NEXT(file_name->data(), cursor, static_cast<int>(file_name->length()),
- code_point);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- // Mac and Chrome OS use UTF-8 encoding for filenames.
- // Linux doesn't actually define file system encoding. Try to parse as
- // UTF-8.
- U8_NEXT(file_name->data(), cursor, static_cast<int>(file_name->length()),
- code_point);
-#else
-#error Unsupported platform
-#endif
-
- if (illegal->DisallowedEverywhere(code_point) ||
- ((char_begin == 0 || cursor == static_cast<int>(file_name->length())) &&
- illegal->DisallowedLeadingOrTrailing(code_point))) {
- file_name->replace(char_begin, cursor - char_begin, 1, replace_char);
- // We just made the potentially multi-byte/word char into one that only
- // takes one byte/word, so need to adjust the cursor to point to the next
- // character again.
- cursor = char_begin + 1;
- }
- }
-}
-
-bool LocaleAwareCompareFilenames(const FilePath& a, const FilePath& b) {
- UErrorCode error_code = U_ZERO_ERROR;
- // Use the default collator. The default locale should have been properly
- // set by the time this constructor is called.
- std::unique_ptr<icu::Collator> collator(
- icu::Collator::createInstance(error_code));
- DCHECK(U_SUCCESS(error_code));
- // Make it case-sensitive.
- collator->setStrength(icu::Collator::TERTIARY);
-
-#if defined(OS_WIN)
- return CompareString16WithCollator(*collator, WideToUTF16(a.value()),
- WideToUTF16(b.value())) == UCOL_LESS;
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
- // On linux, the file system encoding is not defined. We assume
- // SysNativeMBToWide takes care of it.
- return CompareString16WithCollator(
- *collator, WideToUTF16(SysNativeMBToWide(a.value())),
- WideToUTF16(SysNativeMBToWide(b.value()))) == UCOL_LESS;
-#endif
-}
-
-void NormalizeFileNameEncoding(FilePath* file_name) {
-#if defined(OS_CHROMEOS)
- std::string normalized_str;
- if (ConvertToUtf8AndNormalize(file_name->BaseName().value(), kCodepageUTF8,
- &normalized_str) &&
- !normalized_str.empty()) {
- *file_name = file_name->DirName().Append(FilePath(normalized_str));
- }
-#endif
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/file_util_icu.h b/base/i18n/file_util_icu.h
deleted file mode 100644
index f8bd9f4..0000000
--- a/base/i18n/file_util_icu.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_FILE_UTIL_ICU_H_
-#define BASE_I18N_FILE_UTIL_ICU_H_
-
-// File utilities that use the ICU library go in this file.
-
-#include "base/files/file_path.h"
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-
-namespace base {
-namespace i18n {
-
-// Returns true if file_name does not have any illegal character. The input
-// param has the same restriction as that for ReplaceIllegalCharacters.
-BASE_I18N_EXPORT bool IsFilenameLegal(const string16& file_name);
-
-// Replaces characters in |file_name| that are illegal for file names with
-// |replace_char|. |file_name| must not be a full or relative path, but just the
-// file name component (since slashes are considered illegal). Any leading or
-// trailing whitespace or periods in |file_name| is also replaced with the
-// |replace_char|.
-//
-// Example:
-// "bad:file*name?.txt" will be turned into "bad_file_name_.txt" when
-// |replace_char| is '_'.
-//
-// Warning: Do not use this function as the sole means of sanitizing a filename.
-// While the resulting filename itself would be legal, it doesn't necessarily
-// mean that the file will behave safely. On Windows, certain reserved names
-// refer to devices rather than files (E.g. LPT1), and some filenames could be
-// interpreted as shell namespace extensions (E.g. Foo.{<GUID>}).
-//
-// On Windows, Chrome OS and Mac, the file system encoding is already known and
-// parsed as UTF-8 and UTF-16 accordingly.
-// On Linux, the file name will be parsed as UTF8.
-// TODO(asanka): Move full filename sanitization logic here.
-BASE_I18N_EXPORT void ReplaceIllegalCharactersInPath(
- FilePath::StringType* file_name,
- char replace_char);
-
-// Compares two filenames using the current locale information. This can be
-// used to sort directory listings. It behaves like "operator<" for use in
-// std::sort.
-BASE_I18N_EXPORT bool LocaleAwareCompareFilenames(const FilePath& a,
- const FilePath& b);
-
-// Calculates the canonical file-system representation of |file_name| base name.
-// Modifies |file_name| in place. No-op if not on ChromeOS.
-BASE_I18N_EXPORT void NormalizeFileNameEncoding(FilePath* file_name);
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_FILE_UTIL_ICU_H_
diff --git a/base/i18n/i18n_constants.cc b/base/i18n/i18n_constants.cc
deleted file mode 100644
index 7d2f5fc..0000000
--- a/base/i18n/i18n_constants.cc
+++ /dev/null
@@ -1,13 +0,0 @@
-// 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/i18n_constants.h"
-
-namespace base {
-
-const char kCodepageLatin1[] = "ISO-8859-1";
-const char kCodepageUTF8[] = "UTF-8";
-
-} // namespace base
-
diff --git a/base/i18n/i18n_constants.h b/base/i18n/i18n_constants.h
deleted file mode 100644
index c1bd87d..0000000
--- a/base/i18n/i18n_constants.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) 2013 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.
-
-#ifndef BASE_I18N_I18N_CONSTANTS_H_
-#define BASE_I18N_I18N_CONSTANTS_H_
-
-#include "base/i18n/base_i18n_export.h"
-
-namespace base {
-
-// Names of codepages (charsets) understood by icu.
-BASE_I18N_EXPORT extern const char kCodepageLatin1[]; // a.k.a. ISO 8859-1
-BASE_I18N_EXPORT extern const char kCodepageUTF8[];
-
-// The other possible options are UTF-16BE and UTF-16LE, but they are unused in
-// Chromium as of this writing.
-
-} // namespace base
-
-#endif // BASE_I18N_I18N_CONSTANTS_H_
diff --git a/base/i18n/icu_string_conversions.cc b/base/i18n/icu_string_conversions.cc
deleted file mode 100644
index 6ec9980..0000000
--- a/base/i18n/icu_string_conversions.cc
+++ /dev/null
@@ -1,223 +0,0 @@
-// 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/i18n/icu_string_conversions.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "third_party/icu/source/common/unicode/normalizer2.h"
-#include "third_party/icu/source/common/unicode/ucnv.h"
-#include "third_party/icu/source/common/unicode/ucnv_cb.h"
-#include "third_party/icu/source/common/unicode/ucnv_err.h"
-#include "third_party/icu/source/common/unicode/ustring.h"
-
-namespace base {
-
-namespace {
-// ToUnicodeCallbackSubstitute() is based on UCNV_TO_U_CALLBACK_SUBSTITUTE
-// in source/common/ucnv_err.c.
-
-// Copyright (c) 1995-2006 International Business Machines Corporation
-// and others
-//
-// All rights reserved.
-//
-
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the "Software"),
-// to deal in the Software without restriction, including without limitation
-// the rights to use, copy, modify, merge, publish, distribute, and/or
-// sell copies of the Software, and to permit persons to whom the Software
-// is furnished to do so, provided that the above copyright notice(s) and
-// this permission notice appear in all copies of the Software and that
-// both the above copyright notice(s) and this permission notice appear in
-// supporting documentation.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-// OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
-// INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
-// OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-// OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
-// OR PERFORMANCE OF THIS SOFTWARE.
-//
-// Except as contained in this notice, the name of a copyright holder
-// shall not be used in advertising or otherwise to promote the sale, use
-// or other dealings in this Software without prior written authorization
-// of the copyright holder.
-
-// ___________________________________________________________________________
-//
-// All trademarks and registered trademarks mentioned herein are the property
-// of their respective owners.
-
-void ToUnicodeCallbackSubstitute(const void* context,
- UConverterToUnicodeArgs *to_args,
- const char* code_units,
- int32_t length,
- UConverterCallbackReason reason,
- UErrorCode * err) {
- static const UChar kReplacementChar = 0xFFFD;
- if (reason <= UCNV_IRREGULAR) {
- if (context == nullptr ||
- (*(reinterpret_cast<const char*>(context)) == 'i' &&
- reason == UCNV_UNASSIGNED)) {
- *err = U_ZERO_ERROR;
- ucnv_cbToUWriteUChars(to_args, &kReplacementChar, 1, 0, err);
- }
- // else the caller must have set the error code accordingly.
- }
- // else ignore the reset, close and clone calls.
-}
-
-bool ConvertFromUTF16(UConverter* converter, const UChar* uchar_src,
- int uchar_len, OnStringConversionError::Type on_error,
- std::string* encoded) {
- int encoded_max_length = UCNV_GET_MAX_BYTES_FOR_STRING(uchar_len,
- ucnv_getMaxCharSize(converter));
- encoded->resize(encoded_max_length);
-
- UErrorCode status = U_ZERO_ERROR;
-
- // Setup our error handler.
- switch (on_error) {
- case OnStringConversionError::FAIL:
- ucnv_setFromUCallBack(converter, UCNV_FROM_U_CALLBACK_STOP, nullptr,
- nullptr, nullptr, &status);
- break;
- case OnStringConversionError::SKIP:
- case OnStringConversionError::SUBSTITUTE:
- ucnv_setFromUCallBack(converter, UCNV_FROM_U_CALLBACK_SKIP, nullptr,
- nullptr, nullptr, &status);
- break;
- default:
- NOTREACHED();
- }
-
- // ucnv_fromUChars returns size not including terminating null
- int actual_size = ucnv_fromUChars(converter, &(*encoded)[0],
- encoded_max_length, uchar_src, uchar_len, &status);
- encoded->resize(actual_size);
- ucnv_close(converter);
- if (U_SUCCESS(status))
- return true;
- encoded->clear(); // Make sure the output is empty on error.
- return false;
-}
-
-// Set up our error handler for ToUTF-16 converters
-void SetUpErrorHandlerForToUChars(OnStringConversionError::Type on_error,
- UConverter* converter, UErrorCode* status) {
- switch (on_error) {
- case OnStringConversionError::FAIL:
- ucnv_setToUCallBack(converter, UCNV_TO_U_CALLBACK_STOP, nullptr, nullptr,
- nullptr, status);
- break;
- case OnStringConversionError::SKIP:
- ucnv_setToUCallBack(converter, UCNV_TO_U_CALLBACK_SKIP, nullptr, nullptr,
- nullptr, status);
- break;
- case OnStringConversionError::SUBSTITUTE:
- ucnv_setToUCallBack(converter, ToUnicodeCallbackSubstitute, nullptr,
- nullptr, nullptr, status);
- break;
- default:
- NOTREACHED();
- }
-}
-
-} // namespace
-
-// Codepage <-> Wide/UTF-16 ---------------------------------------------------
-
-bool UTF16ToCodepage(const string16& utf16,
- const char* codepage_name,
- OnStringConversionError::Type on_error,
- std::string* encoded) {
- encoded->clear();
-
- UErrorCode status = U_ZERO_ERROR;
- UConverter* converter = ucnv_open(codepage_name, &status);
- if (!U_SUCCESS(status))
- return false;
-
- return ConvertFromUTF16(converter, utf16.c_str(),
- static_cast<int>(utf16.length()), on_error, encoded);
-}
-
-bool CodepageToUTF16(const std::string& encoded,
- const char* codepage_name,
- OnStringConversionError::Type on_error,
- string16* utf16) {
- utf16->clear();
-
- UErrorCode status = U_ZERO_ERROR;
- UConverter* converter = ucnv_open(codepage_name, &status);
- if (!U_SUCCESS(status))
- return false;
-
- // Even in the worst case, the maximum length in 2-byte units of UTF-16
- // output would be at most the same as the number of bytes in input. There
- // is no single-byte encoding in which a character is mapped to a
- // non-BMP character requiring two 2-byte units.
- //
- // Moreover, non-BMP characters in legacy multibyte encodings
- // (e.g. EUC-JP, GB18030) take at least 2 bytes. The only exceptions are
- // BOCU and SCSU, but we don't care about them.
- size_t uchar_max_length = encoded.length() + 1;
-
- SetUpErrorHandlerForToUChars(on_error, converter, &status);
- std::unique_ptr<char16[]> buffer(new char16[uchar_max_length]);
- int actual_size = ucnv_toUChars(converter, buffer.get(),
- static_cast<int>(uchar_max_length), encoded.data(),
- static_cast<int>(encoded.length()), &status);
- ucnv_close(converter);
- if (!U_SUCCESS(status)) {
- utf16->clear(); // Make sure the output is empty on error.
- return false;
- }
-
- utf16->assign(buffer.get(), actual_size);
- return true;
-}
-
-bool ConvertToUtf8AndNormalize(const std::string& text,
- const std::string& charset,
- std::string* result) {
- result->clear();
- string16 utf16;
- if (!CodepageToUTF16(
- text, charset.c_str(), OnStringConversionError::FAIL, &utf16))
- return false;
-
- UErrorCode status = U_ZERO_ERROR;
- const icu::Normalizer2* normalizer = icu::Normalizer2::getNFCInstance(status);
- DCHECK(U_SUCCESS(status));
- if (U_FAILURE(status))
- return false;
- int32_t utf16_length = static_cast<int32_t>(utf16.length());
- icu::UnicodeString normalized(utf16.data(), utf16_length);
- int32_t normalized_prefix_length =
- normalizer->spanQuickCheckYes(normalized, status);
- if (normalized_prefix_length < utf16_length) {
- icu::UnicodeString un_normalized(normalized, normalized_prefix_length);
- normalized.truncate(normalized_prefix_length);
- normalizer->normalizeSecondAndAppend(normalized, un_normalized, status);
- }
- if (U_FAILURE(status))
- return false;
- normalized.toUTF8String(*result);
- return true;
-}
-
-} // namespace base
diff --git a/base/i18n/icu_string_conversions.h b/base/i18n/icu_string_conversions.h
deleted file mode 100644
index cbdcb99..0000000
--- a/base/i18n/icu_string_conversions.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_ICU_STRING_CONVERSIONS_H_
-#define BASE_I18N_ICU_STRING_CONVERSIONS_H_
-
-#include <string>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/i18n/i18n_constants.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-// Defines the error handling modes of UTF16ToCodepage and CodepageToUTF16.
-class OnStringConversionError {
- public:
- enum Type {
- // The function will return failure. The output buffer will be empty.
- FAIL,
-
- // The offending characters are skipped and the conversion will proceed as
- // if they did not exist.
- SKIP,
-
- // When converting to Unicode, the offending byte sequences are substituted
- // by Unicode replacement character (U+FFFD). When converting from Unicode,
- // this is the same as SKIP.
- SUBSTITUTE,
- };
-
- private:
- OnStringConversionError() = delete;
-};
-
-// Converts between UTF-16 strings and the encoding specified. If the
-// encoding doesn't exist or the encoding fails (when on_error is FAIL),
-// returns false.
-BASE_I18N_EXPORT bool UTF16ToCodepage(const string16& utf16,
- const char* codepage_name,
- OnStringConversionError::Type on_error,
- std::string* encoded);
-BASE_I18N_EXPORT bool CodepageToUTF16(const std::string& encoded,
- const char* codepage_name,
- OnStringConversionError::Type on_error,
- string16* utf16);
-
-// Converts from any codepage to UTF-8 and ensures the resulting UTF-8 is
-// normalized.
-BASE_I18N_EXPORT bool ConvertToUtf8AndNormalize(const std::string& text,
- const std::string& charset,
- std::string* result);
-
-} // namespace base
-
-#endif // BASE_I18N_ICU_STRING_CONVERSIONS_H_
diff --git a/base/i18n/icu_util.cc b/base/i18n/icu_util.cc
deleted file mode 100644
index 1cbfbd6..0000000
--- a/base/i18n/icu_util.cc
+++ /dev/null
@@ -1,275 +0,0 @@
-// 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/i18n/icu_util.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-#include <string>
-
-#include "base/debug/alias.h"
-#include "base/files/file_path.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/logging.h"
-#include "base/path_service.h"
-#include "base/strings/string_util.h"
-#include "base/strings/sys_string_conversions.h"
-#include "build_config.h"
-#include "third_party/icu/source/common/unicode/putil.h"
-#include "third_party/icu/source/common/unicode/udata.h"
-#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_ANDROID)
-#include "third_party/icu/source/i18n/unicode/timezone.h"
-#endif
-
-#if defined(OS_ANDROID)
-#include "base/android/apk_assets.h"
-#include "base/android/timezone_utils.h"
-#endif
-
-#if defined(OS_IOS)
-#include "base/ios/ios_util.h"
-#endif
-
-#if defined(OS_MACOSX)
-#include "base/mac/foundation_util.h"
-#endif
-
-#if defined(OS_FUCHSIA)
-#include "base/base_paths_fuchsia.h"
-#endif
-
-namespace base {
-namespace i18n {
-
-#if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED
-#define ICU_UTIL_DATA_SYMBOL "icudt" U_ICU_VERSION_SHORT "_dat"
-#if defined(OS_WIN)
-#define ICU_UTIL_DATA_SHARED_MODULE_NAME "icudt.dll"
-#endif
-#endif
-
-namespace {
-#if !defined(OS_NACL)
-#if DCHECK_IS_ON()
-// Assert that we are not called more than once. Even though calling this
-// function isn't harmful (ICU can handle it), being called twice probably
-// indicates a programming error.
-bool g_check_called_once = true;
-bool g_called_once = false;
-#endif // DCHECK_IS_ON()
-
-#if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-
-// Use an unversioned file name to simplify a icu version update down the road.
-// No need to change the filename in multiple places (gyp files, windows
-// build pkg configurations, etc). 'l' stands for Little Endian.
-// This variable is exported through the header file.
-const char kIcuDataFileName[] = "icudtl.dat";
-#if defined(OS_ANDROID)
-const char kAndroidAssetsIcuDataFileName[] = "assets/icudtl.dat";
-#endif
-
-// File handle intentionally never closed. Not using File here because its
-// Windows implementation guards against two instances owning the same
-// PlatformFile (which we allow since we know it is never freed).
-PlatformFile g_icudtl_pf = kInvalidPlatformFile;
-MemoryMappedFile* g_icudtl_mapped_file = nullptr;
-MemoryMappedFile::Region g_icudtl_region;
-
-void LazyInitIcuDataFile() {
- if (g_icudtl_pf != kInvalidPlatformFile) {
- return;
- }
-#if defined(OS_ANDROID)
- int fd = base::android::OpenApkAsset(kAndroidAssetsIcuDataFileName,
- &g_icudtl_region);
- g_icudtl_pf = fd;
- if (fd != -1) {
- return;
- }
-// For unit tests, data file is located on disk, so try there as a fallback.
-#endif // defined(OS_ANDROID)
-#if !defined(OS_MACOSX)
- FilePath data_path;
- if (!PathService::Get(DIR_ASSETS, &data_path)) {
- LOG(ERROR) << "Can't find " << kIcuDataFileName;
- return;
- }
- data_path = data_path.AppendASCII(kIcuDataFileName);
-#else
- // Assume it is in the framework bundle's Resources directory.
- ScopedCFTypeRef<CFStringRef> data_file_name(
- SysUTF8ToCFStringRef(kIcuDataFileName));
- FilePath data_path = mac::PathForFrameworkBundleResource(data_file_name);
-#if defined(OS_IOS)
- FilePath override_data_path = base::ios::FilePathOfEmbeddedICU();
- if (!override_data_path.empty()) {
- data_path = override_data_path;
- }
-#endif // !defined(OS_IOS)
- if (data_path.empty()) {
- LOG(ERROR) << kIcuDataFileName << " not found in bundle";
- return;
- }
-#endif // !defined(OS_MACOSX)
- File file(data_path, File::FLAG_OPEN | File::FLAG_READ);
- if (file.IsValid()) {
- g_icudtl_pf = file.TakePlatformFile();
- g_icudtl_region = MemoryMappedFile::Region::kWholeFile;
- }
-}
-
-bool InitializeICUWithFileDescriptorInternal(
- PlatformFile data_fd,
- const MemoryMappedFile::Region& data_region) {
- // This can be called multiple times in tests.
- if (g_icudtl_mapped_file) {
- return true;
- }
- if (data_fd == kInvalidPlatformFile) {
- LOG(ERROR) << "Invalid file descriptor to ICU data received.";
- return false;
- }
-
- std::unique_ptr<MemoryMappedFile> icudtl_mapped_file(new MemoryMappedFile());
- if (!icudtl_mapped_file->Initialize(File(data_fd), data_region)) {
- LOG(ERROR) << "Couldn't mmap icu data file";
- return false;
- }
- g_icudtl_mapped_file = icudtl_mapped_file.release();
-
- UErrorCode err = U_ZERO_ERROR;
- udata_setCommonData(const_cast<uint8_t*>(g_icudtl_mapped_file->data()), &err);
-#if defined(OS_ANDROID)
- if (err == U_ZERO_ERROR) {
- // On Android, we can't leave it up to ICU to set the default timezone
- // because ICU's timezone detection does not work in many timezones (e.g.
- // Australia/Sydney, Asia/Seoul, Europe/Paris ). Use JNI to detect the host
- // timezone and set the ICU default timezone accordingly in advance of
- // actual use. See crbug.com/722821 and
- // https://ssl.icu-project.org/trac/ticket/13208 .
- base::string16 timezone_id = base::android::GetDefaultTimeZoneId();
- icu::TimeZone::adoptDefault(icu::TimeZone::createTimeZone(
- icu::UnicodeString(FALSE, timezone_id.data(), timezone_id.length())));
- }
-#endif
- // Never try to load ICU data from files.
- udata_setFileAccess(UDATA_ONLY_PACKAGES, &err);
- return err == U_ZERO_ERROR;
-}
-#endif // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-#endif // !defined(OS_NACL)
-
-} // namespace
-
-#if !defined(OS_NACL)
-#if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-#if defined(OS_ANDROID)
-bool InitializeICUWithFileDescriptor(
- PlatformFile data_fd,
- const MemoryMappedFile::Region& data_region) {
-#if DCHECK_IS_ON()
- DCHECK(!g_check_called_once || !g_called_once);
- g_called_once = true;
-#endif
- return InitializeICUWithFileDescriptorInternal(data_fd, data_region);
-}
-
-PlatformFile GetIcuDataFileHandle(MemoryMappedFile::Region* out_region) {
- CHECK_NE(g_icudtl_pf, kInvalidPlatformFile);
- *out_region = g_icudtl_region;
- return g_icudtl_pf;
-}
-#endif
-
-const uint8_t* GetRawIcuMemory() {
- CHECK(g_icudtl_mapped_file);
- return g_icudtl_mapped_file->data();
-}
-
-bool InitializeICUFromRawMemory(const uint8_t* raw_memory) {
-#if !defined(COMPONENT_BUILD)
-#if DCHECK_IS_ON()
- DCHECK(!g_check_called_once || !g_called_once);
- g_called_once = true;
-#endif
-
- UErrorCode err = U_ZERO_ERROR;
- udata_setCommonData(const_cast<uint8_t*>(raw_memory), &err);
- // Never try to load ICU data from files.
- udata_setFileAccess(UDATA_ONLY_PACKAGES, &err);
- return err == U_ZERO_ERROR;
-#else
- return true;
-#endif
-}
-
-#endif // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-
-bool InitializeICU() {
-#if DCHECK_IS_ON()
- DCHECK(!g_check_called_once || !g_called_once);
- g_called_once = true;
-#endif
-
- bool result;
-#if (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED)
- FilePath data_path;
- PathService::Get(DIR_ASSETS, &data_path);
- data_path = data_path.AppendASCII(ICU_UTIL_DATA_SHARED_MODULE_NAME);
-
- HMODULE module = LoadLibrary(data_path.value().c_str());
- if (!module) {
- LOG(ERROR) << "Failed to load " << ICU_UTIL_DATA_SHARED_MODULE_NAME;
- return false;
- }
-
- FARPROC addr = GetProcAddress(module, ICU_UTIL_DATA_SYMBOL);
- if (!addr) {
- LOG(ERROR) << ICU_UTIL_DATA_SYMBOL << ": not found in "
- << ICU_UTIL_DATA_SHARED_MODULE_NAME;
- return false;
- }
-
- UErrorCode err = U_ZERO_ERROR;
- udata_setCommonData(reinterpret_cast<void*>(addr), &err);
- // Never try to load ICU data from files.
- udata_setFileAccess(UDATA_ONLY_PACKAGES, &err);
- result = (err == U_ZERO_ERROR);
-#elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_STATIC)
- // The ICU data is statically linked.
- result = true;
-#elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE)
- // If the ICU data directory is set, ICU won't actually load the data until
- // it is needed. This can fail if the process is sandboxed at that time.
- // Instead, we map the file in and hand off the data so the sandbox won't
- // cause any problems.
- LazyInitIcuDataFile();
- result =
- InitializeICUWithFileDescriptorInternal(g_icudtl_pf, g_icudtl_region);
-#endif
-
-// To respond to the timezone change properly, the default timezone
-// cache in ICU has to be populated on starting up.
-// TODO(jungshik): Some callers do not care about tz at all. If necessary,
-// add a boolean argument to this function to init'd the default tz only
-// when requested.
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
- if (result)
- std::unique_ptr<icu::TimeZone> zone(icu::TimeZone::createDefault());
-#endif
- return result;
-}
-#endif // !defined(OS_NACL)
-
-void AllowMultipleInitializeCallsForTesting() {
-#if DCHECK_IS_ON() && !defined(OS_NACL)
- g_check_called_once = false;
-#endif
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/icu_util.h b/base/i18n/icu_util.h
deleted file mode 100644
index 9bae8a1..0000000
--- a/base/i18n/icu_util.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_ICU_UTIL_H_
-#define BASE_I18N_ICU_UTIL_H_
-
-#include <stdint.h>
-
-#include "base/files/memory_mapped_file.h"
-#include "base/i18n/base_i18n_export.h"
-#include "build_config.h"
-
-#define ICU_UTIL_DATA_FILE 0
-#define ICU_UTIL_DATA_SHARED 1
-#define ICU_UTIL_DATA_STATIC 2
-
-namespace base {
-namespace i18n {
-
-#if !defined(OS_NACL)
-// Call this function to load ICU's data tables for the current process. This
-// function should be called before ICU is used.
-BASE_I18N_EXPORT bool InitializeICU();
-
-#if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-#if defined(OS_ANDROID)
-// Returns the PlatformFile and Region that was initialized by InitializeICU().
-// Use with InitializeICUWithFileDescriptor().
-BASE_I18N_EXPORT PlatformFile GetIcuDataFileHandle(
- MemoryMappedFile::Region* out_region);
-
-// Android uses a file descriptor passed by browser process to initialize ICU
-// in render processes.
-BASE_I18N_EXPORT bool InitializeICUWithFileDescriptor(
- PlatformFile data_fd,
- const MemoryMappedFile::Region& data_region);
-#endif
-
-// Returns a void pointer to the memory mapped ICU data file.
-//
-// There are cases on Android where we would be unsafely reusing a file
-// descriptor within the same process when initializing two copies of ICU from
-// different binaries in the same address space. This returns an unowned
-// pointer to the memory mapped icu data file; consumers copies of base must
-// not outlive the copy of base that owns the memory mapped file.
-BASE_I18N_EXPORT const uint8_t* GetRawIcuMemory();
-
-// Initializes ICU memory
-//
-// This does nothing in component builds; this initialization should only be
-// done in cases where there could be two copies of base in a single process in
-// non-component builds. (The big example is standalone service libraries: the
-// Service Manager will have a copy of base linked in, and the majority of
-// service libraries will have base linked in but in non-component builds,
-// these will be separate copies of base.)
-BASE_I18N_EXPORT bool InitializeICUFromRawMemory(const uint8_t* raw_memory);
-#endif // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-#endif // !defined(OS_NACL)
-
-// In a test binary, the call above might occur twice.
-BASE_I18N_EXPORT void AllowMultipleInitializeCallsForTesting();
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_ICU_UTIL_H_
diff --git a/base/i18n/message_formatter.cc b/base/i18n/message_formatter.cc
deleted file mode 100644
index c69dd07..0000000
--- a/base/i18n/message_formatter.cc
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright 2015 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/message_formatter.h"
-
-#include "base/i18n/unicodestring.h"
-#include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/time/time.h"
-#include "third_party/icu/source/common/unicode/unistr.h"
-#include "third_party/icu/source/common/unicode/utypes.h"
-#include "third_party/icu/source/i18n/unicode/fmtable.h"
-#include "third_party/icu/source/i18n/unicode/msgfmt.h"
-
-using icu::UnicodeString;
-
-namespace base {
-namespace i18n {
-namespace {
-UnicodeString UnicodeStringFromStringPiece(StringPiece str) {
- return UnicodeString::fromUTF8(
- icu::StringPiece(str.data(), base::checked_cast<int32_t>(str.size())));
-}
-} // anonymous namespace
-
-namespace internal {
-MessageArg::MessageArg() : formattable(nullptr) {}
-
-MessageArg::MessageArg(const char* s)
- : formattable(new icu::Formattable(UnicodeStringFromStringPiece(s))) {}
-
-MessageArg::MessageArg(StringPiece s)
- : formattable(new icu::Formattable(UnicodeStringFromStringPiece(s))) {}
-
-MessageArg::MessageArg(const std::string& s)
- : formattable(new icu::Formattable(UnicodeString::fromUTF8(s))) {}
-
-MessageArg::MessageArg(const string16& s)
- : formattable(new icu::Formattable(UnicodeString(s.data(), s.size()))) {}
-
-MessageArg::MessageArg(int i) : formattable(new icu::Formattable(i)) {}
-
-MessageArg::MessageArg(int64_t i) : formattable(new icu::Formattable(i)) {}
-
-MessageArg::MessageArg(double d) : formattable(new icu::Formattable(d)) {}
-
-MessageArg::MessageArg(const Time& t)
- : formattable(new icu::Formattable(static_cast<UDate>(t.ToJsTime()))) {}
-
-MessageArg::~MessageArg() = default;
-
-// Tests if this argument has a value, and if so increments *count.
-bool MessageArg::has_value(int *count) const {
- if (formattable == nullptr)
- return false;
-
- ++*count;
- return true;
-}
-
-} // namespace internal
-
-string16 MessageFormatter::FormatWithNumberedArgs(
- StringPiece16 msg,
- const internal::MessageArg& arg0,
- const internal::MessageArg& arg1,
- const internal::MessageArg& arg2,
- const internal::MessageArg& arg3,
- const internal::MessageArg& arg4,
- const internal::MessageArg& arg5,
- const internal::MessageArg& arg6) {
- int32_t args_count = 0;
- icu::Formattable args[] = {
- arg0.has_value(&args_count) ? *arg0.formattable : icu::Formattable(),
- arg1.has_value(&args_count) ? *arg1.formattable : icu::Formattable(),
- arg2.has_value(&args_count) ? *arg2.formattable : icu::Formattable(),
- arg3.has_value(&args_count) ? *arg3.formattable : icu::Formattable(),
- arg4.has_value(&args_count) ? *arg4.formattable : icu::Formattable(),
- arg5.has_value(&args_count) ? *arg5.formattable : icu::Formattable(),
- arg6.has_value(&args_count) ? *arg6.formattable : icu::Formattable(),
- };
-
- UnicodeString msg_string(msg.data(), msg.size());
- UErrorCode error = U_ZERO_ERROR;
- icu::MessageFormat format(msg_string, error);
- icu::UnicodeString formatted;
- icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
- format.format(args, args_count, formatted, ignore, error);
- if (U_FAILURE(error)) {
- LOG(ERROR) << "MessageFormat(" << msg.as_string() << ") failed with "
- << u_errorName(error);
- return string16();
- }
- return i18n::UnicodeStringToString16(formatted);
-}
-
-string16 MessageFormatter::FormatWithNamedArgs(
- StringPiece16 msg,
- StringPiece name0, const internal::MessageArg& arg0,
- StringPiece name1, const internal::MessageArg& arg1,
- StringPiece name2, const internal::MessageArg& arg2,
- StringPiece name3, const internal::MessageArg& arg3,
- StringPiece name4, const internal::MessageArg& arg4,
- StringPiece name5, const internal::MessageArg& arg5,
- StringPiece name6, const internal::MessageArg& arg6) {
- icu::UnicodeString names[] = {
- UnicodeStringFromStringPiece(name0),
- UnicodeStringFromStringPiece(name1),
- UnicodeStringFromStringPiece(name2),
- UnicodeStringFromStringPiece(name3),
- UnicodeStringFromStringPiece(name4),
- UnicodeStringFromStringPiece(name5),
- UnicodeStringFromStringPiece(name6),
- };
- int32_t args_count = 0;
- icu::Formattable args[] = {
- arg0.has_value(&args_count) ? *arg0.formattable : icu::Formattable(),
- arg1.has_value(&args_count) ? *arg1.formattable : icu::Formattable(),
- arg2.has_value(&args_count) ? *arg2.formattable : icu::Formattable(),
- arg3.has_value(&args_count) ? *arg3.formattable : icu::Formattable(),
- arg4.has_value(&args_count) ? *arg4.formattable : icu::Formattable(),
- arg5.has_value(&args_count) ? *arg5.formattable : icu::Formattable(),
- arg6.has_value(&args_count) ? *arg6.formattable : icu::Formattable(),
- };
-
- UnicodeString msg_string(msg.data(), msg.size());
- UErrorCode error = U_ZERO_ERROR;
- icu::MessageFormat format(msg_string, error);
-
- icu::UnicodeString formatted;
- format.format(names, args, args_count, formatted, error);
- if (U_FAILURE(error)) {
- LOG(ERROR) << "MessageFormat(" << msg.as_string() << ") failed with "
- << u_errorName(error);
- return string16();
- }
- return i18n::UnicodeStringToString16(formatted);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/message_formatter.h b/base/i18n/message_formatter.h
deleted file mode 100644
index 36a656d..0000000
--- a/base/i18n/message_formatter.h
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef BASE_I18N_MESSAGE_FORMATTER_H_
-#define BASE_I18N_MESSAGE_FORMATTER_H_
-
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "third_party/icu/source/common/unicode/uversion.h"
-
-U_NAMESPACE_BEGIN
-class Formattable;
-U_NAMESPACE_END
-
-namespace base {
-
-class Time;
-
-namespace i18n {
-
-class MessageFormatter;
-
-namespace internal {
-
-class BASE_I18N_EXPORT MessageArg {
- public:
- MessageArg(const char* s);
- MessageArg(StringPiece s);
- MessageArg(const std::string& s);
- MessageArg(const string16& s);
- MessageArg(int i);
- MessageArg(int64_t i);
- MessageArg(double d);
- MessageArg(const Time& t);
- ~MessageArg();
-
- private:
- friend class base::i18n::MessageFormatter;
- MessageArg();
- // Tests if this argument has a value, and if so increments *count.
- bool has_value(int* count) const;
- std::unique_ptr<icu::Formattable> formattable;
- DISALLOW_COPY_AND_ASSIGN(MessageArg);
-};
-
-} // namespace internal
-
-// Message Formatter with the ICU message format syntax support.
-// It can format strings (UTF-8 and UTF-16), numbers and base::Time with
-// plural, gender and other 'selectors' support. This is handy if you
-// have multiple parameters of differnt types and some of them require
-// plural or gender/selector support.
-//
-// To use this API for locale-sensitive formatting, retrieve a 'message
-// template' in the ICU message format from a message bundle (e.g. with
-// l10n_util::GetStringUTF16()) and pass it to FormatWith{Named,Numbered}Args.
-//
-// MessageFormat specs:
-// http://icu-project.org/apiref/icu4j/com/ibm/icu/text/MessageFormat.html
-// http://icu-project.org/apiref/icu4c/classicu_1_1DecimalFormat.html#details
-// Examples:
-// http://userguide.icu-project.org/formatparse/messages
-// message_formatter_unittest.cc
-// go/plurals inside Google.
-// TODO(jshin): Document this API in md format docs.
-// Caveat:
-// When plural/select/gender is used along with other format specifiers such
-// as date or number, plural/select/gender should be at the top level. It's
-// not an ICU restriction but a constraint imposed by Google's translation
-// infrastructure. Message A does not work. It must be revised to Message B.
-//
-// A.
-// Rated <ph name="RATING">{0, number,0.0}<ex>3.2</ex></ph>
-// by {1, plural, =1{a user} other{# users}}
-//
-// B.
-// {1, plural,
-// =1{Rated <ph name="RATING">{0, number,0.0}<ex>3.2</ex></ph>
-// by a user.}
-// other{Rated <ph name="RATING">{0, number,0.0}<ex>3.2</ex></ph>
-// by # users.}}
-
-class BASE_I18N_EXPORT MessageFormatter {
- public:
- static string16 FormatWithNamedArgs(
- StringPiece16 msg,
- StringPiece name0 = StringPiece(),
- const internal::MessageArg& arg0 = internal::MessageArg(),
- StringPiece name1 = StringPiece(),
- const internal::MessageArg& arg1 = internal::MessageArg(),
- StringPiece name2 = StringPiece(),
- const internal::MessageArg& arg2 = internal::MessageArg(),
- StringPiece name3 = StringPiece(),
- const internal::MessageArg& arg3 = internal::MessageArg(),
- StringPiece name4 = StringPiece(),
- const internal::MessageArg& arg4 = internal::MessageArg(),
- StringPiece name5 = StringPiece(),
- const internal::MessageArg& arg5 = internal::MessageArg(),
- StringPiece name6 = StringPiece(),
- const internal::MessageArg& arg6 = internal::MessageArg());
-
- static string16 FormatWithNumberedArgs(
- StringPiece16 msg,
- const internal::MessageArg& arg0 = internal::MessageArg(),
- const internal::MessageArg& arg1 = internal::MessageArg(),
- const internal::MessageArg& arg2 = internal::MessageArg(),
- const internal::MessageArg& arg3 = internal::MessageArg(),
- const internal::MessageArg& arg4 = internal::MessageArg(),
- const internal::MessageArg& arg5 = internal::MessageArg(),
- const internal::MessageArg& arg6 = internal::MessageArg());
-
- private:
- MessageFormatter() = delete;
- DISALLOW_COPY_AND_ASSIGN(MessageFormatter);
-};
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_MESSAGE_FORMATTER_H_
diff --git a/base/i18n/number_formatting.cc b/base/i18n/number_formatting.cc
deleted file mode 100644
index 0ab031e..0000000
--- a/base/i18n/number_formatting.cc
+++ /dev/null
@@ -1,97 +0,0 @@
-// 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/i18n/number_formatting.h"
-
-#include <stddef.h>
-
-#include <memory>
-
-#include "base/format_macros.h"
-#include "base/i18n/message_formatter.h"
-#include "base/i18n/unicodestring.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "third_party/icu/source/common/unicode/ustring.h"
-#include "third_party/icu/source/i18n/unicode/numfmt.h"
-
-namespace base {
-
-namespace {
-
-// A simple wrapper around icu::NumberFormat that allows for resetting it
-// (as LazyInstance does not).
-struct NumberFormatWrapper {
- NumberFormatWrapper() {
- Reset();
- }
-
- void Reset() {
- // There's no ICU call to destroy a NumberFormat object other than
- // operator delete, so use the default Delete, which calls operator delete.
- // This can cause problems if a different allocator is used by this file
- // than by ICU.
- UErrorCode status = U_ZERO_ERROR;
- number_format.reset(icu::NumberFormat::createInstance(status));
- DCHECK(U_SUCCESS(status));
- }
-
- std::unique_ptr<icu::NumberFormat> number_format;
-};
-
-LazyInstance<NumberFormatWrapper>::DestructorAtExit g_number_format_int =
- LAZY_INSTANCE_INITIALIZER;
-LazyInstance<NumberFormatWrapper>::DestructorAtExit g_number_format_float =
- LAZY_INSTANCE_INITIALIZER;
-
-} // namespace
-
-string16 FormatNumber(int64_t number) {
- icu::NumberFormat* number_format =
- g_number_format_int.Get().number_format.get();
-
- if (!number_format) {
- // As a fallback, just return the raw number in a string.
- return ASCIIToUTF16(StringPrintf("%" PRId64, number));
- }
- icu::UnicodeString ustr;
- number_format->format(number, ustr);
-
- return i18n::UnicodeStringToString16(ustr);
-}
-
-string16 FormatDouble(double number, int fractional_digits) {
- icu::NumberFormat* number_format =
- g_number_format_float.Get().number_format.get();
-
- if (!number_format) {
- // As a fallback, just return the raw number in a string.
- return ASCIIToUTF16(StringPrintf("%f", number));
- }
- number_format->setMaximumFractionDigits(fractional_digits);
- number_format->setMinimumFractionDigits(fractional_digits);
- icu::UnicodeString ustr;
- number_format->format(number, ustr);
-
- return i18n::UnicodeStringToString16(ustr);
-}
-
-string16 FormatPercent(int number) {
- return i18n::MessageFormatter::FormatWithNumberedArgs(
- ASCIIToUTF16("{0,number,percent}"), static_cast<double>(number) / 100.0);
-}
-
-namespace testing {
-
-void ResetFormatters() {
- g_number_format_int.Get().Reset();
- g_number_format_float.Get().Reset();
-}
-
-} // namespace testing
-
-} // namespace base
diff --git a/base/i18n/number_formatting.h b/base/i18n/number_formatting.h
deleted file mode 100644
index 9636bf4..0000000
--- a/base/i18n/number_formatting.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_NUMBER_FORMATTING_H_
-#define BASE_I18N_NUMBER_FORMATTING_H_
-
-#include <stdint.h>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-// Return a number formatted with separators in the user's locale.
-// Ex: FormatNumber(1234567) => "1,234,567" in English, "1.234.567" in German
-BASE_I18N_EXPORT string16 FormatNumber(int64_t number);
-
-// Return a number formatted with separators in the user's locale.
-// Ex: FormatDouble(1234567.8, 1)
-// => "1,234,567.8" in English, "1.234.567,8" in German
-BASE_I18N_EXPORT string16 FormatDouble(double number, int fractional_digits);
-
-// Return a percentage formatted with space and symbol in the user's locale.
-// Ex: FormatPercent(12) => "12%" in English, "12 %" in Romanian
-BASE_I18N_EXPORT string16 FormatPercent(int number);
-
-namespace testing {
-
-// Causes cached formatters to be discarded and recreated. Only useful for
-// testing.
-BASE_I18N_EXPORT void ResetFormatters();
-
-} // namespace testing
-
-} // namespace base
-
-#endif // BASE_I18N_NUMBER_FORMATTING_H_
diff --git a/base/i18n/rtl.cc b/base/i18n/rtl.cc
deleted file mode 100644
index 295968b..0000000
--- a/base/i18n/rtl.cc
+++ /dev/null
@@ -1,491 +0,0 @@
-// 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/rtl.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/i18n/base_i18n_switches.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build_config.h"
-#include "third_party/icu/source/common/unicode/locid.h"
-#include "third_party/icu/source/common/unicode/uchar.h"
-#include "third_party/icu/source/common/unicode/uscript.h"
-#include "third_party/icu/source/i18n/unicode/coll.h"
-
-#if defined(OS_IOS)
-#include "base/debug/crash_logging.h"
-#include "base/ios/ios_util.h"
-#endif
-
-namespace {
-
-// Extract language, country and variant, but ignore keywords. For example,
-// en-US, ca@valencia, ca-ES@valencia.
-std::string GetLocaleString(const icu::Locale& locale) {
- const char* language = locale.getLanguage();
- const char* country = locale.getCountry();
- const char* variant = locale.getVariant();
-
- std::string result =
- (language != nullptr && *language != '\0') ? language : "und";
-
- if (country != nullptr && *country != '\0') {
- result += '-';
- result += country;
- }
-
- if (variant != nullptr && *variant != '\0')
- result += '@' + base::ToLowerASCII(variant);
-
- return result;
-}
-
-// Returns LEFT_TO_RIGHT or RIGHT_TO_LEFT if |character| has strong
-// directionality, returns UNKNOWN_DIRECTION if it doesn't. Please refer to
-// http://unicode.org/reports/tr9/ for more information.
-base::i18n::TextDirection GetCharacterDirection(UChar32 character) {
- static bool has_switch = base::CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kForceTextDirection);
- if (has_switch) {
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- std::string force_flag =
- command_line->GetSwitchValueASCII(switches::kForceTextDirection);
-
- if (force_flag == switches::kForceDirectionRTL)
- return base::i18n::RIGHT_TO_LEFT;
- if (force_flag == switches::kForceDirectionLTR)
- return base::i18n::LEFT_TO_RIGHT;
- }
- // Now that we have the character, we use ICU in order to query for the
- // appropriate Unicode BiDi character type.
- int32_t property = u_getIntPropertyValue(character, UCHAR_BIDI_CLASS);
- if ((property == U_RIGHT_TO_LEFT) ||
- (property == U_RIGHT_TO_LEFT_ARABIC) ||
- (property == U_RIGHT_TO_LEFT_EMBEDDING) ||
- (property == U_RIGHT_TO_LEFT_OVERRIDE)) {
- return base::i18n::RIGHT_TO_LEFT;
- } else if ((property == U_LEFT_TO_RIGHT) ||
- (property == U_LEFT_TO_RIGHT_EMBEDDING) ||
- (property == U_LEFT_TO_RIGHT_OVERRIDE)) {
- return base::i18n::LEFT_TO_RIGHT;
- }
- return base::i18n::UNKNOWN_DIRECTION;
-}
-
-} // namespace
-
-namespace base {
-namespace i18n {
-
-// Represents the locale-specific ICU text direction.
-static TextDirection g_icu_text_direction = UNKNOWN_DIRECTION;
-
-// Convert the ICU default locale to a string.
-std::string GetConfiguredLocale() {
- return GetLocaleString(icu::Locale::getDefault());
-}
-
-// Convert the ICU canonicalized locale to a string.
-std::string GetCanonicalLocale(const std::string& locale) {
- return GetLocaleString(icu::Locale::createCanonical(locale.c_str()));
-}
-
-// Convert Chrome locale name to ICU locale name
-std::string ICULocaleName(const std::string& locale_string) {
- // If not Spanish, just return it.
- if (locale_string.substr(0, 2) != "es")
- return locale_string;
- // Expand es to es-ES.
- if (LowerCaseEqualsASCII(locale_string, "es"))
- return "es-ES";
- // Map es-419 (Latin American Spanish) to es-FOO depending on the system
- // locale. If it's es-RR other than es-ES, map to es-RR. Otherwise, map
- // to es-MX (the most populous in Spanish-speaking Latin America).
- if (LowerCaseEqualsASCII(locale_string, "es-419")) {
- const icu::Locale& locale = icu::Locale::getDefault();
- std::string language = locale.getLanguage();
- const char* country = locale.getCountry();
- if (LowerCaseEqualsASCII(language, "es") &&
- !LowerCaseEqualsASCII(country, "es")) {
- language += '-';
- language += country;
- return language;
- }
- return "es-MX";
- }
- // Currently, Chrome has only "es" and "es-419", but later we may have
- // more specific "es-RR".
- return locale_string;
-}
-
-void SetICUDefaultLocale(const std::string& locale_string) {
-#if defined(OS_IOS)
- static base::debug::CrashKeyString* crash_key_locale =
- base::debug::AllocateCrashKeyString("icu_locale_input",
- base::debug::CrashKeySize::Size256);
- base::debug::SetCrashKeyString(crash_key_locale, locale_string);
-#endif
- icu::Locale locale(ICULocaleName(locale_string).c_str());
- UErrorCode error_code = U_ZERO_ERROR;
- const char* lang = locale.getLanguage();
- if (lang != nullptr && *lang != '\0') {
- icu::Locale::setDefault(locale, error_code);
- } else {
- LOG(ERROR) << "Failed to set the ICU default locale to " << locale_string
- << ". Falling back to en-US.";
- icu::Locale::setDefault(icu::Locale::getUS(), error_code);
- }
- g_icu_text_direction = UNKNOWN_DIRECTION;
-}
-
-bool IsRTL() {
- return ICUIsRTL();
-}
-
-bool ICUIsRTL() {
- if (g_icu_text_direction == UNKNOWN_DIRECTION) {
- const icu::Locale& locale = icu::Locale::getDefault();
- g_icu_text_direction = GetTextDirectionForLocaleInStartUp(locale.getName());
- }
- return g_icu_text_direction == RIGHT_TO_LEFT;
-}
-
-TextDirection GetForcedTextDirection() {
-// On iOS, check for RTL forcing.
-#if defined(OS_IOS)
- if (base::ios::IsInForcedRTL())
- return base::i18n::RIGHT_TO_LEFT;
-#endif
-
- base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
- if (command_line->HasSwitch(switches::kForceUIDirection)) {
- std::string force_flag =
- command_line->GetSwitchValueASCII(switches::kForceUIDirection);
-
- if (force_flag == switches::kForceDirectionLTR)
- return base::i18n::LEFT_TO_RIGHT;
-
- if (force_flag == switches::kForceDirectionRTL)
- return base::i18n::RIGHT_TO_LEFT;
- }
-
- return base::i18n::UNKNOWN_DIRECTION;
-}
-
-TextDirection GetTextDirectionForLocaleInStartUp(const char* locale_name) {
- // Check for direction forcing.
- TextDirection forced_direction = GetForcedTextDirection();
- if (forced_direction != UNKNOWN_DIRECTION)
- return forced_direction;
-
- // This list needs to be updated in alphabetical order if we add more RTL
- // locales.
- static const char kRTLLanguageCodes[][3] = {"ar", "fa", "he", "iw", "ur"};
- std::vector<StringPiece> locale_split =
- SplitStringPiece(locale_name, "-_", KEEP_WHITESPACE, SPLIT_WANT_ALL);
- const StringPiece& language_code = locale_split[0];
- if (std::binary_search(kRTLLanguageCodes,
- kRTLLanguageCodes + arraysize(kRTLLanguageCodes),
- language_code))
- return RIGHT_TO_LEFT;
- return LEFT_TO_RIGHT;
-}
-
-TextDirection GetTextDirectionForLocale(const char* locale_name) {
- // Check for direction forcing.
- TextDirection forced_direction = GetForcedTextDirection();
- if (forced_direction != UNKNOWN_DIRECTION)
- return forced_direction;
-
- UErrorCode status = U_ZERO_ERROR;
- ULayoutType layout_dir = uloc_getCharacterOrientation(locale_name, &status);
- DCHECK(U_SUCCESS(status));
- // Treat anything other than RTL as LTR.
- return (layout_dir != ULOC_LAYOUT_RTL) ? LEFT_TO_RIGHT : RIGHT_TO_LEFT;
-}
-
-TextDirection GetFirstStrongCharacterDirection(const string16& text) {
- const UChar* string = text.c_str();
- size_t length = text.length();
- size_t position = 0;
- while (position < length) {
- UChar32 character;
- size_t next_position = position;
- U16_NEXT(string, next_position, length, character);
- TextDirection direction = GetCharacterDirection(character);
- if (direction != UNKNOWN_DIRECTION)
- return direction;
- position = next_position;
- }
- return LEFT_TO_RIGHT;
-}
-
-TextDirection GetLastStrongCharacterDirection(const string16& text) {
- const UChar* string = text.c_str();
- size_t position = text.length();
- while (position > 0) {
- UChar32 character;
- size_t prev_position = position;
- U16_PREV(string, 0, prev_position, character);
- TextDirection direction = GetCharacterDirection(character);
- if (direction != UNKNOWN_DIRECTION)
- return direction;
- position = prev_position;
- }
- return LEFT_TO_RIGHT;
-}
-
-TextDirection GetStringDirection(const string16& text) {
- const UChar* string = text.c_str();
- size_t length = text.length();
- size_t position = 0;
-
- TextDirection result(UNKNOWN_DIRECTION);
- while (position < length) {
- UChar32 character;
- size_t next_position = position;
- U16_NEXT(string, next_position, length, character);
- TextDirection direction = GetCharacterDirection(character);
- if (direction != UNKNOWN_DIRECTION) {
- if (result != UNKNOWN_DIRECTION && result != direction)
- return UNKNOWN_DIRECTION;
- result = direction;
- }
- position = next_position;
- }
-
- // Handle the case of a string not containing any strong directionality
- // characters defaulting to LEFT_TO_RIGHT.
- if (result == UNKNOWN_DIRECTION)
- return LEFT_TO_RIGHT;
-
- return result;
-}
-
-#if defined(OS_WIN)
-bool AdjustStringForLocaleDirection(string16* text) {
- if (!IsRTL() || text->empty())
- return false;
-
- // Marking the string as LTR if the locale is RTL and the string does not
- // contain strong RTL characters. Otherwise, mark the string as RTL.
- bool has_rtl_chars = StringContainsStrongRTLChars(*text);
- if (!has_rtl_chars)
- WrapStringWithLTRFormatting(text);
- else
- WrapStringWithRTLFormatting(text);
-
- return true;
-}
-
-bool UnadjustStringForLocaleDirection(string16* text) {
- if (!IsRTL() || text->empty())
- return false;
-
- *text = StripWrappingBidiControlCharacters(*text);
- return true;
-}
-#else
-bool AdjustStringForLocaleDirection(string16* text) {
- // On OS X & GTK the directionality of a label is determined by the first
- // strongly directional character.
- // However, we want to make sure that in an LTR-language-UI all strings are
- // left aligned and vice versa.
- // A problem can arise if we display a string which starts with user input.
- // User input may be of the opposite directionality to the UI. So the whole
- // string will be displayed in the opposite directionality, e.g. if we want to
- // display in an LTR UI [such as US English]:
- //
- // EMAN_NOISNETXE is now installed.
- //
- // Since EXTENSION_NAME begins with a strong RTL char, the label's
- // directionality will be set to RTL and the string will be displayed visually
- // as:
- //
- // .is now installed EMAN_NOISNETXE
- //
- // In order to solve this issue, we prepend an LRM to the string. An LRM is a
- // strongly directional LTR char.
- // We also append an LRM at the end, which ensures that we're in an LTR
- // context.
-
- // Unlike Windows, Linux and OS X can correctly display RTL glyphs out of the
- // box so there is no issue with displaying zero-width bidi control characters
- // on any system. Thus no need for the !IsRTL() check here.
- if (text->empty())
- return false;
-
- bool ui_direction_is_rtl = IsRTL();
-
- bool has_rtl_chars = StringContainsStrongRTLChars(*text);
- if (!ui_direction_is_rtl && has_rtl_chars) {
- WrapStringWithRTLFormatting(text);
- text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
- kLeftToRightMark);
- text->push_back(kLeftToRightMark);
- } else if (ui_direction_is_rtl && has_rtl_chars) {
- WrapStringWithRTLFormatting(text);
- text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
- kRightToLeftMark);
- text->push_back(kRightToLeftMark);
- } else if (ui_direction_is_rtl) {
- WrapStringWithLTRFormatting(text);
- text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
- kRightToLeftMark);
- text->push_back(kRightToLeftMark);
- } else {
- return false;
- }
-
- return true;
-}
-
-bool UnadjustStringForLocaleDirection(string16* text) {
- if (text->empty())
- return false;
-
- size_t begin_index = 0;
- char16 begin = text->at(begin_index);
- if (begin == kLeftToRightMark ||
- begin == kRightToLeftMark) {
- ++begin_index;
- }
-
- size_t end_index = text->length() - 1;
- char16 end = text->at(end_index);
- if (end == kLeftToRightMark ||
- end == kRightToLeftMark) {
- --end_index;
- }
-
- string16 unmarked_text =
- text->substr(begin_index, end_index - begin_index + 1);
- *text = StripWrappingBidiControlCharacters(unmarked_text);
- return true;
-}
-
-#endif // !OS_WIN
-
-void EnsureTerminatedDirectionalFormatting(string16* text) {
- int count = 0;
- for (auto c : *text) {
- if (c == kLeftToRightEmbeddingMark || c == kRightToLeftEmbeddingMark ||
- c == kLeftToRightOverride || c == kRightToLeftOverride) {
- ++count;
- } else if (c == kPopDirectionalFormatting && count > 0) {
- --count;
- }
- }
- for (int j = 0; j < count; j++)
- text->push_back(kPopDirectionalFormatting);
-}
-
-void SanitizeUserSuppliedString(string16* text) {
- EnsureTerminatedDirectionalFormatting(text);
- AdjustStringForLocaleDirection(text);
-}
-
-bool StringContainsStrongRTLChars(const string16& text) {
- const UChar* string = text.c_str();
- size_t length = text.length();
- size_t position = 0;
- while (position < length) {
- UChar32 character;
- size_t next_position = position;
- U16_NEXT(string, next_position, length, character);
-
- // Now that we have the character, we use ICU in order to query for the
- // appropriate Unicode BiDi character type.
- int32_t property = u_getIntPropertyValue(character, UCHAR_BIDI_CLASS);
- if ((property == U_RIGHT_TO_LEFT) || (property == U_RIGHT_TO_LEFT_ARABIC))
- return true;
-
- position = next_position;
- }
-
- return false;
-}
-
-void WrapStringWithLTRFormatting(string16* text) {
- if (text->empty())
- return;
-
- // Inserting an LRE (Left-To-Right Embedding) mark as the first character.
- text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
- kLeftToRightEmbeddingMark);
-
- // Inserting a PDF (Pop Directional Formatting) mark as the last character.
- text->push_back(kPopDirectionalFormatting);
-}
-
-void WrapStringWithRTLFormatting(string16* text) {
- if (text->empty())
- return;
-
- // Inserting an RLE (Right-To-Left Embedding) mark as the first character.
- text->insert(static_cast<size_t>(0), static_cast<size_t>(1),
- kRightToLeftEmbeddingMark);
-
- // Inserting a PDF (Pop Directional Formatting) mark as the last character.
- text->push_back(kPopDirectionalFormatting);
-}
-
-void WrapPathWithLTRFormatting(const FilePath& path,
- string16* rtl_safe_path) {
- // Wrap the overall path with LRE-PDF pair which essentialy marks the
- // string as a Left-To-Right string.
- // Inserting an LRE (Left-To-Right Embedding) mark as the first character.
- rtl_safe_path->push_back(kLeftToRightEmbeddingMark);
-#if defined(OS_MACOSX)
- rtl_safe_path->append(UTF8ToUTF16(path.value()));
-#elif defined(OS_WIN)
- rtl_safe_path->append(path.value());
-#else // defined(OS_POSIX) && !defined(OS_MACOSX)
- std::wstring wide_path = base::SysNativeMBToWide(path.value());
- rtl_safe_path->append(WideToUTF16(wide_path));
-#endif
- // Inserting a PDF (Pop Directional Formatting) mark as the last character.
- rtl_safe_path->push_back(kPopDirectionalFormatting);
-}
-
-string16 GetDisplayStringInLTRDirectionality(const string16& text) {
- // Always wrap the string in RTL UI (it may be appended to RTL string).
- // Also wrap strings with an RTL first strong character direction in LTR UI.
- if (IsRTL() || GetFirstStrongCharacterDirection(text) == RIGHT_TO_LEFT) {
- string16 text_mutable(text);
- WrapStringWithLTRFormatting(&text_mutable);
- return text_mutable;
- }
- return text;
-}
-
-string16 StripWrappingBidiControlCharacters(const string16& text) {
- if (text.empty())
- return text;
- size_t begin_index = 0;
- char16 begin = text[begin_index];
- if (begin == kLeftToRightEmbeddingMark ||
- begin == kRightToLeftEmbeddingMark ||
- begin == kLeftToRightOverride ||
- begin == kRightToLeftOverride)
- ++begin_index;
- size_t end_index = text.length() - 1;
- if (text[end_index] == kPopDirectionalFormatting)
- --end_index;
- return text.substr(begin_index, end_index - begin_index + 1);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/rtl.h b/base/i18n/rtl.h
deleted file mode 100644
index d3ba29f..0000000
--- a/base/i18n/rtl.h
+++ /dev/null
@@ -1,168 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_RTL_H_
-#define BASE_I18N_RTL_H_
-
-#include <string>
-
-#include "base/compiler_specific.h"
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-#include "build_config.h"
-
-namespace base {
-
-class FilePath;
-
-namespace i18n {
-
-const char16 kRightToLeftMark = 0x200F;
-const char16 kLeftToRightMark = 0x200E;
-const char16 kLeftToRightEmbeddingMark = 0x202A;
-const char16 kRightToLeftEmbeddingMark = 0x202B;
-const char16 kPopDirectionalFormatting = 0x202C;
-const char16 kLeftToRightOverride = 0x202D;
-const char16 kRightToLeftOverride = 0x202E;
-
-// Locale.java mirrored this enum TextDirection. Please keep in sync.
-enum TextDirection {
- UNKNOWN_DIRECTION = 0,
- RIGHT_TO_LEFT = 1,
- LEFT_TO_RIGHT = 2,
- TEXT_DIRECTION_MAX = LEFT_TO_RIGHT,
-};
-
-// Get the locale that the currently running process has been configured to use.
-// The return value is of the form language[-country] (e.g., en-US) where the
-// language is the 2 or 3 letter code from ISO-639.
-BASE_I18N_EXPORT std::string GetConfiguredLocale();
-
-// Canonicalize a string (eg. a POSIX locale string) to a Chrome locale name.
-BASE_I18N_EXPORT std::string GetCanonicalLocale(const std::string& locale);
-
-// Sets the default locale of ICU.
-// Once the application locale of Chrome in GetApplicationLocale is determined,
-// the default locale of ICU need to be changed to match the application locale
-// so that ICU functions work correctly in a locale-dependent manner.
-// This is handy in that we don't have to call GetApplicationLocale()
-// everytime we call locale-dependent ICU APIs as long as we make sure
-// that this is called before any locale-dependent API is called.
-BASE_I18N_EXPORT void SetICUDefaultLocale(const std::string& locale_string);
-
-// Returns true if the application text direction is right-to-left.
-BASE_I18N_EXPORT bool IsRTL();
-
-// Returns whether the text direction for the default ICU locale is RTL. This
-// assumes that SetICUDefaultLocale has been called to set the default locale to
-// the UI locale of Chrome.
-// NOTE: Generally, you should call IsRTL() instead of this.
-BASE_I18N_EXPORT bool ICUIsRTL();
-
-// Gets the explicitly forced text direction for debugging. If no forcing is
-// applied, returns UNKNOWN_DIRECTION.
-BASE_I18N_EXPORT TextDirection GetForcedTextDirection();
-
-// Returns the text direction for |locale_name|.
-// As a startup optimization, this method checks the locale against a list of
-// Chrome-supported RTL locales.
-BASE_I18N_EXPORT TextDirection
-GetTextDirectionForLocaleInStartUp(const char* locale_name);
-
-// Returns the text direction for |locale_name|.
-BASE_I18N_EXPORT TextDirection GetTextDirectionForLocale(
- const char* locale_name);
-
-// Given the string in |text|, returns the directionality of the first or last
-// character with strong directionality in the string. If no character in the
-// text has strong directionality, LEFT_TO_RIGHT is returned. The Bidi
-// character types L, LRE, LRO, R, AL, RLE, and RLO are considered as strong
-// directionality characters. Please refer to http://unicode.org/reports/tr9/
-// for more information.
-BASE_I18N_EXPORT TextDirection GetFirstStrongCharacterDirection(
- const string16& text);
-BASE_I18N_EXPORT TextDirection GetLastStrongCharacterDirection(
- const string16& text);
-
-// Given the string in |text|, returns LEFT_TO_RIGHT or RIGHT_TO_LEFT if all the
-// strong directionality characters in the string are of the same
-// directionality. It returns UNKNOWN_DIRECTION if the string contains a mix of
-// LTR and RTL strong directionality characters. Defaults to LEFT_TO_RIGHT if
-// the string does not contain directionality characters. Please refer to
-// http://unicode.org/reports/tr9/ for more information.
-BASE_I18N_EXPORT TextDirection GetStringDirection(const string16& text);
-
-// Given the string in |text|, this function modifies the string in place with
-// the appropriate Unicode formatting marks that mark the string direction
-// (either left-to-right or right-to-left). The function checks both the current
-// locale and the contents of the string in order to determine the direction of
-// the returned string. The function returns true if the string in |text| was
-// properly adjusted.
-//
-// Certain LTR strings are not rendered correctly when the context is RTL. For
-// example, the string "Foo!" will appear as "!Foo" if it is rendered as is in
-// an RTL context. Calling this function will make sure the returned localized
-// string is always treated as a right-to-left string. This is done by
-// inserting certain Unicode formatting marks into the returned string.
-//
-// ** Notes about the Windows version of this function:
-// TODO(idana) bug 6806: this function adjusts the string in question only
-// if the current locale is right-to-left. The function does not take care of
-// the opposite case (an RTL string displayed in an LTR context) since
-// adjusting the string involves inserting Unicode formatting characters that
-// Windows does not handle well unless right-to-left language support is
-// installed. Since the English version of Windows doesn't have right-to-left
-// language support installed by default, inserting the direction Unicode mark
-// results in Windows displaying squares.
-BASE_I18N_EXPORT bool AdjustStringForLocaleDirection(string16* text);
-
-// Undoes the actions of the above function (AdjustStringForLocaleDirection).
-BASE_I18N_EXPORT bool UnadjustStringForLocaleDirection(string16* text);
-
-// Ensures |text| contains no unterminated directional formatting characters, by
-// appending the appropriate pop-directional-formatting characters to the end of
-// |text|.
-BASE_I18N_EXPORT void EnsureTerminatedDirectionalFormatting(string16* text);
-
-// Sanitizes the |text| by terminating any directional override/embedding
-// characters and then adjusting the string for locale direction.
-BASE_I18N_EXPORT void SanitizeUserSuppliedString(string16* text);
-
-// Returns true if the string contains at least one character with strong right
-// to left directionality; that is, a character with either R or AL Unicode
-// BiDi character type.
-BASE_I18N_EXPORT bool StringContainsStrongRTLChars(const string16& text);
-
-// Wraps a string with an LRE-PDF pair which essentialy marks the string as a
-// Left-To-Right string. Doing this is useful in order to make sure LTR
-// strings are rendered properly in an RTL context.
-BASE_I18N_EXPORT void WrapStringWithLTRFormatting(string16* text);
-
-// Wraps a string with an RLE-PDF pair which essentialy marks the string as a
-// Right-To-Left string. Doing this is useful in order to make sure RTL
-// strings are rendered properly in an LTR context.
-BASE_I18N_EXPORT void WrapStringWithRTLFormatting(string16* text);
-
-// Wraps file path to get it to display correctly in RTL UI. All filepaths
-// should be passed through this function before display in UI for RTL locales.
-BASE_I18N_EXPORT void WrapPathWithLTRFormatting(const FilePath& path,
- string16* rtl_safe_path);
-
-// Return the string in |text| wrapped with LRE (Left-To-Right Embedding) and
-// PDF (Pop Directional Formatting) marks, if needed for UI display purposes.
-BASE_I18N_EXPORT string16 GetDisplayStringInLTRDirectionality(
- const string16& text) WARN_UNUSED_RESULT;
-
-// Strip the beginning (U+202A..U+202B, U+202D..U+202E) and/or ending (U+202C)
-// explicit bidi control characters from |text|, if there are any. Otherwise,
-// return the text itself. Explicit bidi control characters display and have
-// semantic effect. They can be deleted so they might not always appear in a
-// pair.
-BASE_I18N_EXPORT string16 StripWrappingBidiControlCharacters(
- const string16& text) WARN_UNUSED_RESULT;
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_RTL_H_
diff --git a/base/i18n/streaming_utf8_validator.cc b/base/i18n/streaming_utf8_validator.cc
deleted file mode 100644
index 19c86a3..0000000
--- a/base/i18n/streaming_utf8_validator.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2014 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.
-
-// This implementation doesn't use ICU. The ICU macros are oriented towards
-// character-at-a-time processing, whereas byte-at-a-time processing is easier
-// with streaming input.
-
-#include "base/i18n/streaming_utf8_validator.h"
-
-#include "base/i18n/utf8_validator_tables.h"
-#include "base/logging.h"
-
-namespace base {
-namespace {
-
-uint8_t StateTableLookup(uint8_t offset) {
- DCHECK_LT(offset, internal::kUtf8ValidatorTablesSize);
- return internal::kUtf8ValidatorTables[offset];
-}
-
-} // namespace
-
-StreamingUtf8Validator::State StreamingUtf8Validator::AddBytes(const char* data,
- size_t size) {
- // Copy |state_| into a local variable so that the compiler doesn't have to be
- // careful of aliasing.
- uint8_t state = state_;
- for (const char* p = data; p != data + size; ++p) {
- if ((*p & 0x80) == 0) {
- if (state == 0)
- continue;
- state = internal::I18N_UTF8_VALIDATOR_INVALID_INDEX;
- break;
- }
- const uint8_t shift_amount = StateTableLookup(state);
- const uint8_t shifted_char = (*p & 0x7F) >> shift_amount;
- state = StateTableLookup(state + shifted_char + 1);
- // State may be INVALID here, but this code is optimised for the case of
- // valid UTF-8 and it is more efficient (by about 2%) to not attempt an
- // early loop exit unless we hit an ASCII character.
- }
- state_ = state;
- return state == 0 ? VALID_ENDPOINT
- : state == internal::I18N_UTF8_VALIDATOR_INVALID_INDEX
- ? INVALID
- : VALID_MIDPOINT;
-}
-
-void StreamingUtf8Validator::Reset() {
- state_ = 0u;
-}
-
-bool StreamingUtf8Validator::Validate(const std::string& string) {
- return StreamingUtf8Validator().AddBytes(string.data(), string.size()) ==
- VALID_ENDPOINT;
-}
-
-} // namespace base
diff --git a/base/i18n/streaming_utf8_validator.h b/base/i18n/streaming_utf8_validator.h
deleted file mode 100644
index ebf38a6..0000000
--- a/base/i18n/streaming_utf8_validator.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2014 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.
-
-// A streaming validator for UTF-8. Validation is based on the definition in
-// RFC-3629. In particular, it does not reject the invalid characters rejected
-// by base::IsStringUTF8().
-//
-// The implementation detects errors on the first possible byte.
-
-#ifndef BASE_I18N_STREAMING_UTF8_VALIDATOR_H_
-#define BASE_I18N_STREAMING_UTF8_VALIDATOR_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/macros.h"
-
-namespace base {
-
-class BASE_I18N_EXPORT StreamingUtf8Validator {
- public:
- // The validator exposes 3 states. It starts in state VALID_ENDPOINT. As it
- // processes characters it alternates between VALID_ENDPOINT and
- // VALID_MIDPOINT. If it encounters an invalid byte or UTF-8 sequence the
- // state changes permanently to INVALID.
- enum State {
- VALID_ENDPOINT,
- VALID_MIDPOINT,
- INVALID
- };
-
- StreamingUtf8Validator() : state_(0u) {}
- // Trivial destructor intentionally omitted.
-
- // Validate |size| bytes starting at |data|. If the concatenation of all calls
- // to AddBytes() since this object was constructed or reset is a valid UTF-8
- // string, returns VALID_ENDPOINT. If it could be the prefix of a valid UTF-8
- // string, returns VALID_MIDPOINT. If an invalid byte or UTF-8 sequence was
- // present, returns INVALID.
- State AddBytes(const char* data, size_t size);
-
- // Return the object to a freshly-constructed state so that it can be re-used.
- void Reset();
-
- // Validate a complete string using the same criteria. Returns true if the
- // string only contains complete, valid UTF-8 codepoints.
- static bool Validate(const std::string& string);
-
- private:
- // The current state of the validator. Value 0 is the initial/valid state.
- // The state is stored as an offset into |kUtf8ValidatorTables|. The special
- // state |kUtf8InvalidState| is invalid.
- uint8_t state_;
-
- // This type could be made copyable but there is currently no use-case for
- // it.
- DISALLOW_COPY_AND_ASSIGN(StreamingUtf8Validator);
-};
-
-} // namespace base
-
-#endif // BASE_I18N_STREAMING_UTF8_VALIDATOR_H_
diff --git a/base/i18n/streaming_utf8_validator_perftest.cc b/base/i18n/streaming_utf8_validator_perftest.cc
deleted file mode 100644
index ad328f8..0000000
--- a/base/i18n/streaming_utf8_validator_perftest.cc
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright 2014 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.
-
-// All data that is passed through a WebSocket with type "Text" needs to be
-// validated as UTF8. Since this is done on the IO thread, it needs to be
-// reasonably fast.
-
-// We are only interested in the performance on valid UTF8. Invalid UTF8 will
-// result in a connection failure, so is unlikely to become a source of
-// performance issues.
-
-#include "base/i18n/streaming_utf8_validator.h"
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/test/perf_time_logger.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-namespace {
-
-// We want to test ranges of valid UTF-8 sequences. These ranges are inclusive.
-// They are intended to be large enough that the validator needs to do
-// meaningful work while being in some sense "realistic" (eg. control characters
-// are not included).
-const char kOneByteSeqRangeStart[] = " "; // U+0020
-const char kOneByteSeqRangeEnd[] = "~"; // U+007E
-
-const char kTwoByteSeqRangeStart[] = "\xc2\xa0"; // U+00A0 non-breaking space
-const char kTwoByteSeqRangeEnd[] = "\xc9\x8f"; // U+024F small y with stroke
-
-const char kThreeByteSeqRangeStart[] = "\xe3\x81\x82"; // U+3042 Hiragana "a"
-const char kThreeByteSeqRangeEnd[] = "\xe9\xbf\x83"; // U+9FC3 "to blink"
-
-const char kFourByteSeqRangeStart[] = "\xf0\xa0\x80\x8b"; // U+2000B
-const char kFourByteSeqRangeEnd[] = "\xf0\xaa\x9a\xb2"; // U+2A6B2
-
-// The different lengths of strings to test.
-const size_t kTestLengths[] = {1, 32, 256, 32768, 1 << 20};
-
-// Simplest possible byte-at-a-time validator, to provide a baseline
-// for comparison. This is only tried on 1-byte UTF-8 sequences, as
-// the results will not be meaningful with sequences containing
-// top-bit-set bytes.
-bool IsString7Bit(const std::string& s) {
- for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
- if (*it & 0x80)
- return false;
- }
- return true;
-}
-
-// Assumes that |previous| is a valid UTF-8 sequence, and attempts to return
-// the next one. Is just barely smart enough to iterate through the ranges
-// defined about.
-std::string NextUtf8Sequence(const std::string& previous) {
- DCHECK(StreamingUtf8Validator::Validate(previous));
- std::string next = previous;
- for (int i = static_cast<int>(previous.length() - 1); i >= 0; --i) {
- // All bytes in a UTF-8 sequence except the first one are
- // constrained to the range 0x80 to 0xbf, inclusive. When we
- // increment past 0xbf, we carry into the previous byte.
- if (i > 0 && next[i] == '\xbf') {
- next[i] = '\x80';
- continue; // carry
- }
- ++next[i];
- break; // no carry
- }
- DCHECK(StreamingUtf8Validator::Validate(next))
- << "Result \"" << next << "\" failed validation";
- return next;
-}
-
-typedef bool (*TestTargetType)(const std::string&);
-
-// Run fuction |target| over |test_string| |times| times, and report the results
-// using |description|.
-bool RunTest(const std::string& description,
- TestTargetType target,
- const std::string& test_string,
- int times) {
- base::PerfTimeLogger timer(description.c_str());
- bool result = true;
- for (int i = 0; i < times; ++i) {
- result = target(test_string) && result;
- }
- timer.Done();
- return result;
-}
-
-// Construct a string by repeating |input| enough times to equal or exceed
-// |length|.
-std::string ConstructRepeatedTestString(const std::string& input,
- size_t length) {
- std::string output = input;
- while (output.length() * 2 < length) {
- output += output;
- }
- if (output.length() < length) {
- output += ConstructRepeatedTestString(input, length - output.length());
- }
- return output;
-}
-
-// Construct a string by expanding the range of UTF-8 sequences
-// between |input_start| and |input_end|, inclusive, and then
-// repeating the resulting string until it equals or exceeds |length|
-// bytes. |input_start| and |input_end| must be valid UTF-8
-// sequences.
-std::string ConstructRangedTestString(const std::string& input_start,
- const std::string& input_end,
- size_t length) {
- std::string output = input_start;
- std::string input = input_start;
- while (output.length() < length && input != input_end) {
- input = NextUtf8Sequence(input);
- output += input;
- }
- if (output.length() < length) {
- output = ConstructRepeatedTestString(output, length);
- }
- return output;
-}
-
-struct TestFunctionDescription {
- TestTargetType function;
- const char* function_name;
-};
-
-bool IsStringUTF8(const std::string& str) {
- return base::IsStringUTF8(base::StringPiece(str));
-}
-
-// IsString7Bit is intentionally placed last so it can be excluded easily.
-const TestFunctionDescription kTestFunctions[] = {
- {&StreamingUtf8Validator::Validate, "StreamingUtf8Validator"},
- {&IsStringUTF8, "IsStringUTF8"}, {&IsString7Bit, "IsString7Bit"}};
-
-// Construct a test string from |construct_test_string| for each of the lengths
-// in |kTestLengths| in turn. For each string, run each test in |test_functions|
-// for a number of iterations such that the total number of bytes validated
-// is around 16MB.
-void RunSomeTests(
- const char format[],
- base::Callback<std::string(size_t length)> construct_test_string,
- const TestFunctionDescription* test_functions,
- size_t test_count) {
- for (size_t i = 0; i < arraysize(kTestLengths); ++i) {
- const size_t length = kTestLengths[i];
- const std::string test_string = construct_test_string.Run(length);
- const int real_length = static_cast<int>(test_string.length());
- const int times = (1 << 24) / real_length;
- for (size_t test_index = 0; test_index < test_count; ++test_index) {
- EXPECT_TRUE(RunTest(StringPrintf(format,
- test_functions[test_index].function_name,
- real_length,
- times),
- test_functions[test_index].function,
- test_string,
- times));
- }
- }
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, OneByteRepeated) {
- RunSomeTests("%s: bytes=1 repeated length=%d repeat=%d",
- base::Bind(ConstructRepeatedTestString, kOneByteSeqRangeStart),
- kTestFunctions,
- 3);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, OneByteRange) {
- RunSomeTests("%s: bytes=1 ranged length=%d repeat=%d",
- base::Bind(ConstructRangedTestString,
- kOneByteSeqRangeStart,
- kOneByteSeqRangeEnd),
- kTestFunctions,
- 3);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, TwoByteRepeated) {
- RunSomeTests("%s: bytes=2 repeated length=%d repeat=%d",
- base::Bind(ConstructRepeatedTestString, kTwoByteSeqRangeStart),
- kTestFunctions,
- 2);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, TwoByteRange) {
- RunSomeTests("%s: bytes=2 ranged length=%d repeat=%d",
- base::Bind(ConstructRangedTestString,
- kTwoByteSeqRangeStart,
- kTwoByteSeqRangeEnd),
- kTestFunctions,
- 2);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, ThreeByteRepeated) {
- RunSomeTests(
- "%s: bytes=3 repeated length=%d repeat=%d",
- base::Bind(ConstructRepeatedTestString, kThreeByteSeqRangeStart),
- kTestFunctions,
- 2);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, ThreeByteRange) {
- RunSomeTests("%s: bytes=3 ranged length=%d repeat=%d",
- base::Bind(ConstructRangedTestString,
- kThreeByteSeqRangeStart,
- kThreeByteSeqRangeEnd),
- kTestFunctions,
- 2);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, FourByteRepeated) {
- RunSomeTests("%s: bytes=4 repeated length=%d repeat=%d",
- base::Bind(ConstructRepeatedTestString, kFourByteSeqRangeStart),
- kTestFunctions,
- 2);
-}
-
-TEST(StreamingUtf8ValidatorPerfTest, FourByteRange) {
- RunSomeTests("%s: bytes=4 ranged length=%d repeat=%d",
- base::Bind(ConstructRangedTestString,
- kFourByteSeqRangeStart,
- kFourByteSeqRangeEnd),
- kTestFunctions,
- 2);
-}
-
-} // namespace
-} // namespace base
diff --git a/base/i18n/string_compare.cc b/base/i18n/string_compare.cc
deleted file mode 100644
index 649c281..0000000
--- a/base/i18n/string_compare.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2013 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/string_compare.h"
-
-#include "base/logging.h"
-#include "base/strings/utf_string_conversions.h"
-#include "third_party/icu/source/common/unicode/unistr.h"
-
-namespace base {
-namespace i18n {
-
-// Compares the character data stored in two different string16 strings by
-// specified Collator instance.
-UCollationResult CompareString16WithCollator(const icu::Collator& collator,
- const string16& lhs,
- const string16& rhs) {
- UErrorCode error = U_ZERO_ERROR;
- UCollationResult result = collator.compare(
- icu::UnicodeString(FALSE, lhs.c_str(), static_cast<int>(lhs.length())),
- icu::UnicodeString(FALSE, rhs.c_str(), static_cast<int>(rhs.length())),
- error);
- DCHECK(U_SUCCESS(error));
- return result;
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/string_compare.h b/base/i18n/string_compare.h
deleted file mode 100644
index 5fcc5fe..0000000
--- a/base/i18n/string_compare.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2013 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.
-
-#ifndef BASE_I18N_STRING_COMPARE_H_
-#define BASE_I18N_STRING_COMPARE_H_
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-#include "third_party/icu/source/i18n/unicode/coll.h"
-
-namespace base {
-namespace i18n {
-
-// Compares the two strings using the specified collator.
-BASE_I18N_EXPORT UCollationResult
-CompareString16WithCollator(const icu::Collator& collator,
- const string16& lhs,
- const string16& rhs);
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_STRING_COMPARE_H_
diff --git a/base/i18n/string_search.cc b/base/i18n/string_search.cc
deleted file mode 100644
index 2f6fee4..0000000
--- a/base/i18n/string_search.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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 <stdint.h>
-
-#include "base/i18n/string_search.h"
-#include "base/logging.h"
-
-#include "third_party/icu/source/i18n/unicode/usearch.h"
-
-namespace base {
-namespace i18n {
-
-FixedPatternStringSearchIgnoringCaseAndAccents::
-FixedPatternStringSearchIgnoringCaseAndAccents(const string16& find_this)
- : find_this_(find_this) {
- // usearch_open requires a valid string argument to be searched, even if we
- // want to set it by usearch_setText afterwards. So, supplying a dummy text.
- const string16& dummy = find_this_;
-
- UErrorCode status = U_ZERO_ERROR;
- search_ = usearch_open(find_this_.data(), find_this_.size(), dummy.data(),
- dummy.size(), uloc_getDefault(),
- nullptr, // breakiter
- &status);
- if (U_SUCCESS(status)) {
- UCollator* collator = usearch_getCollator(search_);
- ucol_setStrength(collator, UCOL_PRIMARY);
- usearch_reset(search_);
- }
-}
-
-FixedPatternStringSearchIgnoringCaseAndAccents::
-~FixedPatternStringSearchIgnoringCaseAndAccents() {
- if (search_)
- usearch_close(search_);
-}
-
-bool FixedPatternStringSearchIgnoringCaseAndAccents::Search(
- const string16& in_this, size_t* match_index, size_t* match_length) {
- UErrorCode status = U_ZERO_ERROR;
- usearch_setText(search_, in_this.data(), in_this.size(), &status);
-
- // Default to basic substring search if usearch fails. According to
- // http://icu-project.org/apiref/icu4c/usearch_8h.html, usearch_open will fail
- // if either |find_this| or |in_this| are empty. In either case basic
- // substring search will give the correct return value.
- if (!U_SUCCESS(status)) {
- size_t index = in_this.find(find_this_);
- if (index == string16::npos) {
- return false;
- } else {
- if (match_index)
- *match_index = index;
- if (match_length)
- *match_length = find_this_.size();
- return true;
- }
- }
-
- int32_t index = usearch_first(search_, &status);
- if (!U_SUCCESS(status) || index == USEARCH_DONE)
- return false;
- if (match_index)
- *match_index = static_cast<size_t>(index);
- if (match_length)
- *match_length = static_cast<size_t>(usearch_getMatchedLength(search_));
- return true;
-}
-
-bool StringSearchIgnoringCaseAndAccents(const string16& find_this,
- const string16& in_this,
- size_t* match_index,
- size_t* match_length) {
- return FixedPatternStringSearchIgnoringCaseAndAccents(find_this).Search(
- in_this, match_index, match_length);
-}
-
-} // namespace i18n
-} // namespace base
diff --git a/base/i18n/string_search.h b/base/i18n/string_search.h
deleted file mode 100644
index 07a29c1..0000000
--- a/base/i18n/string_search.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// 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.
-
-#ifndef BASE_I18N_STRING_SEARCH_H_
-#define BASE_I18N_STRING_SEARCH_H_
-
-#include <stddef.h>
-
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-
-struct UStringSearch;
-
-namespace base {
-namespace i18n {
-
-// Returns true if |in_this| contains |find_this|. If |match_index| or
-// |match_length| are non-NULL, they are assigned the start position and total
-// length of the match.
-//
-// Only differences between base letters are taken into consideration. Case and
-// accent differences are ignored. Please refer to 'primary level' in
-// http://userguide.icu-project.org/collation/concepts for additional details.
-BASE_I18N_EXPORT
- bool StringSearchIgnoringCaseAndAccents(const string16& find_this,
- const string16& in_this,
- size_t* match_index,
- size_t* match_length);
-
-// This class is for speeding up multiple StringSearchIgnoringCaseAndAccents()
-// with the same |find_this| argument. |find_this| is passed as the constructor
-// argument, and precomputation for searching is done only at that timing.
-class BASE_I18N_EXPORT FixedPatternStringSearchIgnoringCaseAndAccents {
- public:
- explicit FixedPatternStringSearchIgnoringCaseAndAccents(
- const string16& find_this);
- ~FixedPatternStringSearchIgnoringCaseAndAccents();
-
- // Returns true if |in_this| contains |find_this|. If |match_index| or
- // |match_length| are non-NULL, they are assigned the start position and total
- // length of the match.
- bool Search(const string16& in_this,
- size_t* match_index,
- size_t* match_length);
-
- private:
- string16 find_this_;
- UStringSearch* search_;
-};
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_I18N_STRING_SEARCH_H_
diff --git a/base/i18n/time_formatting.cc b/base/i18n/time_formatting.cc
deleted file mode 100644
index 3a5394a..0000000
--- a/base/i18n/time_formatting.cc
+++ /dev/null
@@ -1,301 +0,0 @@
-// 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 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 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));
- DCHECK(U_SUCCESS(status));
- icu::UnicodeString generated_pattern =
- generator->getBestPattern(icu::UnicodeString(pattern), status);
- DCHECK(U_SUCCESS(status));
-
- // Then, format the time using the generated pattern.
- icu::SimpleDateFormat formatter(generated_pattern, status);
- DCHECK(U_SUCCESS(status));
-
- return formatter;
-}
-
-UMeasureFormatWidth DurationWidthToMeasureWidth(DurationFormatWidth width) {
- switch (width) {
- case DURATION_WIDTH_WIDE: return UMEASFMT_WIDTH_WIDE;
- case DURATION_WIDTH_SHORT: return UMEASFMT_WIDTH_SHORT;
- case DURATION_WIDTH_NARROW: return UMEASFMT_WIDTH_NARROW;
- case DURATION_WIDTH_NUMERIC: return UMEASFMT_WIDTH_NUMERIC;
- }
- NOTREACHED();
- return UMEASFMT_WIDTH_COUNT;
-}
-
-const char* DateFormatToString(DateFormat format) {
- switch (format) {
- case DATE_FORMAT_YEAR_MONTH:
- return UDAT_YEAR_MONTH;
- case DATE_FORMAT_MONTH_WEEKDAY_DAY:
- return UDAT_MONTH_WEEKDAY_DAY;
- }
- NOTREACHED();
- return UDAT_YEAR_MONTH_DAY;
-}
-
-} // namespace
-
-string16 TimeFormatTimeOfDay(const Time& time) {
- // We can omit the locale parameter because the default should match
- // Chrome's application locale.
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createTimeInstance(icu::DateFormat::kShort));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatTimeOfDayWithMilliseconds(const Time& time) {
- icu::SimpleDateFormat formatter = CreateSimpleDateFormatter("HmsSSS");
- return TimeFormatWithoutAmPm(&formatter, time);
-}
-
-string16 TimeFormatTimeOfDayWithHourClockType(const Time& time,
- HourClockType type,
- AmPmClockType ampm) {
- // Just redirect to the normal function if the default type matches the
- // given type.
- HourClockType default_type = GetHourClockType();
- if (default_type == type && (type == k24HourClock || ampm == kKeepAmPm)) {
- return TimeFormatTimeOfDay(time);
- }
-
- const char* base_pattern = (type == k12HourClock ? "ahm" : "Hm");
- icu::SimpleDateFormat formatter = CreateSimpleDateFormatter(base_pattern);
-
- if (ampm == kKeepAmPm) {
- return TimeFormat(&formatter, time);
- } else {
- return TimeFormatWithoutAmPm(&formatter, time);
- }
-}
-
-string16 TimeFormatShortDate(const Time& time) {
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createDateInstance(icu::DateFormat::kMedium));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatShortDateNumeric(const Time& time) {
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createDateInstance(icu::DateFormat::kShort));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatShortDateAndTime(const Time& time) {
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createDateTimeInstance(icu::DateFormat::kShort));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatShortDateAndTimeWithTimeZone(const Time& time) {
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createDateTimeInstance(icu::DateFormat::kShort,
- icu::DateFormat::kLong));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatMonthAndYear(const Time& time) {
- icu::SimpleDateFormat formatter =
- CreateSimpleDateFormatter(DateFormatToString(DATE_FORMAT_YEAR_MONTH));
- return TimeFormat(&formatter, time);
-}
-
-string16 TimeFormatFriendlyDateAndTime(const Time& time) {
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createDateTimeInstance(icu::DateFormat::kFull));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatFriendlyDate(const Time& time) {
- std::unique_ptr<icu::DateFormat> formatter(
- icu::DateFormat::createDateInstance(icu::DateFormat::kFull));
- return TimeFormat(formatter.get(), time);
-}
-
-string16 TimeFormatWithPattern(const Time& time, const char* pattern) {
- icu::SimpleDateFormat formatter = CreateSimpleDateFormatter(pattern);
- return TimeFormat(&formatter, time);
-}
-
-bool TimeDurationFormat(const TimeDelta time,
- const DurationFormatWidth width,
- string16* out) {
- DCHECK(out);
- UErrorCode status = U_ZERO_ERROR;
- const int total_minutes = static_cast<int>(time.InSecondsF() / 60 + 0.5);
- const int hours = total_minutes / 60;
- const int minutes = total_minutes % 60;
- UMeasureFormatWidth u_width = DurationWidthToMeasureWidth(width);
-
- // TODO(derat): Delete the |status| checks and LOG(ERROR) calls throughout
- // this function once the cause of http://crbug.com/677043 is tracked down.
- const icu::Measure measures[] = {
- icu::Measure(hours, icu::MeasureUnit::createHour(status), status),
- icu::Measure(minutes, icu::MeasureUnit::createMinute(status), status)};
- if (U_FAILURE(status)) {
- LOG(ERROR) << "Creating MeasureUnit or Measure for " << hours << "h"
- << minutes << "m failed: " << u_errorName(status);
- return false;
- }
-
- icu::MeasureFormat measure_format(icu::Locale::getDefault(), u_width, status);
- if (U_FAILURE(status)) {
- LOG(ERROR) << "Creating MeasureFormat for "
- << icu::Locale::getDefault().getName()
- << " failed: " << u_errorName(status);
- return false;
- }
-
- 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 = 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 = 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 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.
- icu::UnicodeString pattern_unicode;
- formatter->toPattern(pattern_unicode);
-
- // Determine what hour clock type the current locale uses, by checking
- // "a" (am/pm marker) in the short time format. This is reliable as "a"
- // is used by all of 12-hour clock formats, but not any of 24-hour clock
- // formats, as shown below.
- //
- // % grep -A4 DateTimePatterns third_party/icu/source/data/locales/*.txt |
- // grep -B1 -- -- |grep -v -- '--' |
- // perl -nle 'print $1 if /^\S+\s+"(.*)"/' |sort -u
- //
- // H.mm
- // H:mm
- // HH.mm
- // HH:mm
- // a h:mm
- // ah:mm
- // ahh:mm
- // h-mm a
- // h:mm a
- // hh:mm a
- //
- // 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
diff --git a/base/i18n/time_formatting.h b/base/i18n/time_formatting.h
deleted file mode 100644
index 41793b3..0000000
--- a/base/i18n/time_formatting.h
+++ /dev/null
@@ -1,142 +0,0 @@
-// 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.
-
-// Basic time formatting methods. These methods use the current locale
-// formatting for displaying the time.
-
-#ifndef BASE_I18N_TIME_FORMATTING_H_
-#define BASE_I18N_TIME_FORMATTING_H_
-
-#include "base/compiler_specific.h"
-#include "base/i18n/base_i18n_export.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-class Time;
-class TimeDelta;
-
-// Argument type used to specify the hour clock type.
-enum HourClockType {
- k12HourClock, // Uses 1-12. e.g., "3:07 PM"
- k24HourClock, // Uses 0-23. e.g., "15:07"
-};
-
-// Argument type used to specify whether or not to include AM/PM sign.
-enum AmPmClockType {
- kDropAmPm, // Drops AM/PM sign. e.g., "3:07"
- kKeepAmPm, // Keeps AM/PM sign. e.g., "3:07 PM"
-};
-
-// Should match UMeasureFormatWidth in measfmt.h; replicated here to avoid
-// requiring third_party/icu dependencies with this file.
-enum DurationFormatWidth {
- DURATION_WIDTH_WIDE, // "3 hours, 7 minutes"
- DURATION_WIDTH_SHORT, // "3 hr, 7 min"
- DURATION_WIDTH_NARROW, // "3h 7m"
- DURATION_WIDTH_NUMERIC // "3:07"
-};
-
-// Date formats from third_party/icu/source/i18n/unicode/udat.h. Add more as
-// necessary.
-enum DateFormat {
- // November 2007
- DATE_FORMAT_YEAR_MONTH,
- // Tuesday, 7 November
- DATE_FORMAT_MONTH_WEEKDAY_DAY,
-};
-
-// TODO(derat@chromium.org): Update all of these functions to return boolean
-// "success" values and use out-params for formatted strings:
-// http://crbug.com/698802
-
-// Returns the time of day, e.g., "3:07 PM".
-BASE_I18N_EXPORT string16 TimeFormatTimeOfDay(const Time& time);
-
-// Returns the time of day in 24-hour clock format with millisecond accuracy,
-// e.g., "15:07:30.568"
-BASE_I18N_EXPORT string16 TimeFormatTimeOfDayWithMilliseconds(const Time& time);
-
-// Returns the time of day in the specified hour clock type. e.g.
-// "3:07 PM" (type == k12HourClock, ampm == kKeepAmPm).
-// "3:07" (type == k12HourClock, ampm == kDropAmPm).
-// "15:07" (type == k24HourClock).
-BASE_I18N_EXPORT string16 TimeFormatTimeOfDayWithHourClockType(
- const Time& time,
- HourClockType type,
- AmPmClockType ampm);
-
-// Returns a shortened date, e.g. "Nov 7, 2007"
-BASE_I18N_EXPORT string16 TimeFormatShortDate(const Time& time);
-
-// Returns a numeric date such as 12/13/52.
-BASE_I18N_EXPORT string16 TimeFormatShortDateNumeric(const Time& time);
-
-// Returns a numeric date and time such as "12/13/52 2:44:30 PM".
-BASE_I18N_EXPORT string16 TimeFormatShortDateAndTime(const Time& time);
-
-// Returns a month and year, e.g. "November 2007"
-BASE_I18N_EXPORT string16 TimeFormatMonthAndYear(const Time& time);
-
-// Returns a numeric date and time with time zone such as
-// "12/13/52 2:44:30 PM PST".
-BASE_I18N_EXPORT string16
-TimeFormatShortDateAndTimeWithTimeZone(const Time& time);
-
-// Formats a time in a friendly sentence format, e.g.
-// "Monday, March 6, 2008 2:44:30 PM".
-BASE_I18N_EXPORT string16 TimeFormatFriendlyDateAndTime(const Time& time);
-
-// Formats a time in a friendly sentence format, e.g.
-// "Monday, March 6, 2008".
-BASE_I18N_EXPORT string16 TimeFormatFriendlyDate(const Time& time);
-
-// Formats a time using a skeleton to produce a format for different locales
-// when an unusual time format is needed, e.g. "Feb. 2, 18:00".
-//
-// See http://userguide.icu-project.org/formatparse/datetime for details.
-BASE_I18N_EXPORT string16 TimeFormatWithPattern(const Time& time,
- const char* pattern);
-
-// Formats a time duration of hours and minutes into various formats, e.g.,
-// "3:07" or "3 hours, 7 minutes", and returns true on success. See
-// DurationFormatWidth for details.
-//
-// Please don't use width = DURATION_WIDTH_NUMERIC when the time duration
-// can possibly be larger than 24h, as the hour value will be cut below 24
-// after formatting.
-// TODO(chengx): fix function output when width = DURATION_WIDTH_NUMERIC
-// (http://crbug.com/675791)
-BASE_I18N_EXPORT bool TimeDurationFormat(const TimeDelta time,
- const DurationFormatWidth width,
- string16* out) WARN_UNUSED_RESULT;
-
-// Formats a time duration of hours, minutes and seconds into various formats,
-// e.g., "3:07:30" or "3 hours, 7 minutes, 30 seconds", and returns true on
-// success. See DurationFormatWidth for details.
-//
-// Please don't use width = DURATION_WIDTH_NUMERIC when the time duration
-// can possibly be larger than 24h, as the hour value will be cut below 24
-// after formatting.
-// TODO(chengx): fix function output when width = DURATION_WIDTH_NUMERIC
-// (http://crbug.com/675791)
-BASE_I18N_EXPORT bool TimeDurationFormatWithSeconds(
- const TimeDelta time,
- const DurationFormatWidth width,
- string16* out) WARN_UNUSED_RESULT;
-
-// Formats a date interval into various formats, e.g. "2 December - 4 December"
-// or "March 2016 - December 2016". See DateFormat for details.
-BASE_I18N_EXPORT string16 DateIntervalFormat(const Time& begin_time,
- const Time& end_time,
- DateFormat format);
-
-// Gets the hour clock type of the current locale. e.g.
-// k12HourClock (en-US).
-// k24HourClock (en-GB).
-BASE_I18N_EXPORT HourClockType GetHourClockType();
-
-} // namespace base
-
-#endif // BASE_I18N_TIME_FORMATTING_H_
diff --git a/base/i18n/timezone.cc b/base/i18n/timezone.cc
deleted file mode 100644
index 8624e07..0000000
--- a/base/i18n/timezone.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2013 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/timezone.h"
-
-#include <memory>
-#include <string>
-
-#include "third_party/icu/source/common/unicode/unistr.h"
-#include "third_party/icu/source/i18n/unicode/timezone.h"
-
-namespace base {
-
-std::string CountryCodeForCurrentTimezone() {
- std::unique_ptr<icu::TimeZone> zone(icu::TimeZone::createDefault());
- icu::UnicodeString id;
- // ICU returns '001' (world) for Etc/GMT. Preserve the old behavior
- // only for Etc/GMT while returning an empty string for Etc/UTC and
- // Etc/UCT because they're less likely to be chosen by mistake in UK in
- // place of Europe/London (Briitish Time).
- if (zone->getID(id) == UNICODE_STRING_SIMPLE("Etc/GMT"))
- return "GB";
- char region_code[4];
- UErrorCode status = U_ZERO_ERROR;
- int length = zone->getRegion(id, region_code, 4, status);
- // Return an empty string if region_code is a 3-digit numeric code such
- // as 001 (World) for Etc/UTC, Etc/UCT.
- return (U_SUCCESS(status) && length == 2)
- ? std::string(region_code, static_cast<size_t>(length))
- : std::string();
-}
-
-} // namespace base
diff --git a/base/i18n/timezone.h b/base/i18n/timezone.h
deleted file mode 100644
index 7557d44..0000000
--- a/base/i18n/timezone.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2013 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.
-
-#ifndef BASE_I18N_TIMEZONE_H_
-#define BASE_I18N_TIMEZONE_H_
-
-#include <string>
-
-#include "base/i18n/base_i18n_export.h"
-
-namespace base {
-
-// Checks the system timezone and turns it into a two-character ISO 3166 country
-// code. This may fail (for example, it used to always fail on Android), in
-// which case it will return an empty string. It'll also return an empty string
-// when the timezone is Etc/UTC or Etc/UCT, but will return 'GB" for Etc/GMT
-// because people in the UK tends to select Etc/GMT by mistake instead of
-// Europe/London (British Time).
-BASE_I18N_EXPORT std::string CountryCodeForCurrentTimezone();
-
-} // namespace base
-
-#endif // BASE_I18N_TIMEZONE_H_
diff --git a/base/i18n/unicodestring.h b/base/i18n/unicodestring.h
deleted file mode 100644
index b62c526..0000000
--- a/base/i18n/unicodestring.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) 2017 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.
-
-#ifndef BASE_I18N_UNICODESTRING_H_
-#define BASE_I18N_UNICODESTRING_H_
-
-#include "base/strings/string16.h"
-#include "third_party/icu/source/common/unicode/unistr.h"
-#include "third_party/icu/source/common/unicode/uvernum.h"
-
-#if U_ICU_VERSION_MAJOR_NUM >= 59
-#include "third_party/icu/source/common/unicode/char16ptr.h"
-#endif
-
-namespace base {
-namespace i18n {
-
-inline string16 UnicodeStringToString16(const icu::UnicodeString& unistr) {
-#if U_ICU_VERSION_MAJOR_NUM >= 59
- return base::string16(icu::toUCharPtr(unistr.getBuffer()),
- static_cast<size_t>(unistr.length()));
-#else
- return base::string16(unistr.getBuffer(),
- static_cast<size_t>(unistr.length()));
-#endif
-}
-
-} // namespace i18n
-} // namespace base
-
-#endif // BASE_UNICODESTRING_H_
diff --git a/base/i18n/utf8_validator_tables.cc b/base/i18n/utf8_validator_tables.cc
deleted file mode 100644
index 913afc7..0000000
--- a/base/i18n/utf8_validator_tables.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2014 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.
-
-// This file is auto-generated by build_utf8_validator_tables.
-// DO NOT EDIT.
-
-#include "base/i18n/utf8_validator_tables.h"
-
-namespace base {
-namespace internal {
-
-const uint8_t kUtf8ValidatorTables[] = {
- // State 0, offset 0x00
- 0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x08
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x10
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x18
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x20
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x28
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x30
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x38
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x40
- 0x81, 0x81, 0x81, 0x83, 0x83, 0x83, 0x83, 0x83, // 0x48
- 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, // 0x50
- 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, // 0x58
- 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, // 0x60
- 0x83, 0x86, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, // 0x68
- 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8e, 0x8b, // 0x70
- 0x8b, 0x93, 0x9c, 0x9c, 0x9c, 0x9f, 0x81, 0x81, // 0x78
- 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0x80
- 0x81, // 0x81
- // State 1, offset 0x81
- 0x07, 0x81, // 0x83
- // State 2, offset 0x83
- 0x06, 0x00, 0x81, // 0x86
- // State 3, offset 0x86
- 0x05, 0x81, 0x83, 0x81, 0x81, // 0x8b
- // State 4, offset 0x8b
- 0x06, 0x83, 0x81, // 0x8e
- // State 5, offset 0x8e
- 0x05, 0x83, 0x81, 0x81, 0x81, // 0x93
- // State 6, offset 0x93
- 0x04, 0x81, 0x8b, 0x8b, 0x8b, 0x81, 0x81, 0x81, // 0x9b
- 0x81, // 0x9c
- // State 7, offset 0x9c
- 0x06, 0x8b, 0x81, // 0x9f
- // State 8, offset 0x9f
- 0x04, 0x8b, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, // 0xa7
- 0x81, // 0xa8
-};
-
-const size_t kUtf8ValidatorTablesSize = arraysize(kUtf8ValidatorTables);
-
-} // namespace internal
-} // namespace base
diff --git a/base/i18n/utf8_validator_tables.h b/base/i18n/utf8_validator_tables.h
deleted file mode 100644
index 939616b..0000000
--- a/base/i18n/utf8_validator_tables.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2014 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.
-
-#ifndef BASE_I18N_UTF8_VALIDATOR_TABLES_H_
-#define BASE_I18N_UTF8_VALIDATOR_TABLES_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/macros.h"
-
-namespace base {
-namespace internal {
-
-// The tables for all states; a list of entries of the form (right_shift,
-// next_state, next_state, ....). The right_shifts are used to reduce the
-// overall size of the table. The table only covers bytes in the range
-// [0x80, 0xFF] to save space.
-extern const uint8_t kUtf8ValidatorTables[];
-
-extern const size_t kUtf8ValidatorTablesSize;
-
-// The offset of the INVALID state in kUtf8ValidatorTables.
-enum {
- I18N_UTF8_VALIDATOR_INVALID_INDEX = 129
-};
-
-} // namespace internal
-} // namespace base
-
-#endif // BASE_I18N_UTF8_VALIDATOR_TABLES_H_
diff --git a/base/win/i18n.cc b/base/win/i18n.cc
deleted file mode 100644
index d7017e3..0000000
--- a/base/win/i18n.cc
+++ /dev/null
@@ -1,171 +0,0 @@
-// 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/win/i18n.h"
-
-#include <windows.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace {
-
-// Keep this enum in sync with kLanguageFunctionNames.
-enum LanguageFunction {
- SYSTEM_LANGUAGES,
- USER_LANGUAGES,
- PROCESS_LANGUAGES,
- THREAD_LANGUAGES,
- NUM_FUNCTIONS
-};
-
-const char kSystemLanguagesFunctionName[] = "GetSystemPreferredUILanguages";
-const char kUserLanguagesFunctionName[] = "GetUserPreferredUILanguages";
-const char kProcessLanguagesFunctionName[] = "GetProcessPreferredUILanguages";
-const char kThreadLanguagesFunctionName[] = "GetThreadPreferredUILanguages";
-
-// Keep this array in sync with enum LanguageFunction.
-const char *const kLanguageFunctionNames[] = {
- &kSystemLanguagesFunctionName[0],
- &kUserLanguagesFunctionName[0],
- &kProcessLanguagesFunctionName[0],
- &kThreadLanguagesFunctionName[0]
-};
-
-static_assert(NUM_FUNCTIONS == arraysize(kLanguageFunctionNames),
- "LanguageFunction enum and kLanguageFunctionNames array must be "
- "kept in sync");
-
-// Calls one of the MUI Get*PreferredUILanguages functions, placing the result
-// in |languages|. |function| identifies the function to call and |flags| is
-// the function-specific flags (callers must not specify MUI_LANGUAGE_ID or
-// MUI_LANGUAGE_NAME). Returns true if at least one language is placed in
-// |languages|.
-bool GetMUIPreferredUILanguageList(LanguageFunction function, ULONG flags,
- std::vector<wchar_t>* languages) {
- DCHECK(0 <= function && NUM_FUNCTIONS > function);
- DCHECK_EQ(0U, (flags & (MUI_LANGUAGE_ID | MUI_LANGUAGE_NAME)));
- DCHECK(languages);
-
- HMODULE kernel32 = GetModuleHandle(L"kernel32.dll");
- if (NULL != kernel32) {
- typedef BOOL (WINAPI* GetPreferredUILanguages_Fn)(
- DWORD, PULONG, PZZWSTR, PULONG);
- GetPreferredUILanguages_Fn get_preferred_ui_languages =
- reinterpret_cast<GetPreferredUILanguages_Fn>(
- GetProcAddress(kernel32, kLanguageFunctionNames[function]));
- if (NULL != get_preferred_ui_languages) {
- const ULONG call_flags = flags | MUI_LANGUAGE_NAME;
- ULONG language_count = 0;
- ULONG buffer_length = 0;
- if (get_preferred_ui_languages(call_flags, &language_count, NULL,
- &buffer_length) &&
- 0 != buffer_length) {
- languages->resize(buffer_length);
- if (get_preferred_ui_languages(call_flags, &language_count,
- &(*languages)[0], &buffer_length) &&
- 0 != language_count) {
- DCHECK(languages->size() == buffer_length);
- return true;
- } else {
- DPCHECK(0 == language_count)
- << "Failed getting preferred UI languages.";
- }
- } else {
- DPCHECK(0 == buffer_length)
- << "Failed getting size of preferred UI languages.";
- }
- } else {
- DVLOG(2) << "MUI not available.";
- }
- } else {
- NOTREACHED() << "kernel32.dll not found.";
- }
-
- return false;
-}
-
-bool GetUserDefaultUILanguage(std::wstring* language, std::wstring* region) {
- DCHECK(language);
-
- LANGID lang_id = ::GetUserDefaultUILanguage();
- if (LOCALE_CUSTOM_UI_DEFAULT != lang_id) {
- const LCID locale_id = MAKELCID(lang_id, SORT_DEFAULT);
- // max size for LOCALE_SISO639LANGNAME and LOCALE_SISO3166CTRYNAME is 9
- wchar_t result_buffer[9];
- int result_length =
- GetLocaleInfo(locale_id, LOCALE_SISO639LANGNAME, &result_buffer[0],
- arraysize(result_buffer));
- DPCHECK(0 != result_length) << "Failed getting language id";
- if (1 < result_length) {
- language->assign(&result_buffer[0], result_length - 1);
- region->clear();
- if (SUBLANG_NEUTRAL != SUBLANGID(lang_id)) {
- result_length =
- GetLocaleInfo(locale_id, LOCALE_SISO3166CTRYNAME, &result_buffer[0],
- arraysize(result_buffer));
- DPCHECK(0 != result_length) << "Failed getting region id";
- if (1 < result_length)
- region->assign(&result_buffer[0], result_length - 1);
- }
- return true;
- }
- } else {
- // This is entirely unexpected on pre-Vista, which is the only time we
- // should try GetUserDefaultUILanguage anyway.
- NOTREACHED() << "Cannot determine language for a supplemental locale.";
- }
- return false;
-}
-
-bool GetPreferredUILanguageList(LanguageFunction function, ULONG flags,
- std::vector<std::wstring>* languages) {
- std::vector<wchar_t> buffer;
- std::wstring language;
- std::wstring region;
-
- if (GetMUIPreferredUILanguageList(function, flags, &buffer)) {
- std::vector<wchar_t>::const_iterator scan = buffer.begin();
- language.assign(&*scan);
- while (!language.empty()) {
- languages->push_back(language);
- scan += language.size() + 1;
- language.assign(&*scan);
- }
- } else if (GetUserDefaultUILanguage(&language, ®ion)) {
- // Mimic the MUI behavior of putting the neutral version of the lang after
- // the regional one (e.g., "fr-CA, fr").
- if (!region.empty())
- languages->push_back(std::wstring(language)
- .append(1, L'-')
- .append(region));
- languages->push_back(language);
- } else {
- return false;
- }
-
- return true;
-}
-
-} // namespace
-
-namespace base {
-namespace win {
-namespace i18n {
-
-bool GetUserPreferredUILanguageList(std::vector<std::wstring>* languages) {
- DCHECK(languages);
- return GetPreferredUILanguageList(USER_LANGUAGES, 0, languages);
-}
-
-bool GetThreadPreferredUILanguageList(std::vector<std::wstring>* languages) {
- DCHECK(languages);
- return GetPreferredUILanguageList(
- THREAD_LANGUAGES, MUI_MERGE_SYSTEM_FALLBACK | MUI_MERGE_USER_FALLBACK,
- languages);
-}
-
-} // namespace i18n
-} // namespace win
-} // namespace base
diff --git a/base/win/i18n.h b/base/win/i18n.h
deleted file mode 100644
index 9e74d3f..0000000
--- a/base/win/i18n.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// 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.
-
-#ifndef BASE_WIN_I18N_H_
-#define BASE_WIN_I18N_H_
-
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace win {
-namespace i18n {
-
-// Adds to |languages| the list of user preferred UI languages from MUI, if
-// available, falling-back on the user default UI language otherwise. Returns
-// true if at least one language is added.
-BASE_EXPORT bool GetUserPreferredUILanguageList(
- std::vector<std::wstring>* languages);
-
-// Adds to |languages| the list of thread, process, user, and system preferred
-// UI languages from MUI, if available, falling-back on the user default UI
-// language otherwise. Returns true if at least one language is added.
-BASE_EXPORT bool GetThreadPreferredUILanguageList(
- std::vector<std::wstring>* languages);
-
-} // namespace i18n
-} // namespace win
-} // namespace base
-
-#endif // BASE_WIN_I18N_H_
diff --git a/build/gen.py b/build/gen.py
index 37592d4..9cca4e9 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -756,7 +756,6 @@
'base/win/enum_variant.cc',
'base/win/event_trace_controller.cc',
'base/win/event_trace_provider.cc',
- 'base/win/i18n.cc',
'base/win/iat_patch_function.cc',
'base/win/iunknown_impl.cc',
'base/win/message_window.cc',
