| // Copyright (c) 2012 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 "content/common/font_config_ipc_linux.h" |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <stdint.h> |
| #include <sys/mman.h> |
| #include <sys/socket.h> |
| #include <sys/stat.h> |
| #include <sys/uio.h> |
| #include <unistd.h> |
| |
| #include "base/files/file_util.h" |
| #include "base/files/memory_mapped_file.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/pickle.h" |
| #include "base/posix/unix_domain_socket_linux.h" |
| #include "base/threading/thread_restrictions.h" |
| #include "base/trace_event/trace_event.h" |
| #include "skia/ext/refptr.h" |
| #include "skia/ext/skia_utils_base.h" |
| #include "third_party/skia/include/core/SkData.h" |
| #include "third_party/skia/include/core/SkStream.h" |
| #include "third_party/skia/include/core/SkTypeface.h" |
| |
| |
| namespace BASE_HASH_NAMESPACE { |
| |
| std::size_t hash<SkFontConfigInterface::FontIdentity>::operator()( |
| const SkFontConfigInterface::FontIdentity& sp) const { |
| hash<std::string> stringhash; |
| hash<int> inthash; |
| size_t r = inthash(sp.fID); |
| r = r * 41 + inthash(sp.fTTCIndex); |
| r = r * 41 + stringhash(sp.fString.c_str()); |
| r = r * 41 + inthash(sp.fStyle.weight()); |
| r = r * 41 + inthash(sp.fStyle.slant()); |
| r = r * 41 + inthash(sp.fStyle.width()); |
| return r; |
| } |
| |
| } // namespace BASE_HASH_NAMESPACE |
| |
| namespace content { |
| |
| // Wikpedia's main country selection page activates 21 fallback fonts, |
| // doubling this we should be on the generous side as an upper bound, |
| // but nevertheless not have the mapped typefaces cache grow excessively. |
| const size_t kMaxMappedTypefaces = 42; |
| |
| void CloseFD(int fd) { |
| int err = IGNORE_EINTR(close(fd)); |
| DCHECK(!err); |
| } |
| |
| FontConfigIPC::FontConfigIPC(int fd) |
| : fd_(fd) |
| , mapped_typefaces_(kMaxMappedTypefaces) { |
| } |
| |
| FontConfigIPC::~FontConfigIPC() { |
| CloseFD(fd_); |
| } |
| |
| bool FontConfigIPC::matchFamilyName(const char familyName[], |
| SkTypeface::Style requestedStyle, |
| FontIdentity* outFontIdentity, |
| SkString* outFamilyName, |
| SkTypeface::Style* outStyle) { |
| TRACE_EVENT0("sandbox_ipc", "FontConfigIPC::matchFamilyName"); |
| size_t familyNameLen = familyName ? strlen(familyName) : 0; |
| if (familyNameLen > kMaxFontFamilyLength) |
| return false; |
| |
| base::Pickle request; |
| request.WriteInt(METHOD_MATCH); |
| request.WriteData(familyName, familyNameLen); |
| request.WriteUInt32(requestedStyle); |
| |
| uint8_t reply_buf[2048]; |
| const ssize_t r = base::UnixDomainSocket::SendRecvMsg( |
| fd_, reply_buf, sizeof(reply_buf), NULL, request); |
| if (r == -1) |
| return false; |
| |
| base::Pickle reply(reinterpret_cast<char*>(reply_buf), r); |
| base::PickleIterator iter(reply); |
| bool result; |
| if (!iter.ReadBool(&result)) |
| return false; |
| if (!result) |
| return false; |
| |
| SkString reply_family; |
| FontIdentity reply_identity; |
| uint32_t reply_style; |
| if (!skia::ReadSkString(&iter, &reply_family) || |
| !skia::ReadSkFontIdentity(&iter, &reply_identity) || |
| !iter.ReadUInt32(&reply_style)) { |
| return false; |
| } |
| |
| if (outFontIdentity) |
| *outFontIdentity = reply_identity; |
| if (outFamilyName) |
| *outFamilyName = reply_family; |
| if (outStyle) |
| *outStyle = static_cast<SkTypeface::Style>(reply_style); |
| |
| return true; |
| } |
| |
| static void DestroyMemoryMappedFile(const void*, void* context) { |
| base::ThreadRestrictions::ScopedAllowIO allow_munmap; |
| delete static_cast<base::MemoryMappedFile*>(context); |
| } |
| |
| SkMemoryStream* FontConfigIPC::mapFileDescriptorToStream(int fd) { |
| scoped_ptr<base::MemoryMappedFile> mapped_font_file( |
| new base::MemoryMappedFile); |
| base::ThreadRestrictions::ScopedAllowIO allow_mmap; |
| mapped_font_file->Initialize(base::File(fd)); |
| DCHECK(mapped_font_file->IsValid()); |
| |
| auto data = skia::AdoptRef( |
| SkData::NewWithProc(mapped_font_file->data(), mapped_font_file->length(), |
| &DestroyMemoryMappedFile, mapped_font_file.get())); |
| if (!data) |
| return nullptr; |
| ignore_result(mapped_font_file.release()); // Ownership transferred to SkDataB |
| return new SkMemoryStream(data.get()); |
| } |
| |
| SkStreamAsset* FontConfigIPC::openStream(const FontIdentity& identity) { |
| TRACE_EVENT0("sandbox_ipc", "FontConfigIPC::openStream"); |
| |
| base::Pickle request; |
| request.WriteInt(METHOD_OPEN); |
| request.WriteUInt32(identity.fID); |
| |
| int result_fd = -1; |
| uint8_t reply_buf[256]; |
| const ssize_t r = base::UnixDomainSocket::SendRecvMsg( |
| fd_, reply_buf, sizeof(reply_buf), &result_fd, request); |
| if (r == -1) |
| return NULL; |
| |
| base::Pickle reply(reinterpret_cast<char*>(reply_buf), r); |
| bool result; |
| base::PickleIterator iter(reply); |
| if (!iter.ReadBool(&result) || !result) { |
| if (result_fd) |
| CloseFD(result_fd); |
| return NULL; |
| } |
| |
| return mapFileDescriptorToStream(result_fd); |
| } |
| |
| SkTypeface* FontConfigIPC::createTypeface( |
| const SkFontConfigInterface::FontIdentity& identity) { |
| base::AutoLock lock(lock_); |
| auto mapped_typefaces_it = mapped_typefaces_.Get(identity); |
| if (mapped_typefaces_it != mapped_typefaces_.end()) |
| return SkSafeRef(mapped_typefaces_it->second.get()); |
| |
| SkStreamAsset* typeface_stream = openStream(identity); |
| if (!typeface_stream) |
| return nullptr; |
| skia::RefPtr<SkTypeface> typeface_from_stream = skia::AdoptRef( |
| SkTypeface::CreateFromStream(typeface_stream, identity.fTTCIndex)); |
| auto mapped_typefaces_insert_it = |
| mapped_typefaces_.Put(identity, typeface_from_stream); |
| return SkSafeRef(mapped_typefaces_insert_it->second.get()); |
| } |
| |
| } // namespace content |