blob: f9645bd654d30b21e2fdb369c3e652362d3817c2 [file] [log] [blame]
// Copyright 2015 Google Inc. All Rights Reserved.
//
// 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
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "cobalt/dom/font_cache.h"
namespace cobalt {
namespace dom {
namespace {
const int64 kInactiveProcessTimeIntervalMs = 1000;
const int32_t kInactiveFontListPurgeDelayMs = 300000;
const int32_t kInactiveFontPurgeDelayMs = 900000;
const int32_t kTotalFontCountPurgeThreshold = 64;
} // namespace
FontCache::RequestedRemoteTypefaceInfo::RequestedRemoteTypefaceInfo(
const scoped_refptr<loader::font::CachedRemoteTypeface>&
cached_remote_typeface,
const base::Closure& typeface_load_event_callback)
: cached_remote_typeface_reference_(
new loader::font::CachedRemoteTypefaceReferenceWithCallbacks(
cached_remote_typeface, typeface_load_event_callback,
typeface_load_event_callback)),
request_timer_(new base::Timer(false, false)) {
request_timer_->Start(FROM_HERE,
base::TimeDelta::FromMilliseconds(kRequestTimerDelay),
typeface_load_event_callback);
}
FontCache::FontCache(render_tree::ResourceProvider** resource_provider,
loader::font::RemoteTypefaceCache* remote_typeface_cache,
const base::Closure& external_typeface_load_event_callback,
const std::string& language)
: resource_provider_(resource_provider),
remote_typeface_cache_(remote_typeface_cache),
external_typeface_load_event_callback_(
external_typeface_load_event_callback),
language_(language),
font_face_map_(new FontFaceMap()),
last_inactive_process_time_(base::TimeTicks::Now()) {}
void FontCache::SetFontFaceMap(scoped_ptr<FontFaceMap> font_face_map) {
DCHECK(thread_checker_.CalledOnValidThread());
// If nothing has changed, then there's nothing to update. Just return.
if (*font_face_map == *font_face_map_) {
return;
}
// Clear out the cached font lists. It may no longer contain valid font
// mappings as a result of the font face map changing.
font_list_map_.clear();
font_face_map_ = font_face_map.Pass();
// Generate a set of the urls contained within the new font face map.
std::set<GURL> new_url_set;
for (FontFaceMap::iterator map_iterator = font_face_map_->begin();
map_iterator != font_face_map_->end(); ++map_iterator) {
map_iterator->second.CollectUrlSources(&new_url_set);
}
// Iterate through active remote typeface references, verifying that the font
// face map still contains each remote typeface's url. Any remote typeface
// with a url that is no longer contained within |font_face_map_| is purged to
// allow the remote cache to release the memory.
RequestedRemoteTypefaceMap::iterator requested_remote_typeface_iterator =
requested_remote_typeface_cache_.begin();
while (requested_remote_typeface_iterator !=
requested_remote_typeface_cache_.end()) {
RequestedRemoteTypefaceMap::iterator current_iterator =
requested_remote_typeface_iterator++;
// If the referenced url is not in the new url set, then purge it.
if (new_url_set.find(current_iterator->first) == new_url_set.end()) {
requested_remote_typeface_cache_.erase(current_iterator);
}
}
}
void FontCache::ProcessInactiveFontListsAndFonts() {
DCHECK(thread_checker_.CalledOnValidThread());
base::TimeTicks current_time = base::TimeTicks::Now();
if ((current_time - last_inactive_process_time_).InMilliseconds() >
kInactiveProcessTimeIntervalMs) {
last_inactive_process_time_ = current_time;
ProcessInactiveFontLists(current_time);
ProcessInactiveFonts(current_time);
}
}
const scoped_refptr<dom::FontList>& FontCache::GetFontList(
const FontListKey& font_list_key) {
DCHECK(thread_checker_.CalledOnValidThread());
FontListInfo& font_list_info = font_list_map_[font_list_key];
if (font_list_info.font_list == NULL) {
font_list_info.font_list = new FontList(this, font_list_key);
}
return font_list_info.font_list;
}
const scoped_refptr<render_tree::Font>& FontCache::GetFontFromTypefaceAndSize(
const scoped_refptr<render_tree::Typeface>& typeface, float size) {
DCHECK(thread_checker_.CalledOnValidThread());
FontKey font_key(typeface->GetId(), size);
// Check to see if the font is already in the cache. If it is not, then
// create it from the typeface and size and add it to the cache.
FontInfo& cached_font_info = font_map_[font_key];
if (cached_font_info.font == NULL) {
cached_font_info.font = typeface->CreateFontWithSize(size);
}
return cached_font_info.font;
}
scoped_refptr<render_tree::Font> FontCache::TryGetFont(
const std::string& family, render_tree::FontStyle style, float size,
FontListFont::State* state) {
DCHECK(thread_checker_.CalledOnValidThread());
FontFaceMap::iterator font_face_map_iterator = font_face_map_->find(family);
if (font_face_map_iterator != font_face_map_->end()) {
// Retrieve the font face style set entry that most closely matches the
// desired style. Given that a font face was found for this family, it
// should never be NULL.
// https://www.w3.org/TR/css3-fonts/#font-prop-desc
const FontFaceStyleSet::Entry* style_set_entry =
font_face_map_iterator->second.MatchStyle(style);
DCHECK(style_set_entry != NULL);
// Walk the entry's sources:
// - If a remote source is encountered, always return the results of its
// attempted retrieval, regardless of its success.
// - If a local source is encountered, only return the local font if it is
// successfully retrieved. In the case where the font is not locally
// available, the next font in the source list should be attempted
// instead.
// https://www.w3.org/TR/css3-fonts/#src-desc
for (FontFaceSources::const_iterator source_iterator =
style_set_entry->sources.begin();
source_iterator != style_set_entry->sources.end(); ++source_iterator) {
if (source_iterator->IsUrlSource()) {
return TryGetRemoteFont(source_iterator->GetUrl(), size, state);
} else {
scoped_refptr<render_tree::Font> font =
TryGetLocalFontByFaceName(source_iterator->GetName(), size, state);
if (font != NULL) {
return font;
}
}
}
*state = FontListFont::kUnavailableState;
return NULL;
} else {
return TryGetLocalFont(family, style, size, state);
}
}
FontCache::CharacterFallbackTypefaceMap&
FontCache::GetCharacterFallbackTypefaceMap(
const render_tree::FontStyle& style) {
DCHECK(thread_checker_.CalledOnValidThread());
return character_fallback_typeface_maps_[CharacterFallbackKey(style)];
}
const scoped_refptr<render_tree::Typeface>&
FontCache::GetCharacterFallbackTypeface(int32 utf32_character,
const render_tree::FontStyle& style) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(resource_provider());
return GetCachedLocalTypeface(
resource_provider()->GetCharacterFallbackTypeface(utf32_character, style,
language_));
}
scoped_refptr<render_tree::GlyphBuffer> FontCache::CreateGlyphBuffer(
const char16* text_buffer, int32 text_length, bool is_rtl,
FontList* font_list) {
DCHECK(resource_provider());
return resource_provider()->CreateGlyphBuffer(
text_buffer, static_cast<size_t>(text_length), language_, is_rtl,
font_list);
}
float FontCache::GetTextWidth(const char16* text_buffer, int32 text_length,
bool is_rtl, FontList* font_list,
render_tree::FontVector* maybe_used_fonts) {
DCHECK(resource_provider());
return resource_provider()->GetTextWidth(
text_buffer, static_cast<size_t>(text_length), language_, is_rtl,
font_list, maybe_used_fonts);
}
void FontCache::ProcessInactiveFontLists(const base::TimeTicks& current_time) {
for (FontListMap::iterator font_list_iterator = font_list_map_.begin();
font_list_iterator != font_list_map_.end();) {
FontListInfo& font_list_info = font_list_iterator->second;
// Any font list that has a single ref is unreferenced outside of the font
// cache and is no longer active.
if (font_list_info.font_list->HasOneRef()) {
// If there is no inactive time set, then the font list has just become
// inactive, so set the time now.
if (font_list_info.inactive_time.is_null()) {
font_list_info.inactive_time = current_time;
// Otherwise, check to see if the purge delay has been reached.
} else if ((current_time - font_list_info.inactive_time)
.InMilliseconds() >= kInactiveFontListPurgeDelayMs) {
font_list_map_.erase(font_list_iterator++);
continue;
}
// Otherwise, if there's an inactive time set on this font list, clear it.
} else if (!font_list_info.inactive_time.is_null()) {
font_list_info.inactive_time = base::TimeTicks();
}
++font_list_iterator;
}
}
void FontCache::ProcessInactiveFonts(const base::TimeTicks& current_time) {
for (FontMap::iterator font_iterator = font_map_.begin();
font_iterator != font_map_.end();) {
FontInfo& font_info = font_iterator->second;
// Any font that has a single ref is unreferenced outside of the font cache
// and is no longer active.
if (font_info.font->HasOneRef()) {
// If there is no inactive time set, then the font has just become
// inactive, so set the time now and insert it into the inactive font set.
if (font_info.inactive_time.is_null()) {
font_info.inactive_time = current_time;
inactive_font_set_.insert(
InactiveFontKey(font_info.inactive_time, font_iterator->first));
}
// Otherwise, if there's an inactive time set on this font, clear it and
// remove the font from the inactive font set.
} else if (!font_info.inactive_time.is_null()) {
inactive_font_set_.erase(
InactiveFontKey(font_info.inactive_time, font_iterator->first));
font_info.inactive_time = base::TimeTicks();
}
++font_iterator;
}
// Continue looping until the total font count drops to the purge threshold or
// there are no more inactive fonts to purge.
while (font_map_.size() > kTotalFontCountPurgeThreshold &&
inactive_font_set_.size() > 0) {
// Grab the first inactive font in the set. They are ordered by the time
// they became inactive, so the first inactive font in the set is the
// oldest.
InactiveFontSet::iterator inactive_font_iterator =
inactive_font_set_.begin();
// Check to see if the oldest inactive font is old enough to be purged. If
// it is not, simply break out. None of the other inactive fonts will be
// purgeable either.
if ((current_time - inactive_font_iterator->inactive_time)
.InMilliseconds() < kInactiveFontPurgeDelayMs) {
break;
}
// The inactive font is old enough to be purged. Remove it from both the
// font map and the inactive font set.
font_map_.erase(inactive_font_iterator->font_key);
inactive_font_set_.erase(inactive_font_iterator);
}
}
const scoped_refptr<render_tree::Typeface>& FontCache::GetCachedLocalTypeface(
const scoped_refptr<render_tree::Typeface>& typeface) {
DCHECK(typeface);
// Check to see if a typeface with a matching id is already in the cache. If
// it is not, then add the passed in typeface to the cache.
scoped_refptr<render_tree::Typeface>& cached_typeface =
local_typeface_map_[typeface->GetId()];
if (cached_typeface == NULL) {
cached_typeface = typeface;
}
return cached_typeface;
}
scoped_refptr<render_tree::Font> FontCache::TryGetRemoteFont(
const GURL& url, float size, FontListFont::State* state) {
// Retrieve the font from the remote typeface cache, potentially triggering a
// load.
scoped_refptr<loader::font::CachedRemoteTypeface> cached_remote_typeface =
remote_typeface_cache_->CreateCachedResource(url);
RequestedRemoteTypefaceMap::iterator requested_remote_typeface_iterator =
requested_remote_typeface_cache_.find(url);
// If the requested url is not currently cached, then create a cached
// reference and request timer, providing callbacks for when the load is
// completed or the timer expires.
if (requested_remote_typeface_iterator ==
requested_remote_typeface_cache_.end()) {
DLOG(INFO) << "Requested remote font from " << url;
// Create the remote typeface load event's callback. This callback occurs on
// successful loads, failed loads, and when the request's timer expires.
base::Closure typeface_load_event_callback = base::Bind(
&FontCache::OnRemoteTypefaceLoadEvent, base::Unretained(this), url);
// Insert the newly requested remote typeface's info into the cache, and set
// the iterator from the return value of the map insertion.
requested_remote_typeface_iterator =
requested_remote_typeface_cache_
.insert(RequestedRemoteTypefaceMap::value_type(
url, new RequestedRemoteTypefaceInfo(
cached_remote_typeface, typeface_load_event_callback)))
.first;
}
scoped_refptr<render_tree::Typeface> typeface =
cached_remote_typeface->TryGetResource();
if (typeface != NULL) {
*state = FontListFont::kLoadedState;
return GetFontFromTypefaceAndSize(typeface, size);
} else {
if (cached_remote_typeface->IsLoading()) {
if (requested_remote_typeface_iterator->second->HasActiveRequestTimer()) {
*state = FontListFont::kLoadingWithTimerActiveState;
} else {
*state = FontListFont::kLoadingWithTimerExpiredState;
}
} else {
*state = FontListFont::kUnavailableState;
}
return NULL;
}
}
scoped_refptr<render_tree::Font> FontCache::TryGetLocalFont(
const std::string& family, render_tree::FontStyle style, float size,
FontListFont::State* state) {
DCHECK(resource_provider());
DCHECK(resource_provider() != NULL);
// Only request the local font from the resource provider if the family is
// empty or the resource provider actually has the family. The reason for this
// is that the resource provider's |GetLocalTypeface()| is guaranteed to
// return a non-NULL value, and in the case where a family is not supported,
// the subsequent fonts in the font list need to be attempted. An empty family
// signifies using the default font.
if (!family.empty() &&
!resource_provider()->HasLocalFontFamily(family.c_str())) {
*state = FontListFont::kUnavailableState;
return NULL;
} else {
*state = FontListFont::kLoadedState;
return GetFontFromTypefaceAndSize(
GetCachedLocalTypeface(
resource_provider()->GetLocalTypeface(family.c_str(), style)),
size);
}
}
scoped_refptr<render_tree::Font> FontCache::TryGetLocalFontByFaceName(
const std::string& font_face, float size, FontListFont::State* state) {
do {
if (font_face.empty()) {
break;
}
const scoped_refptr<render_tree::Typeface>& typeface(
resource_provider()->GetLocalTypefaceByFaceNameIfAvailable(font_face));
if (!typeface) {
break;
}
const scoped_refptr<render_tree::Typeface>& typeface_cached(
GetCachedLocalTypeface(typeface));
*state = FontListFont::kLoadedState;
return GetFontFromTypefaceAndSize(typeface_cached, size);
} while (false);
*state = FontListFont::kUnavailableState;
return NULL;
}
void FontCache::OnRemoteTypefaceLoadEvent(const GURL& url) {
DCHECK(thread_checker_.CalledOnValidThread());
RequestedRemoteTypefaceMap::iterator requested_remote_typeface_iterator =
requested_remote_typeface_cache_.find(url);
if (requested_remote_typeface_iterator !=
requested_remote_typeface_cache_.end()) {
// NOTE: We can potentially track the exact font list fonts that are
// impacted by each load event and only reset them. However, as a result of
// the minimal amount of processing required to update the loading status of
// a font, the small number of fonts involved, and the fact that this is an
// infrequent event, adding this additional layer of tracking complexity
// doesn't appear to offer any meaningful benefits.
for (FontListMap::iterator font_list_iterator = font_list_map_.begin();
font_list_iterator != font_list_map_.end(); ++font_list_iterator) {
FontListInfo& font_list_info = font_list_iterator->second;
font_list_info.font_list->ResetLoadingFonts();
}
// Clear the request timer. It only runs until the first load event occurs.
requested_remote_typeface_iterator->second->ClearRequestTimer();
external_typeface_load_event_callback_.Run();
}
}
} // namespace dom
} // namespace cobalt