reflow comments in platform/{testing,text}

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

 /* ***** BEGIN LICENSE BLOCK *****
  *
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
@@ skipping 15 matching lines @@
 #include <fcntl.h>
 
 #include "platform/text/hyphenation/HyphenatorAOSP.h"
 
 using std::vector;
 
 namespace android {
 
 static const uint16_t CHAR_SOFT_HYPHEN = 0x00AD;
 
-// The following are structs that correspond to tables inside the hyb file format
+// The following are structs that correspond to tables inside the hyb file
+// format
 
 struct AlphabetTable0 {
   uint32_t version;
   uint32_t min_codepoint;
   uint32_t max_codepoint;
   uint8_t data[1];  // actually flexible array, size is known at runtime
 };
 
 struct AlphabetTable1 {
   uint32_t version;
@@ skipping 77 matching lines @@
     if (alphabetLookup(alpha_codes, word, len)) {
       hyphenateFromCodes(result->data(), alpha_codes, paddedLen);
       return;
     }
     // TODO: try NFC normalization
     // TODO: handle non-BMP Unicode (requires remapping of offsets)
   }
   hyphenateSoft(result->data(), word, len);
 }
 
-// If any soft hyphen is present in the word, use soft hyphens to decide hyphenation,
-// as recommended in UAX #14 (Use of Soft Hyphen)
+// If any soft hyphen is present in the word, use soft hyphens to decide
+// hyphenation, as recommended in UAX #14 (Use of Soft Hyphen)
 void Hyphenator::hyphenateSoft(uint8_t* result,
                                const uint16_t* word,
                                size_t len) {
   result[0] = 0;
   for (size_t i = 1; i < len; i++) {
     result[i] = word[i - 1] == CHAR_SOFT_HYPHEN;
   }
 }
 
 bool Hyphenator::alphabetLookup(uint16_t* alpha_codes,
@@ skipping 38 matching lines @@
       }
       alpha_codes[i + 1] = AlphabetTable1::value(entry);
     }
     alpha_codes[len + 1] = 0;
     return true;
   }
   return false;
 }
 
 /**
- * Internal implementation, after conversion to codes. All case folding and normalization
- * has been done by now, and all characters have been found in the alphabet.
- * Note: len here is the padded length including 0 codes at start and end.
+ * Internal implementation, after conversion to codes. All case folding and
+ * normalization has been done by now, and all characters have been found in the
+ * alphabet.  Note: len here is the padded length including 0 codes at start and
+ * end.
  **/
 void Hyphenator::hyphenateFromCodes(uint8_t* result,
                                     const uint16_t* codes,
                                     size_t len) {
   const Header* header = getHeader();
   const Trie* trie = header->trieTable();
   const Pattern* pattern = header->patternTable();
   uint32_t char_mask = trie->char_mask;
   uint32_t link_shift = trie->link_shift;
   uint32_t link_mask = trie->link_mask;
   uint32_t pattern_shift = trie->pattern_shift;
   size_t maxOffset = len - MIN_SUFFIX - 1;
   for (size_t i = 0; i < len - 1; i++) {
     uint32_t node = 0;  // index into Trie table
     for (size_t j = i; j < len; j++) {
       uint16_t c = codes[j];
       uint32_t entry = trie->data[node + c];
       if ((entry & char_mask) == c) {
         node = (entry & link_mask) >> link_shift;
       } else {
         break;
       }
       uint32_t pat_ix = trie->data[node] >> pattern_shift;
-      // pat_ix contains a 3-tuple of length, shift (number of trailing zeros), and an offset
-      // into the buf pool. This is the pattern for the substring (i..j) we just matched,
+      // pat_ix contains a 3-tuple of length, shift (number of trailing zeros),
+      // and an offset into the buf pool. This is the pattern for the substring
+      // (i..j) we just matched,
       // which we combine (via point-wise max) into the result vector.
       if (pat_ix != 0) {
         uint32_t pat_entry = pattern->data[pat_ix];
         int pat_len = Pattern::len(pat_entry);
         int pat_shift = Pattern::shift(pat_entry);
         const uint8_t* pat_buf = pattern->buf(pat_entry);
         int offset = j + 1 - (pat_len + pat_shift);
-        // offset is the index within result that lines up with the start of pat_buf
+        // offset is the index within result that lines up with the start of
+        // pat_buf
         int start = std::max(MIN_PREFIX - offset, 0);
         int end = std::min(pat_len, (int)maxOffset - offset);
         for (int k = start; k < end; k++) {
           result[offset + k] = std::max(result[offset + k], pat_buf[k]);
         }
       }
     }
   }
   // Since the above calculation does not modify values outside
   // [MIN_PREFIX, len - MIN_SUFFIX], they are left as 0.
   for (size_t i = MIN_PREFIX; i < maxOffset; i++) {
     result[i] &= 1;
   }
 }
 
 }  // namespace android