Add Minikin Hyphenation engine for Android

third_party/WebKit/Source/platform/text/hyphenation/HyphenationMinikin.cpp

 // 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 "platform/text/Hyphenation.h"
 
 #include "base/files/file.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/elapsed_timer.h"
 #include "mojo/public/cpp/system/platform_handle.h"
+#include "platform/text/hyphenation/HyphenatorAOSP.h"
 #include "public/platform/Platform.h"
 #include "public/platform/ServiceRegistry.h"
 #include "public/platform/modules/hyphenation/hyphenation.mojom-blink.h"
 
 namespace blink {
 
+using Hyphenator = android::Hyphenator;
+
 class HyphenationMinikin : public Hyphenation {
 public:
     bool openDictionary(const AtomicString& locale);
 
     size_t lastHyphenLocation(const StringView& text, size_t beforeIndex) const override;
+    Vector<size_t, 8> hyphenLocations(const StringView&) const override;
 
 private:
     static base::PlatformFile openDictionaryFile(const AtomicString& locale);
 
+    std::vector<uint8_t> hyphenate(const StringView&) const;
+
     base::MemoryMappedFile m_file;
+    std::unique_ptr<Hyphenator> m_hyphenator;
 };
 
 static mojom::blink::HyphenationPtr connectToRemoteService()
 {
     mojom::blink::HyphenationPtr service;
     Platform::current()->serviceRegistry()->connectToRemoteService(
         mojo::GetProxy(&service));
     return service;
 }
 
@@ skipping 26 matching lines @@
 bool HyphenationMinikin::openDictionary(const AtomicString& locale)
 {
     base::PlatformFile file = openDictionaryFile(locale);
     if (file == base::kInvalidPlatformFile)
         return false;
     if (!m_file.Initialize(base::File(file))) {
         DLOG(ERROR) << "mmap failed";
         return false;
     }
 
-    // TODO(kojii): Create dictionary from m_file when Minikin is ready.
+    m_hyphenator = wrapUnique(Hyphenator::loadBinary(m_file.data()));
 
     return true;
 }
 
+std::vector<uint8_t> HyphenationMinikin::hyphenate(const StringView& text) const
+{
+    std::vector<uint8_t> result;
+    if (text.is8Bit()) {
+        String text16Bit = text.toString();
+        text16Bit.ensure16Bit();
+        m_hyphenator->hyphenate(&result, text16Bit.characters16(), text16Bit.length());
+    } else {
+        m_hyphenator->hyphenate(&result, text.characters16(), text.length());
+    }
+    return result;
+}
+
 size_t HyphenationMinikin::lastHyphenLocation(const StringView& text, size_t beforeIndex) const
 {
-    // TODO(kojii): Call minikin using the dictionary when Minikin is ready.
+    if (text.length() < minimumPrefixLength + minimumSuffixLength)
+        return 0;
+
+    std::vector<uint8_t> result = hyphenate(text);
+    static_assert(minimumPrefixLength >= 1, "Change the 'if' above if this fails");
+    for (size_t i = text.length() - minimumSuffixLength - 1;
+        i >= minimumPrefixLength; i--) {
+        if (result[i])
+            return i;
+    }
     return 0;
 }
 
+Vector<size_t, 8> HyphenationMinikin::hyphenLocations(const StringView& text) const
+{
+    Vector<size_t, 8> hyphenLocations;
+    if (text.length() < minimumPrefixLength + minimumSuffixLength)
+        return hyphenLocations;
+
+    std::vector<uint8_t> result = hyphenate(text);
+    static_assert(minimumPrefixLength >= 1, "Change the 'if' above if this fails");
+    for (size_t i = text.length() - minimumSuffixLength - 1;
+        i >= minimumPrefixLength; i--) {
+        if (result[i])
+            hyphenLocations.append(i);
+    }
+    return hyphenLocations;
+}
+
+using LocaleMap = HashMap<AtomicString, AtomicString, CaseFoldingHash>;
+
+static LocaleMap createLocaleFallbackMap()
+{
+    // This data is from CLDR, compiled by AOSP.
+    // https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/text/Hyphenator.java
+    using LocaleFallback = const char*[2];
+    static LocaleFallback localeFallbackData[] = {
+        { "en-AS", "en-US" }, // English (American Samoa)
+        { "en-GU", "en-US" }, // English (Guam)
+        { "en-MH", "en-US" }, // English (Marshall Islands)
+        { "en-MP", "en-US" }, // English (Northern Mariana Islands)
+        { "en-PR", "en-US" }, // English (Puerto Rico)
+        { "en-UM", "en-US" }, // English (United States Minor Outlying Islands)
+        { "en-VI", "en-US" }, // English (Virgin Islands)
+        { "no", "nb" },
+        { "am", "und-Ethi" }, // Amharic
+        { "byn", "und-Ethi" }, // Blin
+        { "gez", "und-Ethi" }, // Geʻez
+        { "ti", "und-Ethi" }, // Tigrinya
+        { "wal", "und-Ethi" }, // Wolaytta
+    };
+    LocaleMap map;
+    for (const auto& it : localeFallbackData)
+        map.add(it[0], it[1]);
+    return map;
+}
+
 PassRefPtr<Hyphenation> Hyphenation::platformGetHyphenation(const AtomicString& locale)
 {
     RefPtr<HyphenationMinikin> hyphenation(adoptRef(new HyphenationMinikin));
-    if (!hyphenation->openDictionary(locale))
-        return nullptr;
-    return hyphenation.release();
+    if (hyphenation->openDictionary(locale.lowerASCII()))
+        return hyphenation.release();
+    hyphenation.clear();
+
+    DEFINE_STATIC_LOCAL(LocaleMap, localeFallback, (createLocaleFallbackMap()));
+    const auto& it = localeFallback.find(locale);
+    if (it != localeFallback.end())
+        return get(it->value);
+
+    return nullptr;
 }
 
 } // namespace blink