1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "gfxDWriteCommon.h"
#include <unordered_map>
#include "mozilla/Atomics.h"
#include "mozilla/StaticMutex.h"
#include "mozilla/gfx/Logging.h"
class gfxDWriteFontFileStream;
static mozilla::StaticMutex sFontFileStreamsMutex;
static uint64_t sNextFontFileKey = 0;
static std::unordered_map<uint64_t, gfxDWriteFontFileStream*> sFontFileStreams;
IDWriteFontFileLoader* gfxDWriteFontFileLoader::mInstance = nullptr;
class gfxDWriteFontFileStream final : public IDWriteFontFileStream {
public:
/**
* Used by the FontFileLoader to create a new font stream,
* this font stream is created from data in memory. The memory
* passed may be released after object creation, it will be
* copied internally.
*
* @param aData Font data
*/
gfxDWriteFontFileStream(const uint8_t* aData, uint32_t aLength,
uint64_t aFontFileKey);
~gfxDWriteFontFileStream();
// IUnknown interface
IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject) {
if (iid == __uuidof(IDWriteFontFileStream)) {
*ppObject = static_cast<IDWriteFontFileStream*>(this);
return S_OK;
} else if (iid == __uuidof(IUnknown)) {
*ppObject = static_cast<IUnknown*>(this);
return S_OK;
} else {
return E_NOINTERFACE;
}
}
IFACEMETHOD_(ULONG, AddRef)() {
MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
return ++mRefCnt;
}
IFACEMETHOD_(ULONG, Release)() {
MOZ_ASSERT(0 != mRefCnt, "dup release");
uint32_t count = --mRefCnt;
if (count == 0) {
// Avoid locking unless necessary. Verify the refcount hasn't changed
// while locked. Delete within the scope of the lock when zero.
mozilla::StaticMutexAutoLock lock(sFontFileStreamsMutex);
if (0 != mRefCnt) {
return mRefCnt;
}
delete this;
}
return count;
}
// IDWriteFontFileStream methods
virtual HRESULT STDMETHODCALLTYPE
ReadFileFragment(void const** fragmentStart, UINT64 fileOffset,
UINT64 fragmentSize, OUT void** fragmentContext);
virtual void STDMETHODCALLTYPE ReleaseFileFragment(void* fragmentContext);
virtual HRESULT STDMETHODCALLTYPE GetFileSize(OUT UINT64* fileSize);
virtual HRESULT STDMETHODCALLTYPE GetLastWriteTime(OUT UINT64* lastWriteTime);
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
return mData.ShallowSizeOfExcludingThis(mallocSizeOf);
}
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
}
private:
FallibleTArray<uint8_t> mData;
mozilla::Atomic<uint32_t> mRefCnt;
uint64_t mFontFileKey;
};
gfxDWriteFontFileStream::gfxDWriteFontFileStream(const uint8_t* aData,
uint32_t aLength,
uint64_t aFontFileKey)
: mFontFileKey(aFontFileKey) {
// If this fails, mData will remain empty. That's OK: GetFileSize()
// will then return 0, etc., and the font just won't load.
if (!mData.AppendElements(aData, aLength, mozilla::fallible_t())) {
NS_WARNING("Failed to store data in gfxDWriteFontFileStream");
}
}
gfxDWriteFontFileStream::~gfxDWriteFontFileStream() {
sFontFileStreams.erase(mFontFileKey);
}
HRESULT STDMETHODCALLTYPE
gfxDWriteFontFileStream::GetFileSize(UINT64* fileSize) {
*fileSize = mData.Length();
return S_OK;
}
HRESULT STDMETHODCALLTYPE
gfxDWriteFontFileStream::GetLastWriteTime(UINT64* lastWriteTime) {
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE gfxDWriteFontFileStream::ReadFileFragment(
const void** fragmentStart, UINT64 fileOffset, UINT64 fragmentSize,
void** fragmentContext) {
// We are required to do bounds checking.
if (fileOffset + fragmentSize > (UINT64)mData.Length()) {
return E_FAIL;
}
// We should be alive for the duration of this.
*fragmentStart = &mData[fileOffset];
*fragmentContext = nullptr;
return S_OK;
}
void STDMETHODCALLTYPE
gfxDWriteFontFileStream::ReleaseFileFragment(void* fragmentContext) {}
HRESULT STDMETHODCALLTYPE gfxDWriteFontFileLoader::CreateStreamFromKey(
const void* fontFileReferenceKey, UINT32 fontFileReferenceKeySize,
IDWriteFontFileStream** fontFileStream) {
if (!fontFileReferenceKey || !fontFileStream) {
return E_POINTER;
}
mozilla::StaticMutexAutoLock lock(sFontFileStreamsMutex);
uint64_t fontFileKey = *static_cast<const uint64_t*>(fontFileReferenceKey);
auto found = sFontFileStreams.find(fontFileKey);
if (found == sFontFileStreams.end()) {
*fontFileStream = nullptr;
return E_FAIL;
}
found->second->AddRef();
*fontFileStream = found->second;
return S_OK;
}
/* static */
HRESULT
gfxDWriteFontFileLoader::CreateCustomFontFile(
const uint8_t* aFontData, uint32_t aLength, IDWriteFontFile** aFontFile,
IDWriteFontFileStream** aFontFileStream) {
MOZ_ASSERT(aFontFile);
MOZ_ASSERT(aFontFileStream);
RefPtr<IDWriteFactory> factory = mozilla::gfx::Factory::GetDWriteFactory();
if (!factory) {
gfxCriticalError()
<< "Failed to get DWrite Factory in CreateCustomFontFile.";
return E_FAIL;
}
sFontFileStreamsMutex.Lock();
uint64_t fontFileKey = sNextFontFileKey++;
RefPtr<gfxDWriteFontFileStream> ffsRef =
new gfxDWriteFontFileStream(aFontData, aLength, fontFileKey);
sFontFileStreams[fontFileKey] = ffsRef;
sFontFileStreamsMutex.Unlock();
RefPtr<IDWriteFontFile> fontFile;
HRESULT hr = factory->CreateCustomFontFileReference(
&fontFileKey, sizeof(fontFileKey), Instance(), getter_AddRefs(fontFile));
if (FAILED(hr)) {
NS_WARNING("Failed to load font file from data!");
return hr;
}
fontFile.forget(aFontFile);
ffsRef.forget(aFontFileStream);
return S_OK;
}
size_t gfxDWriteFontFileLoader::SizeOfIncludingThis(
mozilla::MallocSizeOf mallocSizeOf) const {
size_t sizes = mallocSizeOf(this);
// We are a singleton type that is effective owner of sFontFileStreams.
MOZ_ASSERT(this == mInstance);
for (const auto& entry : sFontFileStreams) {
gfxDWriteFontFileStream* fileStream = entry.second;
sizes += fileStream->SizeOfIncludingThis(mallocSizeOf);
}
return sizes;
}
|
