1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "ui/gfx/render_text_harfbuzz.h" 6 7 #include <limits> 8 #include <map> 9 10 #include "base/i18n/bidi_line_iterator.h" 11 #include "base/i18n/break_iterator.h" 12 #include "base/i18n/char_iterator.h" 13 #include "base/lazy_instance.h" 14 #include "third_party/harfbuzz-ng/src/hb.h" 15 #include "third_party/icu/source/common/unicode/ubidi.h" 16 #include "third_party/skia/include/core/SkColor.h" 17 #include "third_party/skia/include/core/SkTypeface.h" 18 #include "ui/gfx/canvas.h" 19 #include "ui/gfx/font_fallback.h" 20 #include "ui/gfx/font_render_params.h" 21 #include "ui/gfx/utf16_indexing.h" 22 23 #if defined(OS_WIN) 24 #include "ui/gfx/font_fallback_win.h" 25 #endif 26 27 namespace gfx { 28 29 namespace { 30 31 // Text length limit. Longer strings are slow and not fully tested. 32 const size_t kMaxTextLength = 10000; 33 34 // The maximum number of scripts a Unicode character can belong to. This value 35 // is arbitrarily chosen to be a good limit because it is unlikely for a single 36 // character to belong to more scripts. 37 const size_t kMaxScripts = 5; 38 39 // Maps from code points to glyph indices in a font. 40 typedef std::map<uint32_t, uint16_t> GlyphCache; 41 42 // Font data provider for HarfBuzz using Skia. Copied from Blink. 43 // TODO(ckocagil): Eliminate the duplication. http://crbug.com/368375 44 struct FontData { 45 FontData(GlyphCache* glyph_cache) : glyph_cache_(glyph_cache) {} 46 47 SkPaint paint_; 48 GlyphCache* glyph_cache_; 49 }; 50 51 hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value) { 52 return SkScalarToFixed(value); 53 } 54 55 // Deletes the object at the given pointer after casting it to the given type. 56 template<typename Type> 57 void DeleteByType(void* data) { 58 Type* typed_data = reinterpret_cast<Type*>(data); 59 delete typed_data; 60 } 61 62 template<typename Type> 63 void DeleteArrayByType(void* data) { 64 Type* typed_data = reinterpret_cast<Type*>(data); 65 delete[] typed_data; 66 } 67 68 // Outputs the |width| and |extents| of the glyph with index |codepoint| in 69 // |paint|'s font. 70 void GetGlyphWidthAndExtents(SkPaint* paint, 71 hb_codepoint_t codepoint, 72 hb_position_t* width, 73 hb_glyph_extents_t* extents) { 74 DCHECK_LE(codepoint, 0xFFFFU); 75 paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); 76 77 SkScalar sk_width; 78 SkRect sk_bounds; 79 uint16_t glyph = codepoint; 80 81 paint->getTextWidths(&glyph, sizeof(glyph), &sk_width, &sk_bounds); 82 if (width) 83 *width = SkiaScalarToHarfBuzzPosition(sk_width); 84 if (extents) { 85 // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be 86 // y-grows-up. 87 extents->x_bearing = SkiaScalarToHarfBuzzPosition(sk_bounds.fLeft); 88 extents->y_bearing = SkiaScalarToHarfBuzzPosition(-sk_bounds.fTop); 89 extents->width = SkiaScalarToHarfBuzzPosition(sk_bounds.width()); 90 extents->height = SkiaScalarToHarfBuzzPosition(-sk_bounds.height()); 91 } 92 } 93 94 // Writes the |glyph| index for the given |unicode| code point. Returns whether 95 // the glyph exists, i.e. it is not a missing glyph. 96 hb_bool_t GetGlyph(hb_font_t* font, 97 void* data, 98 hb_codepoint_t unicode, 99 hb_codepoint_t variation_selector, 100 hb_codepoint_t* glyph, 101 void* user_data) { 102 FontData* font_data = reinterpret_cast<FontData*>(data); 103 GlyphCache* cache = font_data->glyph_cache_; 104 105 bool exists = cache->count(unicode) != 0; 106 if (!exists) { 107 SkPaint* paint = &font_data->paint_; 108 paint->setTextEncoding(SkPaint::kUTF32_TextEncoding); 109 paint->textToGlyphs(&unicode, sizeof(hb_codepoint_t), &(*cache)[unicode]); 110 } 111 *glyph = (*cache)[unicode]; 112 return !!*glyph; 113 } 114 115 // Returns the horizontal advance value of the |glyph|. 116 hb_position_t GetGlyphHorizontalAdvance(hb_font_t* font, 117 void* data, 118 hb_codepoint_t glyph, 119 void* user_data) { 120 FontData* font_data = reinterpret_cast<FontData*>(data); 121 hb_position_t advance = 0; 122 123 GetGlyphWidthAndExtents(&font_data->paint_, glyph, &advance, 0); 124 return advance; 125 } 126 127 hb_bool_t GetGlyphHorizontalOrigin(hb_font_t* font, 128 void* data, 129 hb_codepoint_t glyph, 130 hb_position_t* x, 131 hb_position_t* y, 132 void* user_data) { 133 // Just return true, like the HarfBuzz-FreeType implementation. 134 return true; 135 } 136 137 hb_position_t GetGlyphKerning(FontData* font_data, 138 hb_codepoint_t first_glyph, 139 hb_codepoint_t second_glyph) { 140 SkTypeface* typeface = font_data->paint_.getTypeface(); 141 const uint16_t glyphs[2] = { static_cast<uint16_t>(first_glyph), 142 static_cast<uint16_t>(second_glyph) }; 143 int32_t kerning_adjustments[1] = { 0 }; 144 145 if (!typeface->getKerningPairAdjustments(glyphs, 2, kerning_adjustments)) 146 return 0; 147 148 SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm()); 149 SkScalar size = font_data->paint_.getTextSize(); 150 return SkiaScalarToHarfBuzzPosition( 151 SkScalarMulDiv(SkIntToScalar(kerning_adjustments[0]), size, upm)); 152 } 153 154 hb_position_t GetGlyphHorizontalKerning(hb_font_t* font, 155 void* data, 156 hb_codepoint_t left_glyph, 157 hb_codepoint_t right_glyph, 158 void* user_data) { 159 FontData* font_data = reinterpret_cast<FontData*>(data); 160 if (font_data->paint_.isVerticalText()) { 161 // We don't support cross-stream kerning. 162 return 0; 163 } 164 165 return GetGlyphKerning(font_data, left_glyph, right_glyph); 166 } 167 168 hb_position_t GetGlyphVerticalKerning(hb_font_t* font, 169 void* data, 170 hb_codepoint_t top_glyph, 171 hb_codepoint_t bottom_glyph, 172 void* user_data) { 173 FontData* font_data = reinterpret_cast<FontData*>(data); 174 if (!font_data->paint_.isVerticalText()) { 175 // We don't support cross-stream kerning. 176 return 0; 177 } 178 179 return GetGlyphKerning(font_data, top_glyph, bottom_glyph); 180 } 181 182 // Writes the |extents| of |glyph|. 183 hb_bool_t GetGlyphExtents(hb_font_t* font, 184 void* data, 185 hb_codepoint_t glyph, 186 hb_glyph_extents_t* extents, 187 void* user_data) { 188 FontData* font_data = reinterpret_cast<FontData*>(data); 189 190 GetGlyphWidthAndExtents(&font_data->paint_, glyph, 0, extents); 191 return true; 192 } 193 194 class FontFuncs { 195 public: 196 FontFuncs() : font_funcs_(hb_font_funcs_create()) { 197 hb_font_funcs_set_glyph_func(font_funcs_, GetGlyph, 0, 0); 198 hb_font_funcs_set_glyph_h_advance_func( 199 font_funcs_, GetGlyphHorizontalAdvance, 0, 0); 200 hb_font_funcs_set_glyph_h_kerning_func( 201 font_funcs_, GetGlyphHorizontalKerning, 0, 0); 202 hb_font_funcs_set_glyph_h_origin_func( 203 font_funcs_, GetGlyphHorizontalOrigin, 0, 0); 204 hb_font_funcs_set_glyph_v_kerning_func( 205 font_funcs_, GetGlyphVerticalKerning, 0, 0); 206 hb_font_funcs_set_glyph_extents_func( 207 font_funcs_, GetGlyphExtents, 0, 0); 208 hb_font_funcs_make_immutable(font_funcs_); 209 } 210 211 ~FontFuncs() { 212 hb_font_funcs_destroy(font_funcs_); 213 } 214 215 hb_font_funcs_t* get() { return font_funcs_; } 216 217 private: 218 hb_font_funcs_t* font_funcs_; 219 220 DISALLOW_COPY_AND_ASSIGN(FontFuncs); 221 }; 222 223 base::LazyInstance<FontFuncs>::Leaky g_font_funcs = LAZY_INSTANCE_INITIALIZER; 224 225 // Returns the raw data of the font table |tag|. 226 hb_blob_t* GetFontTable(hb_face_t* face, hb_tag_t tag, void* user_data) { 227 SkTypeface* typeface = reinterpret_cast<SkTypeface*>(user_data); 228 229 const size_t table_size = typeface->getTableSize(tag); 230 if (!table_size) 231 return 0; 232 233 scoped_ptr<char[]> buffer(new char[table_size]); 234 if (!buffer) 235 return 0; 236 size_t actual_size = typeface->getTableData(tag, 0, table_size, buffer.get()); 237 if (table_size != actual_size) 238 return 0; 239 240 char* buffer_raw = buffer.release(); 241 return hb_blob_create(buffer_raw, table_size, HB_MEMORY_MODE_WRITABLE, 242 buffer_raw, DeleteArrayByType<char>); 243 } 244 245 void UnrefSkTypeface(void* data) { 246 SkTypeface* skia_face = reinterpret_cast<SkTypeface*>(data); 247 SkSafeUnref(skia_face); 248 } 249 250 // Wrapper class for a HarfBuzz face created from a given Skia face. 251 class HarfBuzzFace { 252 public: 253 HarfBuzzFace() : face_(NULL) {} 254 255 ~HarfBuzzFace() { 256 if (face_) 257 hb_face_destroy(face_); 258 } 259 260 void Init(SkTypeface* skia_face) { 261 SkSafeRef(skia_face); 262 face_ = hb_face_create_for_tables(GetFontTable, skia_face, UnrefSkTypeface); 263 DCHECK(face_); 264 } 265 266 hb_face_t* get() { 267 return face_; 268 } 269 270 private: 271 hb_face_t* face_; 272 }; 273 274 // Creates a HarfBuzz font from the given Skia face and text size. 275 hb_font_t* CreateHarfBuzzFont(SkTypeface* skia_face, 276 int text_size, 277 const FontRenderParams& params, 278 bool background_is_transparent) { 279 typedef std::pair<HarfBuzzFace, GlyphCache> FaceCache; 280 281 // TODO(ckocagil): This shouldn't grow indefinitely. Maybe use base::MRUCache? 282 static std::map<SkFontID, FaceCache> face_caches; 283 284 FaceCache* face_cache = &face_caches[skia_face->uniqueID()]; 285 if (face_cache->first.get() == NULL) 286 face_cache->first.Init(skia_face); 287 288 hb_font_t* harfbuzz_font = hb_font_create(face_cache->first.get()); 289 const int scale = SkScalarToFixed(text_size); 290 hb_font_set_scale(harfbuzz_font, scale, scale); 291 FontData* hb_font_data = new FontData(&face_cache->second); 292 hb_font_data->paint_.setTypeface(skia_face); 293 hb_font_data->paint_.setTextSize(text_size); 294 // TODO(ckocagil): Do we need to update these params later? 295 internal::ApplyRenderParams(params, background_is_transparent, 296 &hb_font_data->paint_); 297 hb_font_set_funcs(harfbuzz_font, g_font_funcs.Get().get(), hb_font_data, 298 DeleteByType<FontData>); 299 hb_font_make_immutable(harfbuzz_font); 300 return harfbuzz_font; 301 } 302 303 // Returns true if characters of |block_code| may trigger font fallback. 304 bool IsUnusualBlockCode(UBlockCode block_code) { 305 return block_code == UBLOCK_GEOMETRIC_SHAPES || 306 block_code == UBLOCK_MISCELLANEOUS_SYMBOLS; 307 } 308 309 bool IsBracket(UChar32 character) { 310 static const char kBrackets[] = { '(', ')', '{', '}', '<', '>', }; 311 static const char* kBracketsEnd = kBrackets + arraysize(kBrackets); 312 return std::find(kBrackets, kBracketsEnd, character) != kBracketsEnd; 313 } 314 315 // Returns the boundary between a special and a regular character. Special 316 // characters are brackets or characters that satisfy |IsUnusualBlockCode|. 317 size_t FindRunBreakingCharacter(const base::string16& text, 318 size_t run_start, 319 size_t run_break) { 320 const int32 run_length = static_cast<int32>(run_break - run_start); 321 base::i18n::UTF16CharIterator iter(text.c_str() + run_start, run_length); 322 const UChar32 first_char = iter.get(); 323 const UBlockCode first_block = ublock_getCode(first_char); 324 const bool first_block_unusual = IsUnusualBlockCode(first_block); 325 const bool first_bracket = IsBracket(first_char); 326 327 while (iter.Advance() && iter.array_pos() < run_length) { 328 const UChar32 current_char = iter.get(); 329 const UBlockCode current_block = ublock_getCode(current_char); 330 const bool block_break = current_block != first_block && 331 (first_block_unusual || IsUnusualBlockCode(current_block)); 332 if (block_break || first_bracket != IsBracket(current_char)) 333 return run_start + iter.array_pos(); 334 } 335 return run_break; 336 } 337 338 // If the given scripts match, returns the one that isn't USCRIPT_COMMON or 339 // USCRIPT_INHERITED, i.e. the more specific one. Otherwise returns 340 // USCRIPT_INVALID_CODE. 341 UScriptCode ScriptIntersect(UScriptCode first, UScriptCode second) { 342 if (first == second || 343 (second > USCRIPT_INVALID_CODE && second <= USCRIPT_INHERITED)) { 344 return first; 345 } 346 if (first > USCRIPT_INVALID_CODE && first <= USCRIPT_INHERITED) 347 return second; 348 return USCRIPT_INVALID_CODE; 349 } 350 351 // Writes the script and the script extensions of the character with the 352 // Unicode |codepoint|. Returns the number of written scripts. 353 int GetScriptExtensions(UChar32 codepoint, UScriptCode* scripts) { 354 UErrorCode icu_error = U_ZERO_ERROR; 355 // ICU documentation incorrectly states that the result of 356 // |uscript_getScriptExtensions| will contain the regular script property. 357 // Write the character's script property to the first element. 358 scripts[0] = uscript_getScript(codepoint, &icu_error); 359 if (U_FAILURE(icu_error)) 360 return 0; 361 // Fill the rest of |scripts| with the extensions. 362 int count = uscript_getScriptExtensions(codepoint, scripts + 1, 363 kMaxScripts - 1, &icu_error); 364 if (U_FAILURE(icu_error)) 365 count = 0; 366 return count + 1; 367 } 368 369 // Intersects the script extensions set of |codepoint| with |result| and writes 370 // to |result|, reading and updating |result_size|. 371 void ScriptSetIntersect(UChar32 codepoint, 372 UScriptCode* result, 373 size_t* result_size) { 374 UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE }; 375 int count = GetScriptExtensions(codepoint, scripts); 376 377 size_t out_size = 0; 378 379 for (size_t i = 0; i < *result_size; ++i) { 380 for (int j = 0; j < count; ++j) { 381 UScriptCode intersection = ScriptIntersect(result[i], scripts[j]); 382 if (intersection != USCRIPT_INVALID_CODE) { 383 result[out_size++] = intersection; 384 break; 385 } 386 } 387 } 388 389 *result_size = out_size; 390 } 391 392 // Find the longest sequence of characters from 0 and up to |length| that 393 // have at least one common UScriptCode value. Writes the common script value to 394 // |script| and returns the length of the sequence. Takes the characters' script 395 // extensions into account. http://www.unicode.org/reports/tr24/#ScriptX 396 // 397 // Consider 3 characters with the script values {Kana}, {Hira, Kana}, {Kana}. 398 // Without script extensions only the first script in each set would be taken 399 // into account, resulting in 3 runs where 1 would be enough. 400 // TODO(ckocagil): Write a unit test for the case above. 401 int ScriptInterval(const base::string16& text, 402 size_t start, 403 size_t length, 404 UScriptCode* script) { 405 DCHECK_GT(length, 0U); 406 407 UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE }; 408 409 base::i18n::UTF16CharIterator char_iterator(text.c_str() + start, length); 410 size_t scripts_size = GetScriptExtensions(char_iterator.get(), scripts); 411 *script = scripts[0]; 412 413 while (char_iterator.Advance()) { 414 ScriptSetIntersect(char_iterator.get(), scripts, &scripts_size); 415 if (scripts_size == 0U) 416 return char_iterator.array_pos(); 417 *script = scripts[0]; 418 } 419 420 return length; 421 } 422 423 // A port of hb_icu_script_to_script because harfbuzz on CrOS is built without 424 // hb-icu. See http://crbug.com/356929 425 inline hb_script_t ICUScriptToHBScript(UScriptCode script) { 426 if (script == USCRIPT_INVALID_CODE) 427 return HB_SCRIPT_INVALID; 428 return hb_script_from_string(uscript_getShortName(script), -1); 429 } 430 431 // Helper template function for |TextRunHarfBuzz::GetClusterAt()|. |Iterator| 432 // can be a forward or reverse iterator type depending on the text direction. 433 template <class Iterator> 434 void GetClusterAtImpl(size_t pos, 435 Range range, 436 Iterator elements_begin, 437 Iterator elements_end, 438 bool reversed, 439 Range* chars, 440 Range* glyphs) { 441 Iterator element = std::upper_bound(elements_begin, elements_end, pos); 442 chars->set_end(element == elements_end ? range.end() : *element); 443 glyphs->set_end(reversed ? elements_end - element : element - elements_begin); 444 445 DCHECK(element != elements_begin); 446 while (--element != elements_begin && *element == *(element - 1)); 447 chars->set_start(*element); 448 glyphs->set_start( 449 reversed ? elements_end - element : element - elements_begin); 450 if (reversed) 451 *glyphs = Range(glyphs->end(), glyphs->start()); 452 453 DCHECK(!chars->is_reversed()); 454 DCHECK(!chars->is_empty()); 455 DCHECK(!glyphs->is_reversed()); 456 DCHECK(!glyphs->is_empty()); 457 } 458 459 } // namespace 460 461 namespace internal { 462 463 TextRunHarfBuzz::TextRunHarfBuzz() 464 : width(0.0f), 465 preceding_run_widths(0.0f), 466 is_rtl(false), 467 level(0), 468 script(USCRIPT_INVALID_CODE), 469 glyph_count(static_cast<size_t>(-1)), 470 font_size(0), 471 font_style(0), 472 strike(false), 473 diagonal_strike(false), 474 underline(false) {} 475 476 TextRunHarfBuzz::~TextRunHarfBuzz() {} 477 478 void TextRunHarfBuzz::GetClusterAt(size_t pos, 479 Range* chars, 480 Range* glyphs) const { 481 DCHECK(range.Contains(Range(pos, pos + 1))); 482 DCHECK(chars); 483 DCHECK(glyphs); 484 485 if (glyph_count == 0) { 486 *chars = range; 487 *glyphs = Range(); 488 return; 489 } 490 491 if (is_rtl) { 492 GetClusterAtImpl(pos, range, glyph_to_char.rbegin(), glyph_to_char.rend(), 493 true, chars, glyphs); 494 return; 495 } 496 497 GetClusterAtImpl(pos, range, glyph_to_char.begin(), glyph_to_char.end(), 498 false, chars, glyphs); 499 } 500 501 Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const { 502 DCHECK(range.Contains(char_range)); 503 DCHECK(!char_range.is_reversed()); 504 DCHECK(!char_range.is_empty()); 505 506 Range start_glyphs; 507 Range end_glyphs; 508 Range temp_range; 509 GetClusterAt(char_range.start(), &temp_range, &start_glyphs); 510 GetClusterAt(char_range.end() - 1, &temp_range, &end_glyphs); 511 512 return is_rtl ? Range(end_glyphs.start(), start_glyphs.end()) : 513 Range(start_glyphs.start(), end_glyphs.end()); 514 } 515 516 size_t TextRunHarfBuzz::CountMissingGlyphs() const { 517 static const int kMissingGlyphId = 0; 518 size_t missing = 0; 519 for (size_t i = 0; i < glyph_count; ++i) 520 missing += (glyphs[i] == kMissingGlyphId) ? 1 : 0; 521 return missing; 522 } 523 524 Range TextRunHarfBuzz::GetGraphemeBounds( 525 base::i18n::BreakIterator* grapheme_iterator, 526 size_t text_index) { 527 DCHECK_LT(text_index, range.end()); 528 // TODO(msw): Support floating point grapheme bounds. 529 const int preceding_run_widths_int = SkScalarRoundToInt(preceding_run_widths); 530 if (glyph_count == 0) 531 return Range(preceding_run_widths_int, preceding_run_widths_int + width); 532 533 Range chars; 534 Range glyphs; 535 GetClusterAt(text_index, &chars, &glyphs); 536 const int cluster_begin_x = SkScalarRoundToInt(positions[glyphs.start()].x()); 537 const int cluster_end_x = glyphs.end() < glyph_count ? 538 SkScalarRoundToInt(positions[glyphs.end()].x()) : width; 539 540 // A cluster consists of a number of code points and corresponds to a number 541 // of glyphs that should be drawn together. A cluster can contain multiple 542 // graphemes. In order to place the cursor at a grapheme boundary inside the 543 // cluster, we simply divide the cluster width by the number of graphemes. 544 if (chars.length() > 1 && grapheme_iterator) { 545 int before = 0; 546 int total = 0; 547 for (size_t i = chars.start(); i < chars.end(); ++i) { 548 if (grapheme_iterator->IsGraphemeBoundary(i)) { 549 if (i < text_index) 550 ++before; 551 ++total; 552 } 553 } 554 DCHECK_GT(total, 0); 555 if (total > 1) { 556 if (is_rtl) 557 before = total - before - 1; 558 DCHECK_GE(before, 0); 559 DCHECK_LT(before, total); 560 const int cluster_width = cluster_end_x - cluster_begin_x; 561 const int grapheme_begin_x = cluster_begin_x + static_cast<int>(0.5f + 562 cluster_width * before / static_cast<float>(total)); 563 const int grapheme_end_x = cluster_begin_x + static_cast<int>(0.5f + 564 cluster_width * (before + 1) / static_cast<float>(total)); 565 return Range(preceding_run_widths_int + grapheme_begin_x, 566 preceding_run_widths_int + grapheme_end_x); 567 } 568 } 569 570 return Range(preceding_run_widths_int + cluster_begin_x, 571 preceding_run_widths_int + cluster_end_x); 572 } 573 574 } // namespace internal 575 576 RenderTextHarfBuzz::RenderTextHarfBuzz() 577 : RenderText(), 578 needs_layout_(false) { 579 set_truncate_length(kMaxTextLength); 580 } 581 582 RenderTextHarfBuzz::~RenderTextHarfBuzz() {} 583 584 Size RenderTextHarfBuzz::GetStringSize() { 585 const SizeF size_f = GetStringSizeF(); 586 return Size(std::ceil(size_f.width()), size_f.height()); 587 } 588 589 SizeF RenderTextHarfBuzz::GetStringSizeF() { 590 EnsureLayout(); 591 return lines()[0].size; 592 } 593 594 SelectionModel RenderTextHarfBuzz::FindCursorPosition(const Point& point) { 595 EnsureLayout(); 596 597 int x = ToTextPoint(point).x(); 598 int offset = 0; 599 size_t run_index = GetRunContainingXCoord(x, &offset); 600 if (run_index >= runs_.size()) 601 return EdgeSelectionModel((x < 0) ? CURSOR_LEFT : CURSOR_RIGHT); 602 const internal::TextRunHarfBuzz& run = *runs_[run_index]; 603 604 for (size_t i = 0; i < run.glyph_count; ++i) { 605 const SkScalar end = 606 i + 1 == run.glyph_count ? run.width : run.positions[i + 1].x(); 607 const SkScalar middle = (end + run.positions[i].x()) / 2; 608 609 if (offset < middle) { 610 return SelectionModel(LayoutIndexToTextIndex( 611 run.glyph_to_char[i] + (run.is_rtl ? 1 : 0)), 612 (run.is_rtl ? CURSOR_BACKWARD : CURSOR_FORWARD)); 613 } 614 if (offset < end) { 615 return SelectionModel(LayoutIndexToTextIndex( 616 run.glyph_to_char[i] + (run.is_rtl ? 0 : 1)), 617 (run.is_rtl ? CURSOR_FORWARD : CURSOR_BACKWARD)); 618 } 619 } 620 return EdgeSelectionModel(CURSOR_RIGHT); 621 } 622 623 std::vector<RenderText::FontSpan> RenderTextHarfBuzz::GetFontSpansForTesting() { 624 EnsureLayout(); 625 626 std::vector<RenderText::FontSpan> spans; 627 for (size_t i = 0; i < runs_.size(); ++i) { 628 SkString family_name; 629 runs_[i]->skia_face->getFamilyName(&family_name); 630 Font font(family_name.c_str(), runs_[i]->font_size); 631 spans.push_back(RenderText::FontSpan(font, 632 Range(LayoutIndexToTextIndex(runs_[i]->range.start()), 633 LayoutIndexToTextIndex(runs_[i]->range.end())))); 634 } 635 636 return spans; 637 } 638 639 Range RenderTextHarfBuzz::GetGlyphBounds(size_t index) { 640 EnsureLayout(); 641 const size_t run_index = 642 GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD)); 643 // Return edge bounds if the index is invalid or beyond the layout text size. 644 if (run_index >= runs_.size()) 645 return Range(GetStringSize().width()); 646 const size_t layout_index = TextIndexToLayoutIndex(index); 647 internal::TextRunHarfBuzz* run = runs_[run_index]; 648 Range bounds = run->GetGraphemeBounds(grapheme_iterator_.get(), layout_index); 649 return run->is_rtl ? Range(bounds.end(), bounds.start()) : bounds; 650 } 651 652 int RenderTextHarfBuzz::GetLayoutTextBaseline() { 653 EnsureLayout(); 654 return lines()[0].baseline; 655 } 656 657 SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel( 658 const SelectionModel& selection, 659 VisualCursorDirection direction) { 660 DCHECK(!needs_layout_); 661 internal::TextRunHarfBuzz* run; 662 size_t run_index = GetRunContainingCaret(selection); 663 if (run_index >= runs_.size()) { 664 // The cursor is not in any run: we're at the visual and logical edge. 665 SelectionModel edge = EdgeSelectionModel(direction); 666 if (edge.caret_pos() == selection.caret_pos()) 667 return edge; 668 int visual_index = (direction == CURSOR_RIGHT) ? 0 : runs_.size() - 1; 669 run = runs_[visual_to_logical_[visual_index]]; 670 } else { 671 // If the cursor is moving within the current run, just move it by one 672 // grapheme in the appropriate direction. 673 run = runs_[run_index]; 674 size_t caret = selection.caret_pos(); 675 bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT); 676 if (forward_motion) { 677 if (caret < LayoutIndexToTextIndex(run->range.end())) { 678 caret = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD); 679 return SelectionModel(caret, CURSOR_BACKWARD); 680 } 681 } else { 682 if (caret > LayoutIndexToTextIndex(run->range.start())) { 683 caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD); 684 return SelectionModel(caret, CURSOR_FORWARD); 685 } 686 } 687 // The cursor is at the edge of a run; move to the visually adjacent run. 688 int visual_index = logical_to_visual_[run_index]; 689 visual_index += (direction == CURSOR_LEFT) ? -1 : 1; 690 if (visual_index < 0 || visual_index >= static_cast<int>(runs_.size())) 691 return EdgeSelectionModel(direction); 692 run = runs_[visual_to_logical_[visual_index]]; 693 } 694 bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT); 695 return forward_motion ? FirstSelectionModelInsideRun(run) : 696 LastSelectionModelInsideRun(run); 697 } 698 699 SelectionModel RenderTextHarfBuzz::AdjacentWordSelectionModel( 700 const SelectionModel& selection, 701 VisualCursorDirection direction) { 702 if (obscured()) 703 return EdgeSelectionModel(direction); 704 705 base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD); 706 bool success = iter.Init(); 707 DCHECK(success); 708 if (!success) 709 return selection; 710 711 // Match OS specific word break behavior. 712 #if defined(OS_WIN) 713 size_t pos; 714 if (direction == CURSOR_RIGHT) { 715 pos = std::min(selection.caret_pos() + 1, text().length()); 716 while (iter.Advance()) { 717 pos = iter.pos(); 718 if (iter.IsWord() && pos > selection.caret_pos()) 719 break; 720 } 721 } else { // direction == CURSOR_LEFT 722 // Notes: We always iterate words from the beginning. 723 // This is probably fast enough for our usage, but we may 724 // want to modify WordIterator so that it can start from the 725 // middle of string and advance backwards. 726 pos = std::max<int>(selection.caret_pos() - 1, 0); 727 while (iter.Advance()) { 728 if (iter.IsWord()) { 729 size_t begin = iter.pos() - iter.GetString().length(); 730 if (begin == selection.caret_pos()) { 731 // The cursor is at the beginning of a word. 732 // Move to previous word. 733 break; 734 } else if (iter.pos() >= selection.caret_pos()) { 735 // The cursor is in the middle or at the end of a word. 736 // Move to the top of current word. 737 pos = begin; 738 break; 739 } 740 pos = iter.pos() - iter.GetString().length(); 741 } 742 } 743 } 744 return SelectionModel(pos, CURSOR_FORWARD); 745 #else 746 SelectionModel cur(selection); 747 for (;;) { 748 cur = AdjacentCharSelectionModel(cur, direction); 749 size_t run = GetRunContainingCaret(cur); 750 if (run == runs_.size()) 751 break; 752 const bool is_forward = runs_[run]->is_rtl == (direction == CURSOR_LEFT); 753 size_t cursor = cur.caret_pos(); 754 if (is_forward ? iter.IsEndOfWord(cursor) : iter.IsStartOfWord(cursor)) 755 break; 756 } 757 return cur; 758 #endif 759 } 760 761 std::vector<Rect> RenderTextHarfBuzz::GetSubstringBounds(const Range& range) { 762 DCHECK(!needs_layout_); 763 DCHECK(Range(0, text().length()).Contains(range)); 764 Range layout_range(TextIndexToLayoutIndex(range.start()), 765 TextIndexToLayoutIndex(range.end())); 766 DCHECK(Range(0, GetLayoutText().length()).Contains(layout_range)); 767 768 std::vector<Rect> rects; 769 if (layout_range.is_empty()) 770 return rects; 771 std::vector<Range> bounds; 772 773 // Add a Range for each run/selection intersection. 774 for (size_t i = 0; i < runs_.size(); ++i) { 775 internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]]; 776 Range intersection = run->range.Intersect(layout_range); 777 if (!intersection.IsValid()) 778 continue; 779 DCHECK(!intersection.is_reversed()); 780 const Range leftmost_character_x = run->GetGraphemeBounds( 781 grapheme_iterator_.get(), 782 run->is_rtl ? intersection.end() - 1 : intersection.start()); 783 const Range rightmost_character_x = run->GetGraphemeBounds( 784 grapheme_iterator_.get(), 785 run->is_rtl ? intersection.start() : intersection.end() - 1); 786 Range range_x(leftmost_character_x.start(), rightmost_character_x.end()); 787 DCHECK(!range_x.is_reversed()); 788 if (range_x.is_empty()) 789 continue; 790 791 // Union this with the last range if they're adjacent. 792 DCHECK(bounds.empty() || bounds.back().GetMax() <= range_x.GetMin()); 793 if (!bounds.empty() && bounds.back().GetMax() == range_x.GetMin()) { 794 range_x = Range(bounds.back().GetMin(), range_x.GetMax()); 795 bounds.pop_back(); 796 } 797 bounds.push_back(range_x); 798 } 799 for (size_t i = 0; i < bounds.size(); ++i) { 800 std::vector<Rect> current_rects = TextBoundsToViewBounds(bounds[i]); 801 rects.insert(rects.end(), current_rects.begin(), current_rects.end()); 802 } 803 return rects; 804 } 805 806 size_t RenderTextHarfBuzz::TextIndexToLayoutIndex(size_t index) const { 807 DCHECK_LE(index, text().length()); 808 ptrdiff_t i = obscured() ? UTF16IndexToOffset(text(), 0, index) : index; 809 CHECK_GE(i, 0); 810 // Clamp layout indices to the length of the text actually used for layout. 811 return std::min<size_t>(GetLayoutText().length(), i); 812 } 813 814 size_t RenderTextHarfBuzz::LayoutIndexToTextIndex(size_t index) const { 815 if (!obscured()) 816 return index; 817 818 DCHECK_LE(index, GetLayoutText().length()); 819 const size_t text_index = UTF16OffsetToIndex(text(), 0, index); 820 DCHECK_LE(text_index, text().length()); 821 return text_index; 822 } 823 824 bool RenderTextHarfBuzz::IsValidCursorIndex(size_t index) { 825 if (index == 0 || index == text().length()) 826 return true; 827 if (!IsValidLogicalIndex(index)) 828 return false; 829 EnsureLayout(); 830 return !grapheme_iterator_ || grapheme_iterator_->IsGraphemeBoundary(index); 831 } 832 833 void RenderTextHarfBuzz::ResetLayout() { 834 needs_layout_ = true; 835 } 836 837 void RenderTextHarfBuzz::EnsureLayout() { 838 if (needs_layout_) { 839 runs_.clear(); 840 grapheme_iterator_.reset(); 841 842 if (!GetLayoutText().empty()) { 843 grapheme_iterator_.reset(new base::i18n::BreakIterator(GetLayoutText(), 844 base::i18n::BreakIterator::BREAK_CHARACTER)); 845 if (!grapheme_iterator_->Init()) 846 grapheme_iterator_.reset(); 847 848 ItemizeText(); 849 850 for (size_t i = 0; i < runs_.size(); ++i) 851 ShapeRun(runs_[i]); 852 853 // Precalculate run width information. 854 float preceding_run_widths = 0.0f; 855 for (size_t i = 0; i < runs_.size(); ++i) { 856 internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]]; 857 run->preceding_run_widths = preceding_run_widths; 858 preceding_run_widths += run->width; 859 } 860 } 861 862 needs_layout_ = false; 863 std::vector<internal::Line> empty_lines; 864 set_lines(&empty_lines); 865 } 866 867 if (lines().empty()) { 868 std::vector<internal::Line> lines; 869 lines.push_back(internal::Line()); 870 lines[0].baseline = font_list().GetBaseline(); 871 lines[0].size.set_height(font_list().GetHeight()); 872 873 int current_x = 0; 874 SkPaint paint; 875 876 for (size_t i = 0; i < runs_.size(); ++i) { 877 const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]]; 878 internal::LineSegment segment; 879 segment.x_range = Range(current_x, current_x + run.width); 880 segment.char_range = run.range; 881 segment.run = i; 882 lines[0].segments.push_back(segment); 883 884 paint.setTypeface(run.skia_face.get()); 885 paint.setTextSize(run.font_size); 886 SkPaint::FontMetrics metrics; 887 paint.getFontMetrics(&metrics); 888 889 lines[0].size.set_width(lines[0].size.width() + run.width); 890 lines[0].size.set_height(std::max(lines[0].size.height(), 891 metrics.fDescent - metrics.fAscent)); 892 lines[0].baseline = std::max(lines[0].baseline, 893 SkScalarRoundToInt(-metrics.fAscent)); 894 } 895 896 set_lines(&lines); 897 } 898 } 899 900 void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) { 901 DCHECK(!needs_layout_); 902 internal::SkiaTextRenderer renderer(canvas); 903 ApplyFadeEffects(&renderer); 904 ApplyTextShadows(&renderer); 905 ApplyCompositionAndSelectionStyles(); 906 907 int current_x = 0; 908 const Vector2d line_offset = GetLineOffset(0); 909 for (size_t i = 0; i < runs_.size(); ++i) { 910 const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]]; 911 renderer.SetTypeface(run.skia_face.get()); 912 renderer.SetTextSize(run.font_size); 913 renderer.SetFontRenderParams(run.render_params, 914 background_is_transparent()); 915 916 Vector2d origin = line_offset + Vector2d(current_x, lines()[0].baseline); 917 scoped_ptr<SkPoint[]> positions(new SkPoint[run.glyph_count]); 918 for (size_t j = 0; j < run.glyph_count; ++j) { 919 positions[j] = run.positions[j]; 920 positions[j].offset(SkIntToScalar(origin.x()), SkIntToScalar(origin.y())); 921 } 922 923 for (BreakList<SkColor>::const_iterator it = 924 colors().GetBreak(run.range.start()); 925 it != colors().breaks().end() && it->first < run.range.end(); 926 ++it) { 927 const Range intersection = colors().GetRange(it).Intersect(run.range); 928 const Range colored_glyphs = run.CharRangeToGlyphRange(intersection); 929 // The range may be empty if a portion of a multi-character grapheme is 930 // selected, yielding two colors for a single glyph. For now, this just 931 // paints the glyph with a single style, but it should paint it twice, 932 // clipped according to selection bounds. See http://crbug.com/366786 933 if (colored_glyphs.is_empty()) 934 continue; 935 936 renderer.SetForegroundColor(it->second); 937 renderer.DrawPosText(&positions[colored_glyphs.start()], 938 &run.glyphs[colored_glyphs.start()], 939 colored_glyphs.length()); 940 int width = (colored_glyphs.end() == run.glyph_count ? run.width : 941 run.positions[colored_glyphs.end()].x()) - 942 run.positions[colored_glyphs.start()].x(); 943 renderer.DrawDecorations(origin.x(), origin.y(), width, run.underline, 944 run.strike, run.diagonal_strike); 945 } 946 947 current_x += run.width; 948 } 949 950 renderer.EndDiagonalStrike(); 951 952 UndoCompositionAndSelectionStyles(); 953 } 954 955 size_t RenderTextHarfBuzz::GetRunContainingCaret( 956 const SelectionModel& caret) const { 957 DCHECK(!needs_layout_); 958 size_t layout_position = TextIndexToLayoutIndex(caret.caret_pos()); 959 LogicalCursorDirection affinity = caret.caret_affinity(); 960 for (size_t run = 0; run < runs_.size(); ++run) { 961 if (RangeContainsCaret(runs_[run]->range, layout_position, affinity)) 962 return run; 963 } 964 return runs_.size(); 965 } 966 967 size_t RenderTextHarfBuzz::GetRunContainingXCoord(int x, int* offset) const { 968 DCHECK(!needs_layout_); 969 if (x < 0) 970 return runs_.size(); 971 // Find the text run containing the argument point (assumed already offset). 972 int current_x = 0; 973 for (size_t i = 0; i < runs_.size(); ++i) { 974 size_t run = visual_to_logical_[i]; 975 current_x += runs_[run]->width; 976 if (x < current_x) { 977 *offset = x - (current_x - runs_[run]->width); 978 return run; 979 } 980 } 981 return runs_.size(); 982 } 983 984 SelectionModel RenderTextHarfBuzz::FirstSelectionModelInsideRun( 985 const internal::TextRunHarfBuzz* run) { 986 size_t position = LayoutIndexToTextIndex(run->range.start()); 987 position = IndexOfAdjacentGrapheme(position, CURSOR_FORWARD); 988 return SelectionModel(position, CURSOR_BACKWARD); 989 } 990 991 SelectionModel RenderTextHarfBuzz::LastSelectionModelInsideRun( 992 const internal::TextRunHarfBuzz* run) { 993 size_t position = LayoutIndexToTextIndex(run->range.end()); 994 position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD); 995 return SelectionModel(position, CURSOR_FORWARD); 996 } 997 998 void RenderTextHarfBuzz::ItemizeText() { 999 const base::string16& text = GetLayoutText(); 1000 const bool is_text_rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT; 1001 DCHECK_NE(0U, text.length()); 1002 1003 // If ICU fails to itemize the text, we create a run that spans the entire 1004 // text. This is needed because leaving the runs set empty causes some clients 1005 // to misbehave since they expect non-zero text metrics from a non-empty text. 1006 base::i18n::BiDiLineIterator bidi_iterator; 1007 if (!bidi_iterator.Open(text, is_text_rtl, false)) { 1008 internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz; 1009 run->range = Range(0, text.length()); 1010 runs_.push_back(run); 1011 visual_to_logical_ = logical_to_visual_ = std::vector<int32_t>(1, 0); 1012 return; 1013 } 1014 1015 // Temporarily apply composition underlines and selection colors. 1016 ApplyCompositionAndSelectionStyles(); 1017 1018 // Build the list of runs from the script items and ranged styles. Use an 1019 // empty color BreakList to avoid breaking runs at color boundaries. 1020 BreakList<SkColor> empty_colors; 1021 empty_colors.SetMax(text.length()); 1022 internal::StyleIterator style(empty_colors, styles()); 1023 1024 for (size_t run_break = 0; run_break < text.length();) { 1025 internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz; 1026 run->range.set_start(run_break); 1027 run->font_style = (style.style(BOLD) ? Font::BOLD : 0) | 1028 (style.style(ITALIC) ? Font::ITALIC : 0); 1029 run->strike = style.style(STRIKE); 1030 run->diagonal_strike = style.style(DIAGONAL_STRIKE); 1031 run->underline = style.style(UNDERLINE); 1032 1033 int32 script_item_break = 0; 1034 bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level); 1035 // Odd BiDi embedding levels correspond to RTL runs. 1036 run->is_rtl = (run->level % 2) == 1; 1037 // Find the length and script of this script run. 1038 script_item_break = ScriptInterval(text, run_break, 1039 script_item_break - run_break, &run->script) + run_break; 1040 1041 // Find the next break and advance the iterators as needed. 1042 run_break = std::min(static_cast<size_t>(script_item_break), 1043 TextIndexToLayoutIndex(style.GetRange().end())); 1044 1045 // Break runs at certain characters that need to be rendered separately to 1046 // prevent either an unusual character from forcing a fallback font on the 1047 // entire run, or brackets from being affected by a fallback font. 1048 // http://crbug.com/278913, http://crbug.com/396776 1049 if (run_break > run->range.start()) 1050 run_break = FindRunBreakingCharacter(text, run->range.start(), run_break); 1051 1052 DCHECK(IsValidCodePointIndex(text, run_break)); 1053 style.UpdatePosition(LayoutIndexToTextIndex(run_break)); 1054 run->range.set_end(run_break); 1055 1056 runs_.push_back(run); 1057 } 1058 1059 // Undo the temporarily applied composition underlines and selection colors. 1060 UndoCompositionAndSelectionStyles(); 1061 1062 const size_t num_runs = runs_.size(); 1063 std::vector<UBiDiLevel> levels(num_runs); 1064 for (size_t i = 0; i < num_runs; ++i) 1065 levels[i] = runs_[i]->level; 1066 visual_to_logical_.resize(num_runs); 1067 ubidi_reorderVisual(&levels[0], num_runs, &visual_to_logical_[0]); 1068 logical_to_visual_.resize(num_runs); 1069 ubidi_reorderLogical(&levels[0], num_runs, &logical_to_visual_[0]); 1070 } 1071 1072 void RenderTextHarfBuzz::ShapeRun(internal::TextRunHarfBuzz* run) { 1073 const Font& primary_font = font_list().GetPrimaryFont(); 1074 const std::string primary_font_name = primary_font.GetFontName(); 1075 run->font_size = primary_font.GetFontSize(); 1076 1077 size_t best_font_missing = std::numeric_limits<size_t>::max(); 1078 std::string best_font; 1079 std::string current_font; 1080 1081 // Try shaping with |primary_font|. 1082 if (ShapeRunWithFont(run, primary_font_name)) { 1083 current_font = primary_font_name; 1084 size_t current_missing = run->CountMissingGlyphs(); 1085 if (current_missing == 0) 1086 return; 1087 if (current_missing < best_font_missing) { 1088 best_font_missing = current_missing; 1089 best_font = current_font; 1090 } 1091 } 1092 1093 #if defined(OS_WIN) 1094 Font uniscribe_font; 1095 const base::char16* run_text = &(GetLayoutText()[run->range.start()]); 1096 if (GetUniscribeFallbackFont(primary_font, run_text, run->range.length(), 1097 &uniscribe_font) && 1098 ShapeRunWithFont(run, uniscribe_font.GetFontName())) { 1099 current_font = uniscribe_font.GetFontName(); 1100 size_t current_missing = run->CountMissingGlyphs(); 1101 if (current_missing == 0) 1102 return; 1103 if (current_missing < best_font_missing) { 1104 best_font_missing = current_missing; 1105 best_font = current_font; 1106 } 1107 } 1108 #endif 1109 1110 // Try shaping with the fonts in the fallback list except the first, which is 1111 // |primary_font|. 1112 std::vector<std::string> fonts = GetFallbackFontFamilies(primary_font_name); 1113 for (size_t i = 1; i < fonts.size(); ++i) { 1114 if (!ShapeRunWithFont(run, fonts[i])) 1115 continue; 1116 current_font = fonts[i]; 1117 size_t current_missing = run->CountMissingGlyphs(); 1118 if (current_missing == 0) 1119 return; 1120 if (current_missing < best_font_missing) { 1121 best_font_missing = current_missing; 1122 best_font = current_font; 1123 } 1124 } 1125 1126 if (!best_font.empty() && 1127 (best_font == current_font || ShapeRunWithFont(run, best_font))) { 1128 return; 1129 } 1130 1131 run->glyph_count = 0; 1132 run->width = 0.0f; 1133 } 1134 1135 bool RenderTextHarfBuzz::ShapeRunWithFont(internal::TextRunHarfBuzz* run, 1136 const std::string& font_family) { 1137 const base::string16& text = GetLayoutText(); 1138 skia::RefPtr<SkTypeface> skia_face = 1139 internal::CreateSkiaTypeface(font_family, run->font_style); 1140 if (skia_face == NULL) 1141 return false; 1142 run->skia_face = skia_face; 1143 FontRenderParamsQuery query(false); 1144 query.families.push_back(font_family); 1145 query.pixel_size = run->font_size; 1146 query.style = run->font_style; 1147 run->render_params = GetFontRenderParams(query, NULL); 1148 hb_font_t* harfbuzz_font = CreateHarfBuzzFont(run->skia_face.get(), 1149 run->font_size, run->render_params, background_is_transparent()); 1150 1151 // Create a HarfBuzz buffer and add the string to be shaped. The HarfBuzz 1152 // buffer holds our text, run information to be used by the shaping engine, 1153 // and the resulting glyph data. 1154 hb_buffer_t* buffer = hb_buffer_create(); 1155 hb_buffer_add_utf16(buffer, reinterpret_cast<const uint16*>(text.c_str()), 1156 text.length(), run->range.start(), run->range.length()); 1157 hb_buffer_set_script(buffer, ICUScriptToHBScript(run->script)); 1158 hb_buffer_set_direction(buffer, 1159 run->is_rtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR); 1160 // TODO(ckocagil): Should we determine the actual language? 1161 hb_buffer_set_language(buffer, hb_language_get_default()); 1162 1163 // Shape the text. 1164 hb_shape(harfbuzz_font, buffer, NULL, 0); 1165 1166 // Populate the run fields with the resulting glyph data in the buffer. 1167 unsigned int glyph_count = 0; 1168 hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count); 1169 run->glyph_count = glyph_count; 1170 hb_glyph_position_t* hb_positions = 1171 hb_buffer_get_glyph_positions(buffer, NULL); 1172 run->glyphs.reset(new uint16[run->glyph_count]); 1173 run->glyph_to_char.resize(run->glyph_count); 1174 run->positions.reset(new SkPoint[run->glyph_count]); 1175 run->width = 0.0f; 1176 for (size_t i = 0; i < run->glyph_count; ++i) { 1177 run->glyphs[i] = infos[i].codepoint; 1178 run->glyph_to_char[i] = infos[i].cluster; 1179 const int x_offset = SkFixedToScalar(hb_positions[i].x_offset); 1180 const int y_offset = SkFixedToScalar(hb_positions[i].y_offset); 1181 run->positions[i].set(run->width + x_offset, -y_offset); 1182 run->width += SkFixedToScalar(hb_positions[i].x_advance); 1183 #if defined(OS_LINUX) 1184 // Match Pango's glyph rounding logic on Linux. 1185 if (!run->render_params.subpixel_positioning) 1186 run->width = std::floor(run->width + 0.5f); 1187 #endif 1188 } 1189 1190 hb_buffer_destroy(buffer); 1191 hb_font_destroy(harfbuzz_font); 1192 return true; 1193 } 1194 1195 } // namespace gfx 1196