// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/child/dwrite_font_proxy/font_fallback_win.h"
#include <math.h>
#include <algorithm>
#include <string>
#include "base/metrics/histogram_macros.h"
#include "base/strings/utf_string_conversion_utils.h"
#include "base/strings/utf_string_conversions.h"
#include "base/trace_event/trace_event.h"
#include "content/child/dwrite_font_proxy/dwrite_font_proxy_win.h"
namespace mswr = Microsoft::WRL;
namespace content {
namespace {
const size_t kMaxFamilyCacheSize = 10;
std::wstring MakeCacheKey(const wchar_t* base_family_name,
const wchar_t* locale) {
std::wstring cache_key(base_family_name);
return cache_key + L"_" + locale;
}
} // namespace
HRESULT FontFallback::Create(FontFallback** font_fallback_out,
DWriteFontCollectionProxy* collection) {
return Microsoft::WRL::MakeAndInitialize<FontFallback>(font_fallback_out,
collection);
}
FontFallback::FontFallback() = default;
FontFallback::~FontFallback() = default;
HRESULT FontFallback::MapCharacters(IDWriteTextAnalysisSource* source,
UINT32 text_position,
UINT32 text_length,
IDWriteFontCollection* base_font_collection,
const wchar_t* base_family_name,
DWRITE_FONT_WEIGHT base_weight,
DWRITE_FONT_STYLE base_style,
DWRITE_FONT_STRETCH base_stretch,
UINT32* mapped_length,
IDWriteFont** mapped_font,
FLOAT* scale) {
*mapped_font = nullptr;
*mapped_length = 1;
*scale = 1.0;
const WCHAR* text = nullptr;
UINT32 chunk_length = 0;
if (FAILED(source->GetTextAtPosition(text_position, &text, &chunk_length))) {
DCHECK(false);
return E_FAIL;
}
std::u16string text_chunk;
base::WideToUTF16(text, std::min(chunk_length, text_length), &text_chunk);
if (text_chunk.size() == 0) {
DCHECK(false);
return E_INVALIDARG;
}
base_family_name = base_family_name ? base_family_name : L"";
const WCHAR* locale = nullptr;
// |locale_text_length| is actually the length of text with the locale, not
// the length of the locale string itself.
UINT32 locale_text_length = 0;
source->GetLocaleName(text_position /*textPosition*/, &locale_text_length,
&locale);
locale = locale ? locale : L"";
size_t mapped_length_size_t = *mapped_length;
if (GetCachedFont(text_chunk, base_family_name, locale, base_weight,
base_style, base_stretch, mapped_font,
&mapped_length_size_t)) {
DCHECK(*mapped_font);
DCHECK_GT(mapped_length_size_t, 0u);
*mapped_length = base::checked_cast<UINT32>(mapped_length_size_t);
return S_OK;
}
TRACE_EVENT0("dwrite,fonts", "FontFallback::MapCharacters (IPC)");
blink::mojom::MapCharactersResultPtr result;
if (!GetFontProxy().MapCharacters(
text_chunk,
blink::mojom::DWriteFontStyle::New(base_weight, base_style,
base_stretch),
base::WideToUTF16(locale), source->GetParagraphReadingDirection(),
base::WideToUTF16(base_family_name), &result)) {
DCHECK(false);
return E_FAIL;
}
// We don't cache scale in the fallback cache, and Skia ignores scale anyway.
// If we ever get a result that's significantly different from 1 we may need
// to consider whether it's worth doing the work to plumb it through.
DCHECK(fabs(*scale - 1.0f) < 0.00001);
*mapped_length = result->mapped_length;
*scale = result->scale;
if (result->family_index == UINT32_MAX) {
return S_OK;
}
mswr::ComPtr<IDWriteFontFamily> family;
// It would be nice to find a way to determine at runtime if |collection_| is
// a proxy collection, or just a generic IDWriteFontCollection. Unfortunately
// I can't find a way to get QueryInterface to return the actual class when
// using mswr::RuntimeClass. If we could use QI, we can fallback on
// FindFontFamily if the proxy is not available.
if (!collection_->GetFontFamily(result->family_index, result->family_name,
&family)) {
DCHECK(false);
return E_FAIL;
}
if (FAILED(family->GetFirstMatchingFont(
static_cast<DWRITE_FONT_WEIGHT>(result->font_style->font_weight),
static_cast<DWRITE_FONT_STRETCH>(result->font_style->font_stretch),
static_cast<DWRITE_FONT_STYLE>(result->font_style->font_slant),
mapped_font))) {
DCHECK(false);
return E_FAIL;
}
DCHECK(*mapped_font);
AddCachedFamily(std::move(family), base_family_name, locale);
return S_OK;
}
HRESULT STDMETHODCALLTYPE
FontFallback::RuntimeClassInitialize(DWriteFontCollectionProxy* collection) {
collection_ = collection;
return S_OK;
}
bool FontFallback::GetCachedFont(const std::u16string& text,
const wchar_t* base_family_name,
const wchar_t* locale,
DWRITE_FONT_WEIGHT base_weight,
DWRITE_FONT_STYLE base_style,
DWRITE_FONT_STRETCH base_stretch,
IDWriteFont** font,
size_t* mapped_length) {
base::AutoLock guard(lock_);
std::map<std::wstring, std::list<mswr::ComPtr<IDWriteFontFamily>>>::iterator
it = fallback_family_cache_.find(MakeCacheKey(base_family_name, locale));
if (it == fallback_family_cache_.end())
return false;
TRACE_EVENT0("dwrite,fonts", "FontFallback::GetCachedFont");
std::list<mswr::ComPtr<IDWriteFontFamily>>& family_list = it->second;
std::list<mswr::ComPtr<IDWriteFontFamily>>::iterator family_iterator;
for (family_iterator = family_list.begin();
family_iterator != family_list.end(); ++family_iterator) {
mswr::ComPtr<IDWriteFont> matched_font;
if (FAILED((*family_iterator)
->GetFirstMatchingFont(base_weight, base_stretch, base_style,
&matched_font))) {
continue;
}
// |character_index| tracks how much of the string we have read. This is
// different from |mapped_length| because ReadUnicodeCharacter can advance
// |character_index| even if the character cannot be mapped (invalid
// surrogate pair or font does not contain a matching glyph).
size_t character_index = 0;
size_t length = 0; // How much of the text can actually be mapped.
while (character_index < text.length()) {
BOOL exists = false;
base_icu::UChar32 character = 0;
if (!base::ReadUnicodeCharacter(text.c_str(), text.length(),
&character_index, &character))
break;
if (FAILED(matched_font->HasCharacter(character, &exists)) || !exists)
break;
character_index++;
length = character_index;
}
if (length > 0) {
// Move the current family to the front of the list
family_list.splice(family_list.begin(), family_list, family_iterator);
matched_font.CopyTo(font);
*mapped_length = length;
return true;
}
}
return false;
}
void FontFallback::AddCachedFamily(
Microsoft::WRL::ComPtr<IDWriteFontFamily> family,
const wchar_t* base_family_name,
const wchar_t* locale) {
base::AutoLock guard(lock_);
// Note: If the requested locale does not disambiguate Han ideographs, caching
// by locale may prime the cache with one CJK font for the first request,
// which may be unsuitable for the next request. For example: While specifying
// an ambiguous locale, requesting certain Chinese characters first, DWrite
// will give us a simplified Chinese font, then requesting a Korean character
// later may return a Chinese font for the Korean character. This is prevented
// on the Blink side by passing a disambiguating locale.
std::list<mswr::ComPtr<IDWriteFontFamily>>& family_list =
fallback_family_cache_[MakeCacheKey(base_family_name, locale)];
family_list.push_front(std::move(family));
while (family_list.size() > kMaxFamilyCacheSize)
family_list.pop_back();
}
blink::mojom::DWriteFontProxy& FontFallback::GetFontProxy() {
return collection_->GetFontProxy();
}
} // namespace content
Codebase Browser
chromium