Update (old) harfbuzz to ToT

third_party/harfbuzz/src/harfbuzz-shaper.cpp

 /*
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * This is part of HarfBuzz, an OpenType Layout engine library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
@@ skipping 165 matching lines @@
             lineBreakType = HB_ForcedBreak;
         } else if(cls == HB_LineBreak_CR) {
             lineBreakType = (ncls == HB_LineBreak_LF) ? HB_NoBreak : HB_ForcedBreak;
         }
 
         if (ncls == HB_LineBreak_SP)
             goto next_no_cls_update;
         if (ncls >= HB_LineBreak_CR)
             goto next;
 
-        // two complex chars (thai or lao), thai_attributes might override, but here we do a best guess
-        if (cls == HB_LineBreak_SA && ncls == HB_LineBreak_SA) {
-            lineBreakType = HB_Break;
-            goto next;
-        }
-
         {
             int tcls = ncls;
+            // for south east asian chars that require a complex (dictionary analysis), the unicode
+            // standard recommends to treat them as AL. thai_attributes and other attribute methods that
+            // do dictionary analysis can override
             if (tcls >= HB_LineBreak_SA)
-                tcls = HB_LineBreak_ID;
+                tcls = HB_LineBreak_AL;
             if (cls >= HB_LineBreak_SA)
-                cls = HB_LineBreak_ID;
+                cls = HB_LineBreak_AL;
 
             int brk = breakTable[cls][tcls];
             switch (brk) {
             case DirectBreak:
                 lineBreakType = HB_Break;
                 if (uc[i-1] == 0xad) // soft hyphen
                     lineBreakType = HB_SoftHyphen;
                 break;
             case IndirectBreak:
                 lineBreakType = (lcls == HB_LineBreak_SP) ? HB_Break : HB_NoBreak;
@@ skipping 371 matching lines @@
 #endif
 
     HB_HeuristicPosition(shaper_item);
     return true;
 }
 
 const HB_ScriptEngine HB_ScriptEngines[] = {
     // Common
     { HB_BasicShape, 0},
     // Greek
-    { HB_BasicShape, 0},
+    { HB_GreekShape, 0},
     // Cyrillic
     { HB_BasicShape, 0},
     // Armenian
     { HB_BasicShape, 0},
     // Hebrew
     { HB_HebrewShape, 0 },
     // Arabic
     { HB_ArabicShape, 0},
     // Syriac
     { HB_ArabicShape, 0},
@@ skipping 367 matching lines @@
     face->gpos = 0;
     face->gsub = 0;
     face->current_script = HB_ScriptCount;
     face->current_flags = HB_ShaperFlag_Default;
     face->has_opentype_kerning = false;
     face->tmpAttributes = 0;
     face->tmpLogClusters = 0;
     face->glyphs_substituted = false;
     face->buffer = 0;
 
-    HB_Error error;
+    HB_Error error = HB_Err_Ok;
     HB_Stream stream;
     HB_Stream gdefStream;
 
     gdefStream = getTableStream(font, tableFunc, TTAG_GDEF);
+    error = HB_Err_Not_Covered;
     if (!gdefStream || (error = HB_Load_GDEF_Table(gdefStream, &face->gdef))) {
         //DEBUG("error loading gdef table: %d", error);
         face->gdef = 0;
     }
 
     //DEBUG() << "trying to load gsub table";
     stream = getTableStream(font, tableFunc, TTAG_GSUB);
+    error = HB_Err_Not_Covered;
     if (!stream || (error = HB_Load_GSUB_Table(stream, &face->gsub, face->gdef, gdefStream))) {
         face->gsub = 0;
         if (error != HB_Err_Not_Covered) {
             //DEBUG("error loading gsub table: %d", error);
         } else {
             //DEBUG("face doesn't have a gsub table");
         }
     }
     _hb_close_stream(stream);
 
     stream = getTableStream(font, tableFunc, TTAG_GPOS);
+    error = HB_Err_Not_Covered;
     if (!stream || (error = HB_Load_GPOS_Table(stream, &face->gpos, face->gdef, gdefStream))) {
         face->gpos = 0;
         DEBUG("error loading gpos table: %d", error);
     }
     _hb_close_stream(stream);
 
     _hb_close_stream(gdefStream);
 
     for (unsigned int i = 0; i < HB_ScriptCount; ++i)
         face->supported_scripts[i] = checkScript(face, i);
@@ skipping 340 matching lines @@
     if (shaper_item->num_glyphs < shaper_item->item.length) {
         shaper_item->num_glyphs = shaper_item->item.length;
         return false;
     }
     assert(shaper_item->item.script < HB_ScriptCount);
     result = HB_ScriptEngines[shaper_item->item.script].shape(shaper_item);
     shaper_item->glyphIndicesPresent = false;
     return result;
 }