diff options
Diffstat (limited to 'chromium/ui/gfx/render_text_harfbuzz.cc')
| -rw-r--r-- | chromium/ui/gfx/render_text_harfbuzz.cc | 1010 |
1 files changed, 1010 insertions, 0 deletions
diff --git a/chromium/ui/gfx/render_text_harfbuzz.cc b/chromium/ui/gfx/render_text_harfbuzz.cc new file mode 100644 index 00000000000..3d9bf58141e --- /dev/null +++ b/chromium/ui/gfx/render_text_harfbuzz.cc @@ -0,0 +1,1010 @@ +// Copyright 2014 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 "ui/gfx/render_text_harfbuzz.h" + +#include <map> + +#include "base/debug/leak_annotations.h" +#include "base/i18n/bidi_line_iterator.h" +#include "base/i18n/break_iterator.h" +#include "base/i18n/char_iterator.h" +#include "base/lazy_instance.h" +#include "third_party/harfbuzz-ng/src/hb.h" +#include "third_party/icu/source/common/unicode/ubidi.h" +#include "third_party/skia/include/core/SkColor.h" +#include "third_party/skia/include/core/SkTypeface.h" +#include "ui/gfx/canvas.h" +#include "ui/gfx/utf16_indexing.h" + +#if defined(OS_WIN) +#include "ui/gfx/font_smoothing_win.h" +#endif + +namespace gfx { + +namespace { + +// The maximum number of scripts a Unicode character can belong to. This value +// is arbitrarily chosen to be a good limit because it is unlikely for a single +// character to belong to more scripts. +const size_t kMaxScripts = 5; + +// Maps from code points to glyph indices in a font. +typedef std::map<uint32_t, uint16_t> GlyphCache; + +// Font data provider for HarfBuzz using Skia. Copied from Blink. +// TODO(ckocagil): Eliminate the duplication. http://crbug.com/368375 +struct FontData { + FontData(GlyphCache* glyph_cache) : glyph_cache_(glyph_cache) {} + + SkPaint paint_; + GlyphCache* glyph_cache_; +}; + +hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value) { + return SkScalarToFixed(value); +} + +// Deletes the object at the given pointer after casting it to the given type. +template<typename Type> +void DeleteByType(void* data) { + Type* typed_data = reinterpret_cast<Type*>(data); + delete typed_data; +} + +template<typename Type> +void DeleteArrayByType(void* data) { + Type* typed_data = reinterpret_cast<Type*>(data); + delete[] typed_data; +} + +// Outputs the |width| and |extents| of the glyph with index |codepoint| in +// |paint|'s font. +void GetGlyphWidthAndExtents(SkPaint* paint, + hb_codepoint_t codepoint, + hb_position_t* width, + hb_glyph_extents_t* extents) { + DCHECK_LE(codepoint, 0xFFFFU); + paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding); + + SkScalar sk_width; + SkRect sk_bounds; + uint16_t glyph = codepoint; + + paint->getTextWidths(&glyph, sizeof(glyph), &sk_width, &sk_bounds); + if (width) + *width = SkiaScalarToHarfBuzzPosition(sk_width); + if (extents) { + // Invert y-axis because Skia is y-grows-down but we set up HarfBuzz to be + // y-grows-up. + extents->x_bearing = SkiaScalarToHarfBuzzPosition(sk_bounds.fLeft); + extents->y_bearing = SkiaScalarToHarfBuzzPosition(-sk_bounds.fTop); + extents->width = SkiaScalarToHarfBuzzPosition(sk_bounds.width()); + extents->height = SkiaScalarToHarfBuzzPosition(-sk_bounds.height()); + } +} + +// Writes the |glyph| index for the given |unicode| code point. Returns whether +// the glyph exists, i.e. it is not a missing glyph. +hb_bool_t GetGlyph(hb_font_t* font, + void* data, + hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t* glyph, + void* user_data) { + FontData* font_data = reinterpret_cast<FontData*>(data); + GlyphCache* cache = font_data->glyph_cache_; + + bool exists = cache->count(unicode) != 0; + if (!exists) { + SkPaint* paint = &font_data->paint_; + paint->setTextEncoding(SkPaint::kUTF32_TextEncoding); + paint->textToGlyphs(&unicode, sizeof(hb_codepoint_t), &(*cache)[unicode]); + } + *glyph = (*cache)[unicode]; + return !!*glyph; +} + +// Returns the horizontal advance value of the |glyph|. +hb_position_t GetGlyphHorizontalAdvance(hb_font_t* font, + void* data, + hb_codepoint_t glyph, + void* user_data) { + FontData* font_data = reinterpret_cast<FontData*>(data); + hb_position_t advance = 0; + + GetGlyphWidthAndExtents(&font_data->paint_, glyph, &advance, 0); + return advance; +} + +hb_bool_t GetGlyphHorizontalOrigin(hb_font_t* font, + void* data, + hb_codepoint_t glyph, + hb_position_t* x, + hb_position_t* y, + void* user_data) { + // Just return true, like the HarfBuzz-FreeType implementation. + return true; +} + +hb_position_t GetGlyphKerning(FontData* font_data, + hb_codepoint_t first_glyph, + hb_codepoint_t second_glyph) { + SkTypeface* typeface = font_data->paint_.getTypeface(); + const uint16_t glyphs[2] = { static_cast<uint16_t>(first_glyph), + static_cast<uint16_t>(second_glyph) }; + int32_t kerning_adjustments[1] = { 0 }; + + if (!typeface->getKerningPairAdjustments(glyphs, 2, kerning_adjustments)) + return 0; + + SkScalar upm = SkIntToScalar(typeface->getUnitsPerEm()); + SkScalar size = font_data->paint_.getTextSize(); + return SkiaScalarToHarfBuzzPosition( + SkScalarMulDiv(SkIntToScalar(kerning_adjustments[0]), size, upm)); +} + +hb_position_t GetGlyphHorizontalKerning(hb_font_t* font, + void* data, + hb_codepoint_t left_glyph, + hb_codepoint_t right_glyph, + void* user_data) { + FontData* font_data = reinterpret_cast<FontData*>(data); + if (font_data->paint_.isVerticalText()) { + // We don't support cross-stream kerning. + return 0; + } + + return GetGlyphKerning(font_data, left_glyph, right_glyph); +} + +hb_position_t GetGlyphVerticalKerning(hb_font_t* font, + void* data, + hb_codepoint_t top_glyph, + hb_codepoint_t bottom_glyph, + void* user_data) { + FontData* font_data = reinterpret_cast<FontData*>(data); + if (!font_data->paint_.isVerticalText()) { + // We don't support cross-stream kerning. + return 0; + } + + return GetGlyphKerning(font_data, top_glyph, bottom_glyph); +} + +// Writes the |extents| of |glyph|. +hb_bool_t GetGlyphExtents(hb_font_t* font, + void* data, + hb_codepoint_t glyph, + hb_glyph_extents_t* extents, + void* user_data) { + FontData* font_data = reinterpret_cast<FontData*>(data); + + GetGlyphWidthAndExtents(&font_data->paint_, glyph, 0, extents); + return true; +} + +class FontFuncs { + public: + FontFuncs() : font_funcs_(hb_font_funcs_create()) { + hb_font_funcs_set_glyph_func(font_funcs_, GetGlyph, 0, 0); + hb_font_funcs_set_glyph_h_advance_func( + font_funcs_, GetGlyphHorizontalAdvance, 0, 0); + hb_font_funcs_set_glyph_h_kerning_func( + font_funcs_, GetGlyphHorizontalKerning, 0, 0); + hb_font_funcs_set_glyph_h_origin_func( + font_funcs_, GetGlyphHorizontalOrigin, 0, 0); + hb_font_funcs_set_glyph_v_kerning_func( + font_funcs_, GetGlyphVerticalKerning, 0, 0); + hb_font_funcs_set_glyph_extents_func( + font_funcs_, GetGlyphExtents, 0, 0); + hb_font_funcs_make_immutable(font_funcs_); + } + + ~FontFuncs() { + hb_font_funcs_destroy(font_funcs_); + } + + hb_font_funcs_t* get() { return font_funcs_; } + + private: + hb_font_funcs_t* font_funcs_; + + DISALLOW_COPY_AND_ASSIGN(FontFuncs); +}; + +base::LazyInstance<FontFuncs>::Leaky g_font_funcs = LAZY_INSTANCE_INITIALIZER; + +// Returns the raw data of the font table |tag|. +hb_blob_t* GetFontTable(hb_face_t* face, hb_tag_t tag, void* user_data) { + SkTypeface* typeface = reinterpret_cast<SkTypeface*>(user_data); + + const size_t table_size = typeface->getTableSize(tag); + if (!table_size) + return 0; + + scoped_ptr<char[]> buffer(new char[table_size]); + if (!buffer) + return 0; + size_t actual_size = typeface->getTableData(tag, 0, table_size, buffer.get()); + if (table_size != actual_size) + return 0; + + char* buffer_raw = buffer.release(); + return hb_blob_create(buffer_raw, table_size, HB_MEMORY_MODE_WRITABLE, + buffer_raw, DeleteArrayByType<char>); +} + +void UnrefSkTypeface(void* data) { + SkTypeface* skia_face = reinterpret_cast<SkTypeface*>(data); + SkSafeUnref(skia_face); +} + +// Creates a HarfBuzz face from the given Skia face. +hb_face_t* CreateHarfBuzzFace(SkTypeface* skia_face) { + SkSafeRef(skia_face); + hb_face_t* face = hb_face_create_for_tables(GetFontTable, skia_face, + UnrefSkTypeface); + DCHECK(face); + return face; +} + +// Creates a HarfBuzz font from the given Skia face and text size. +hb_font_t* CreateHarfBuzzFont(SkTypeface* skia_face, int text_size) { + typedef std::pair<hb_face_t*, GlyphCache> FaceCache; + + // TODO(ckocagil): This shouldn't grow indefinitely. Maybe use base::MRUCache? + static std::map<SkFontID, FaceCache> face_caches; + + FaceCache* face_cache = &face_caches[skia_face->uniqueID()]; + if (face_cache->first == 0) { + // These HarfBuzz faces live indefinitely and are intentionally leaked. + ANNOTATE_SCOPED_MEMORY_LEAK; + hb_face_t* harfbuzz_face = CreateHarfBuzzFace(skia_face); + *face_cache = FaceCache(harfbuzz_face, GlyphCache()); + } + + hb_font_t* harfbuzz_font = hb_font_create(face_cache->first); + // TODO(ckocagil): Investigate whether disabling hinting here has any effect + // on text quality. + int upem = hb_face_get_upem(face_cache->first); + hb_font_set_scale(harfbuzz_font, upem, upem); + FontData* hb_font_data = new FontData(&face_cache->second); + hb_font_data->paint_.setTypeface(skia_face); + hb_font_data->paint_.setTextSize(text_size); + hb_font_set_funcs(harfbuzz_font, g_font_funcs.Get().get(), hb_font_data, + DeleteByType<FontData>); + hb_font_make_immutable(harfbuzz_font); + return harfbuzz_font; +} + +// Returns true if characters of |block_code| may trigger font fallback. +bool IsUnusualBlockCode(UBlockCode block_code) { + return block_code == UBLOCK_GEOMETRIC_SHAPES || + block_code == UBLOCK_MISCELLANEOUS_SYMBOLS; +} + +// Returns the index of the first unusual character after a usual character or +// vice versa. Unusual characters are defined by |IsUnusualBlockCode|. +size_t FindUnusualCharacter(const base::string16& text, + size_t run_start, + size_t run_break) { + const int32 run_length = static_cast<int32>(run_break - run_start); + base::i18n::UTF16CharIterator iter(text.c_str() + run_start, + run_length); + const UBlockCode first_block_code = ublock_getCode(iter.get()); + const bool first_block_unusual = IsUnusualBlockCode(first_block_code); + while (iter.Advance() && iter.array_pos() < run_length) { + const UBlockCode current_block_code = ublock_getCode(iter.get()); + if (current_block_code != first_block_code && + (first_block_unusual || IsUnusualBlockCode(current_block_code))) { + return run_start + iter.array_pos(); + } + } + return run_break; +} + +// If the given scripts match, returns the one that isn't USCRIPT_COMMON or +// USCRIPT_INHERITED, i.e. the more specific one. Otherwise returns +// USCRIPT_INVALID_CODE. +UScriptCode ScriptIntersect(UScriptCode first, UScriptCode second) { + if (first == second || + (second > USCRIPT_INVALID_CODE && second <= USCRIPT_INHERITED)) { + return first; + } + if (first > USCRIPT_INVALID_CODE && first <= USCRIPT_INHERITED) + return second; + return USCRIPT_INVALID_CODE; +} + +// Writes the script and the script extensions of the character with the +// Unicode |codepoint|. Returns the number of written scripts. +int GetScriptExtensions(UChar32 codepoint, UScriptCode* scripts) { + UErrorCode icu_error = U_ZERO_ERROR; + // ICU documentation incorrectly states that the result of + // |uscript_getScriptExtensions| will contain the regular script property. + // Write the character's script property to the first element. + scripts[0] = uscript_getScript(codepoint, &icu_error); + if (U_FAILURE(icu_error)) + return 0; + // Fill the rest of |scripts| with the extensions. + int count = uscript_getScriptExtensions(codepoint, scripts + 1, + kMaxScripts - 1, &icu_error); + if (U_FAILURE(icu_error)) + count = 0; + return count + 1; +} + +// Intersects the script extensions set of |codepoint| with |result| and writes +// to |result|, reading and updating |result_size|. +void ScriptSetIntersect(UChar32 codepoint, + UScriptCode* result, + size_t* result_size) { + UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE }; + int count = GetScriptExtensions(codepoint, scripts); + + size_t out_size = 0; + + for (size_t i = 0; i < *result_size; ++i) { + for (int j = 0; j < count; ++j) { + UScriptCode intersection = ScriptIntersect(result[i], scripts[j]); + if (intersection != USCRIPT_INVALID_CODE) { + result[out_size++] = intersection; + break; + } + } + } + + *result_size = out_size; +} + +// Find the longest sequence of characters from 0 and up to |length| that +// have at least one common UScriptCode value. Writes the common script value to +// |script| and returns the length of the sequence. Takes the characters' script +// extensions into account. http://www.unicode.org/reports/tr24/#ScriptX +// +// Consider 3 characters with the script values {Kana}, {Hira, Kana}, {Kana}. +// Without script extensions only the first script in each set would be taken +// into account, resulting in 3 runs where 1 would be enough. +// TODO(ckocagil): Write a unit test for the case above. +int ScriptInterval(const base::string16& text, + size_t start, + size_t length, + UScriptCode* script) { + DCHECK_GT(length, 0U); + + UScriptCode scripts[kMaxScripts] = { USCRIPT_INVALID_CODE }; + + base::i18n::UTF16CharIterator char_iterator(text.c_str() + start, length); + size_t scripts_size = GetScriptExtensions(char_iterator.get(), scripts); + *script = scripts[0]; + + while (char_iterator.Advance()) { + ScriptSetIntersect(char_iterator.get(), scripts, &scripts_size); + if (scripts_size == 0U) + return char_iterator.array_pos(); + *script = scripts[0]; + } + + return length; +} + +// A port of hb_icu_script_to_script because harfbuzz on CrOS is built without +// hb-icu. See http://crbug.com/356929 +inline hb_script_t ICUScriptToHBScript(UScriptCode script) { + if (script == USCRIPT_INVALID_CODE) + return HB_SCRIPT_INVALID; + return hb_script_from_string(uscript_getShortName(script), -1); +} + +} // namespace + +namespace internal { + +TextRunHarfBuzz::TextRunHarfBuzz() + : width(0), + preceding_run_widths(0), + is_rtl(false), + level(0), + script(USCRIPT_INVALID_CODE), + glyph_count(-1), + font_size(0), + font_style(0), + strike(false), + diagonal_strike(false), + underline(false) {} + +TextRunHarfBuzz::~TextRunHarfBuzz() {} + +size_t TextRunHarfBuzz::CharToGlyph(size_t pos) const { + DCHECK(range.start() <= pos && pos < range.end()); + + if (!is_rtl) { + size_t cluster_start = 0; + for (size_t i = 1; i < glyph_count && pos >= glyph_to_char[i]; ++i) + if (glyph_to_char[i] != glyph_to_char[i - 1]) + cluster_start = i; + return cluster_start; + } + + for (size_t i = 0; i < glyph_count; ++i) { + if (pos >= glyph_to_char[i]) + return i; + } + NOTREACHED(); + return 0; +} + +Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const { + DCHECK(range.Contains(char_range)); + DCHECK(!char_range.is_reversed()); + DCHECK(!char_range.is_empty()); + + size_t first = 0; + size_t last = 0; + + if (is_rtl) { + // For RTL runs, we subtract 1 from |char_range| to get the leading edges. + last = CharToGlyph(char_range.end() - 1); + // Loop until we find a non-empty glyph range. For multi-character clusters, + // the loop is needed to find the cluster end. Do the same for LTR below. + for (size_t i = char_range.start(); i > range.start(); --i) { + first = CharToGlyph(i - 1); + if (first != last) + return Range(last, first); + } + return Range(last, glyph_count); + } + + first = CharToGlyph(char_range.start()); + for (size_t i = char_range.end(); i < range.end(); ++i) { + last = CharToGlyph(i); + if (first != last) + return Range(first, last); + } + return Range(first, glyph_count); +} + +// Returns whether the given shaped run contains any missing glyphs. +bool TextRunHarfBuzz::HasMissingGlyphs() const { + static const int kMissingGlyphId = 0; + for (size_t i = 0; i < glyph_count; ++i) { + if (glyphs[i] == kMissingGlyphId) + return true; + } + return false; +} + +int TextRunHarfBuzz::GetGlyphXBoundary(size_t text_index, bool trailing) const { + if (text_index == range.end()) { + trailing = true; + --text_index; + } + Range glyph_range = CharRangeToGlyphRange(Range(text_index, text_index + 1)); + const size_t glyph_pos = (is_rtl == trailing) ? + glyph_range.start() : glyph_range.end(); + const int x = glyph_pos < glyph_count ? + SkScalarRoundToInt(positions[glyph_pos].x()) : width; + return preceding_run_widths + x; +} + +} // namespace internal + +RenderTextHarfBuzz::RenderTextHarfBuzz() + : RenderText(), + needs_layout_(false) {} + +RenderTextHarfBuzz::~RenderTextHarfBuzz() {} + +Size RenderTextHarfBuzz::GetStringSize() { + EnsureLayout(); + return lines()[0].size; +} + +SelectionModel RenderTextHarfBuzz::FindCursorPosition(const Point& point) { + EnsureLayout(); + + int x = ToTextPoint(point).x(); + int offset = 0; + size_t run_index = GetRunContainingXCoord(x, &offset); + if (run_index >= runs_.size()) + return EdgeSelectionModel((x < 0) ? CURSOR_LEFT : CURSOR_RIGHT); + const internal::TextRunHarfBuzz& run = *runs_[run_index]; + + for (size_t i = 0; i < run.glyph_count; ++i) { + const SkScalar end = + i + 1 == run.glyph_count ? run.width : run.positions[i + 1].x(); + const SkScalar middle = (end + run.positions[i].x()) / 2; + + if (offset < middle) { + return SelectionModel(LayoutIndexToTextIndex( + run.glyph_to_char[i] + (run.is_rtl ? 1 : 0)), + (run.is_rtl ? CURSOR_BACKWARD : CURSOR_FORWARD)); + } + if (offset < end) { + return SelectionModel(LayoutIndexToTextIndex( + run.glyph_to_char[i] + (run.is_rtl ? 0 : 1)), + (run.is_rtl ? CURSOR_FORWARD : CURSOR_BACKWARD)); + } + } + return EdgeSelectionModel(CURSOR_RIGHT); +} + +std::vector<RenderText::FontSpan> RenderTextHarfBuzz::GetFontSpansForTesting() { + NOTIMPLEMENTED(); + return std::vector<RenderText::FontSpan>(); +} + +int RenderTextHarfBuzz::GetLayoutTextBaseline() { + EnsureLayout(); + return lines()[0].baseline; +} + +SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel( + const SelectionModel& selection, + VisualCursorDirection direction) { + DCHECK(!needs_layout_); + internal::TextRunHarfBuzz* run; + size_t run_index = GetRunContainingCaret(selection); + if (run_index >= runs_.size()) { + // The cursor is not in any run: we're at the visual and logical edge. + SelectionModel edge = EdgeSelectionModel(direction); + if (edge.caret_pos() == selection.caret_pos()) + return edge; + int visual_index = (direction == CURSOR_RIGHT) ? 0 : runs_.size() - 1; + run = runs_[visual_to_logical_[visual_index]]; + } else { + // If the cursor is moving within the current run, just move it by one + // grapheme in the appropriate direction. + run = runs_[run_index]; + size_t caret = selection.caret_pos(); + bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT); + if (forward_motion) { + if (caret < LayoutIndexToTextIndex(run->range.end())) { + caret = IndexOfAdjacentGrapheme(caret, CURSOR_FORWARD); + return SelectionModel(caret, CURSOR_BACKWARD); + } + } else { + if (caret > LayoutIndexToTextIndex(run->range.start())) { + caret = IndexOfAdjacentGrapheme(caret, CURSOR_BACKWARD); + return SelectionModel(caret, CURSOR_FORWARD); + } + } + // The cursor is at the edge of a run; move to the visually adjacent run. + int visual_index = logical_to_visual_[run_index]; + visual_index += (direction == CURSOR_LEFT) ? -1 : 1; + if (visual_index < 0 || visual_index >= static_cast<int>(runs_.size())) + return EdgeSelectionModel(direction); + run = runs_[visual_to_logical_[visual_index]]; + } + bool forward_motion = run->is_rtl == (direction == CURSOR_LEFT); + return forward_motion ? FirstSelectionModelInsideRun(run) : + LastSelectionModelInsideRun(run); +} + +SelectionModel RenderTextHarfBuzz::AdjacentWordSelectionModel( + const SelectionModel& selection, + VisualCursorDirection direction) { + // TODO(ckocagil): This implementation currently matches RenderTextWin, but it + // should match the native behavior on other platforms. + if (obscured()) + return EdgeSelectionModel(direction); + + base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD); + bool success = iter.Init(); + DCHECK(success); + if (!success) + return selection; + + size_t pos; + if (direction == CURSOR_RIGHT) { + pos = std::min(selection.caret_pos() + 1, text().length()); + while (iter.Advance()) { + pos = iter.pos(); + if (iter.IsWord() && pos > selection.caret_pos()) + break; + } + } else { // direction == CURSOR_LEFT + // Notes: We always iterate words from the beginning. + // This is probably fast enough for our usage, but we may + // want to modify WordIterator so that it can start from the + // middle of string and advance backwards. + pos = std::max<int>(selection.caret_pos() - 1, 0); + while (iter.Advance()) { + if (iter.IsWord()) { + size_t begin = iter.pos() - iter.GetString().length(); + if (begin == selection.caret_pos()) { + // The cursor is at the beginning of a word. + // Move to previous word. + break; + } else if (iter.pos() >= selection.caret_pos()) { + // The cursor is in the middle or at the end of a word. + // Move to the top of current word. + pos = begin; + break; + } + pos = iter.pos() - iter.GetString().length(); + } + } + } + return SelectionModel(pos, CURSOR_FORWARD); +} + +Range RenderTextHarfBuzz::GetGlyphBounds(size_t index) { + const size_t run_index = + GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD)); + // Return edge bounds if the index is invalid or beyond the layout text size. + if (run_index >= runs_.size()) + return Range(GetStringSize().width()); + const size_t layout_index = TextIndexToLayoutIndex(index); + return Range(runs_[run_index]->GetGlyphXBoundary(layout_index, false), + runs_[run_index]->GetGlyphXBoundary(layout_index, true)); +} + +std::vector<Rect> RenderTextHarfBuzz::GetSubstringBounds(const Range& range) { + DCHECK(!needs_layout_); + DCHECK(Range(0, text().length()).Contains(range)); + Range layout_range(TextIndexToLayoutIndex(range.start()), + TextIndexToLayoutIndex(range.end())); + DCHECK(Range(0, GetLayoutText().length()).Contains(layout_range)); + + std::vector<Rect> rects; + if (layout_range.is_empty()) + return rects; + std::vector<Range> bounds; + + // Add a Range for each run/selection intersection. + // TODO(msw): The bounds should probably not always be leading the range ends. + for (size_t i = 0; i < runs_.size(); ++i) { + const internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]]; + Range intersection = run->range.Intersect(layout_range); + if (intersection.IsValid()) { + DCHECK(!intersection.is_reversed()); + Range range_x(run->GetGlyphXBoundary(intersection.start(), false), + run->GetGlyphXBoundary(intersection.end(), false)); + if (range_x.is_empty()) + continue; + range_x = Range(range_x.GetMin(), range_x.GetMax()); + // Union this with the last range if they're adjacent. + DCHECK(bounds.empty() || bounds.back().GetMax() <= range_x.GetMin()); + if (!bounds.empty() && bounds.back().GetMax() == range_x.GetMin()) { + range_x = Range(bounds.back().GetMin(), range_x.GetMax()); + bounds.pop_back(); + } + bounds.push_back(range_x); + } + } + for (size_t i = 0; i < bounds.size(); ++i) { + std::vector<Rect> current_rects = TextBoundsToViewBounds(bounds[i]); + rects.insert(rects.end(), current_rects.begin(), current_rects.end()); + } + return rects; +} + +size_t RenderTextHarfBuzz::TextIndexToLayoutIndex(size_t index) const { + DCHECK_LE(index, text().length()); + ptrdiff_t i = obscured() ? UTF16IndexToOffset(text(), 0, index) : index; + CHECK_GE(i, 0); + // Clamp layout indices to the length of the text actually used for layout. + return std::min<size_t>(GetLayoutText().length(), i); +} + +size_t RenderTextHarfBuzz::LayoutIndexToTextIndex(size_t index) const { + if (!obscured()) + return index; + + DCHECK_LE(index, GetLayoutText().length()); + const size_t text_index = UTF16OffsetToIndex(text(), 0, index); + DCHECK_LE(text_index, text().length()); + return text_index; +} + +bool RenderTextHarfBuzz::IsValidCursorIndex(size_t index) { + if (index == 0 || index == text().length()) + return true; + if (!IsValidLogicalIndex(index)) + return false; + EnsureLayout(); + // Disallow indices amid multi-character graphemes by checking glyph bounds. + // These characters are not surrogate-pairs, but may yield a single glyph: + // \x0915\x093f - (ki) - one of many Devanagari biconsonantal conjuncts. + // \x0e08\x0e33 - (cho chan + sara am) - a Thai consonant and vowel pair. + return GetGlyphBounds(index) != GetGlyphBounds(index - 1); +} + +void RenderTextHarfBuzz::ResetLayout() { + needs_layout_ = true; +} + +void RenderTextHarfBuzz::EnsureLayout() { + if (needs_layout_) { + runs_.clear(); + + if (!GetLayoutText().empty()) { + ItemizeText(); + + for (size_t i = 0; i < runs_.size(); ++i) + ShapeRun(runs_[i]); + + // Precalculate run width information. + size_t preceding_run_widths = 0; + for (size_t i = 0; i < runs_.size(); ++i) { + internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]]; + run->preceding_run_widths = preceding_run_widths; + preceding_run_widths += run->width; + } + } + + needs_layout_ = false; + std::vector<internal::Line> empty_lines; + set_lines(&empty_lines); + } + + if (lines().empty()) { + std::vector<internal::Line> lines; + lines.push_back(internal::Line()); + lines[0].baseline = font_list().GetBaseline(); + lines[0].size.set_height(font_list().GetHeight()); + + int current_x = 0; + SkPaint paint; + + for (size_t i = 0; i < runs_.size(); ++i) { + const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]]; + internal::LineSegment segment; + segment.x_range = Range(current_x, current_x + run.width); + segment.char_range = run.range; + segment.run = i; + lines[0].segments.push_back(segment); + + paint.setTypeface(run.skia_face.get()); + paint.setTextSize(run.font_size); + SkPaint::FontMetrics metrics; + paint.getFontMetrics(&metrics); + + lines[0].size.set_width(lines[0].size.width() + run.width); + lines[0].size.set_height(std::max(lines[0].size.height(), + SkScalarRoundToInt(metrics.fDescent - metrics.fAscent))); + lines[0].baseline = std::max(lines[0].baseline, + SkScalarRoundToInt(-metrics.fAscent)); + } + + set_lines(&lines); + } +} + +void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) { + DCHECK(!needs_layout_); + + int current_x = 0; + + internal::SkiaTextRenderer renderer(canvas); + ApplyFadeEffects(&renderer); + ApplyTextShadows(&renderer); + +#if defined(OS_WIN) + bool smoothing_enabled; + bool cleartype_enabled; + GetCachedFontSmoothingSettings(&smoothing_enabled, &cleartype_enabled); + // Note that |cleartype_enabled| corresponds to Skia's |enable_lcd_text|. + renderer.SetFontSmoothingSettings( + smoothing_enabled, cleartype_enabled && !background_is_transparent(), + smoothing_enabled /* subpixel_positioning */); +#endif + + ApplyCompositionAndSelectionStyles(); + + const Vector2d line_offset = GetLineOffset(0); + + for (size_t i = 0; i < runs_.size(); ++i) { + const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]]; + renderer.SetTypeface(run.skia_face.get()); + renderer.SetTextSize(run.font_size); + + canvas->Save(); + Vector2d origin = line_offset + Vector2d(current_x, lines()[0].baseline); + canvas->Translate(origin); + + for (BreakList<SkColor>::const_iterator it = + colors().GetBreak(run.range.start()); + it != colors().breaks().end() && it->first < run.range.end(); + ++it) { + const Range intersection = colors().GetRange(it).Intersect(run.range); + const Range colored_glyphs = run.CharRangeToGlyphRange(intersection); + // The range may be empty if a portion of a multi-character grapheme is + // selected, yielding two colors for a single glyph. For now, this just + // paints the glyph with a single style, but it should paint it twice, + // clipped according to selection bounds. See http://crbug.com/366786 + if (colored_glyphs.is_empty()) + continue; + + renderer.SetForegroundColor(it->second); + renderer.DrawPosText(&run.positions[colored_glyphs.start()], + &run.glyphs[colored_glyphs.start()], + colored_glyphs.length()); + int width = (colored_glyphs.end() == run.glyph_count ? run.width : + run.positions[colored_glyphs.end()].x()) - + run.positions[colored_glyphs.start()].x(); + renderer.DrawDecorations(0, 0, width, run.underline, run.strike, + run.diagonal_strike); + } + + canvas->Restore(); + current_x += run.width; + } + + renderer.EndDiagonalStrike(); + + UndoCompositionAndSelectionStyles(); +} + +size_t RenderTextHarfBuzz::GetRunContainingCaret( + const SelectionModel& caret) const { + DCHECK(!needs_layout_); + size_t layout_position = TextIndexToLayoutIndex(caret.caret_pos()); + LogicalCursorDirection affinity = caret.caret_affinity(); + for (size_t run = 0; run < runs_.size(); ++run) { + if (RangeContainsCaret(runs_[run]->range, layout_position, affinity)) + return run; + } + return runs_.size(); +} + +size_t RenderTextHarfBuzz::GetRunContainingXCoord(int x, int* offset) const { + DCHECK(!needs_layout_); + if (x < 0) + return runs_.size(); + // Find the text run containing the argument point (assumed already offset). + int current_x = 0; + for (size_t i = 0; i < runs_.size(); ++i) { + size_t run = visual_to_logical_[i]; + current_x += runs_[run]->width; + if (x < current_x) { + *offset = x - (current_x - runs_[run]->width); + return run; + } + } + return runs_.size(); +} + +SelectionModel RenderTextHarfBuzz::FirstSelectionModelInsideRun( + const internal::TextRunHarfBuzz* run) { + size_t position = LayoutIndexToTextIndex(run->range.start()); + position = IndexOfAdjacentGrapheme(position, CURSOR_FORWARD); + return SelectionModel(position, CURSOR_BACKWARD); +} + +SelectionModel RenderTextHarfBuzz::LastSelectionModelInsideRun( + const internal::TextRunHarfBuzz* run) { + size_t position = LayoutIndexToTextIndex(run->range.end()); + position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD); + return SelectionModel(position, CURSOR_FORWARD); +} + +void RenderTextHarfBuzz::ItemizeText() { + const base::string16& text = GetLayoutText(); + const bool is_text_rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT; + DCHECK_NE(0U, text.length()); + + // If ICU fails to itemize the text, we create a run that spans the entire + // text. This is needed because leaving the runs set empty causes some clients + // to misbehave since they expect non-zero text metrics from a non-empty text. + base::i18n::BiDiLineIterator bidi_iterator; + if (!bidi_iterator.Open(text, is_text_rtl, false)) { + internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz; + run->range = Range(0, text.length()); + runs_.push_back(run); + visual_to_logical_ = logical_to_visual_ = std::vector<int32_t>(1, 0); + return; + } + + // Temporarily apply composition underlines and selection colors. + ApplyCompositionAndSelectionStyles(); + + // Build the list of runs from the script items and ranged styles. Use an + // empty color BreakList to avoid breaking runs at color boundaries. + BreakList<SkColor> empty_colors; + empty_colors.SetMax(text.length()); + internal::StyleIterator style(empty_colors, styles()); + + for (size_t run_break = 0; run_break < text.length();) { + internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz; + run->range.set_start(run_break); + run->font_style = (style.style(BOLD) ? Font::BOLD : 0) | + (style.style(ITALIC) ? Font::ITALIC : 0); + run->strike = style.style(STRIKE); + run->diagonal_strike = style.style(DIAGONAL_STRIKE); + run->underline = style.style(UNDERLINE); + + int32 script_item_break = 0; + bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level); + // Odd BiDi embedding levels correspond to RTL runs. + run->is_rtl = (run->level % 2) == 1; + // Find the length and script of this script run. + script_item_break = ScriptInterval(text, run_break, + script_item_break - run_break, &run->script) + run_break; + + // Find the next break and advance the iterators as needed. + run_break = std::min(static_cast<size_t>(script_item_break), + TextIndexToLayoutIndex(style.GetRange().end())); + + // Break runs adjacent to character substrings in certain code blocks. + // This avoids using their fallback fonts for more characters than needed, + // in cases like "\x25B6 Media Title", etc. http://crbug.com/278913 + if (run_break > run->range.start()) + run_break = FindUnusualCharacter(text, run->range.start(), run_break); + + DCHECK(IsValidCodePointIndex(text, run_break)); + style.UpdatePosition(LayoutIndexToTextIndex(run_break)); + run->range.set_end(run_break); + + runs_.push_back(run); + } + + // Undo the temporarily applied composition underlines and selection colors. + UndoCompositionAndSelectionStyles(); + + const size_t num_runs = runs_.size(); + std::vector<UBiDiLevel> levels(num_runs); + for (size_t i = 0; i < num_runs; ++i) + levels[i] = runs_[i]->level; + visual_to_logical_.resize(num_runs); + ubidi_reorderVisual(&levels[0], num_runs, &visual_to_logical_[0]); + logical_to_visual_.resize(num_runs); + ubidi_reorderLogical(&levels[0], num_runs, &logical_to_visual_[0]); +} + +void RenderTextHarfBuzz::ShapeRun(internal::TextRunHarfBuzz* run) { + const base::string16& text = GetLayoutText(); + // TODO(ckocagil|yukishiino): Implement font fallback. + const Font& primary_font = font_list().GetPrimaryFont(); + run->skia_face = internal::CreateSkiaTypeface(primary_font.GetFontName(), + run->font_style); + run->font_size = primary_font.GetFontSize(); + + hb_font_t* harfbuzz_font = CreateHarfBuzzFont(run->skia_face.get(), + run->font_size); + + // Create a HarfBuzz buffer and add the string to be shaped. The HarfBuzz + // buffer holds our text, run information to be used by the shaping engine, + // and the resulting glyph data. + hb_buffer_t* buffer = hb_buffer_create(); + hb_buffer_add_utf16(buffer, reinterpret_cast<const uint16*>(text.c_str()), + text.length(), run->range.start(), run->range.length()); + hb_buffer_set_script(buffer, ICUScriptToHBScript(run->script)); + hb_buffer_set_direction(buffer, + run->is_rtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR); + // TODO(ckocagil): Should we determine the actual language? + hb_buffer_set_language(buffer, hb_language_get_default()); + + // Shape the text. + hb_shape(harfbuzz_font, buffer, NULL, 0); + + // Populate the run fields with the resulting glyph data in the buffer. + unsigned int glyph_count = 0; + hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count); + hb_glyph_position_t* hb_positions = hb_buffer_get_glyph_positions(buffer, + NULL); + run->glyph_count = glyph_count; + run->glyphs.reset(new uint16[run->glyph_count]); + run->glyph_to_char.reset(new uint32[run->glyph_count]); + run->positions.reset(new SkPoint[run->glyph_count]); + for (size_t i = 0; i < run->glyph_count; ++i) { + run->glyphs[i] = infos[i].codepoint; + run->glyph_to_char[i] = infos[i].cluster; + const int x_offset = + SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_offset)); + const int y_offset = + SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].y_offset)); + run->positions[i].set(run->width + x_offset, y_offset); + run->width += + SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_advance)); + } + + hb_buffer_destroy(buffer); + hb_font_destroy(harfbuzz_font); +} + +} // namespace gfx |