Merge 2987: Fix hyphenated words not to overflow on 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 "platform/text/hyphenation/HyphenationMinikin.h"
 
 #include "base/files/file.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/timer/elapsed_timer.h"
 #include "platform/LayoutLocale.h"
 #include "platform/text/hyphenation/HyphenatorAOSP.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.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::File 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()->interfaceProvider()->getInterface(
       mojo::MakeRequest(&service));
   return service;
 }
 
 static const mojom::blink::HyphenationPtr& getService() {
   DEFINE_STATIC_LOCAL(mojom::blink::HyphenationPtr, service,
                       (connectToRemoteService()));
   return service;
 }
 
-base::File HyphenationMinikin::openDictionaryFile(const AtomicString& locale) {
+bool HyphenationMinikin::openDictionary(const AtomicString& locale) {
   const mojom::blink::HyphenationPtr& service = getService();
   base::File file;
   base::ElapsedTimer timer;
   service->OpenDictionary(locale, &file);
   UMA_HISTOGRAM_TIMES("Hyphenation.Open", timer.Elapsed());
-  return file;
+
+  return openDictionary(std::move(file));
 }
 
-bool HyphenationMinikin::openDictionary(const AtomicString& locale) {
-  base::File file = openDictionaryFile(locale);
+bool HyphenationMinikin::openDictionary(base::File file) {
   if (!file.IsValid())
     return false;
   if (!m_file.Initialize(std::move(file))) {
     DLOG(ERROR) << "mmap failed";
     return false;
   }
 
   m_hyphenator = WTF::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 {
-  if (text.length() < minimumPrefixLength + minimumSuffixLength)
+  if (text.length() < minimumPrefixLength + minimumSuffixLength ||
+      beforeIndex <= minimumPrefixLength)
     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--) {
+  beforeIndex =
+      std::min<size_t>(beforeIndex, text.length() - minimumSuffixLength);
+  CHECK_LE(beforeIndex, result.size());
+  CHECK_GE(beforeIndex, 1u);
+  static_assert(minimumPrefixLength >= 1, "|beforeIndex - 1| can underflow");
+  for (size_t i = beforeIndex - 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)
@@ skipping 55 matching lines @@
   hyphenation.clear();
 
   DEFINE_STATIC_LOCAL(LocaleMap, localeFallback, (createLocaleFallbackMap()));
   const auto& it = localeFallback.find(locale);
   if (it != localeFallback.end())
     return LayoutLocale::get(it->value)->getHyphenation();
 
   return nullptr;
 }
 
+PassRefPtr<HyphenationMinikin> HyphenationMinikin::fromFileForTesting(
+    base::File file) {
+  RefPtr<HyphenationMinikin> hyphenation(adoptRef(new HyphenationMinikin));
+  if (hyphenation->openDictionary(std::move(file)))
+    return hyphenation.release();
+  return nullptr;
+}
+
 }  // namespace blink