SkString SkStringFromUTF16(const uint16_t* src, size_t count) {
SkString ret;
const uint16_t* stop = src + count;
if (count > 0) {
SkASSERT(src);
size_t n = 0;
const uint16_t* end = src + count;
for (const uint16_t* ptr = src; ptr < end;) {
const uint16_t* last = ptr;
SkUnichar u = SkUTF::NextUTF16(&ptr, stop);
size_t s = SkUTF::ToUTF8(u);
if (n > UINT32_MAX - s) {
end = last; // truncate input string
break;
}
n += s;
}
ret = SkString(n);
char* out = ret.writable_str();
for (const uint16_t* ptr = src; ptr < end;) {
out += SkUTF::ToUTF8(SkUTF::NextUTF16(&ptr, stop), out);
}
SkASSERT(out == ret.writable_str() + n);
}
return ret;
}
SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
load_system_fonts();
int style = stream->readU8();
int len = stream->readPackedUInt();
if (len > 0) {
SkString str;
str.resize(len);
stream->read(str.writable_str(), len);
const FontInitRec* rec = gSystemFonts;
for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) {
if (strcmp(rec[i].fFileName, str.c_str()) == 0) {
// backup until we hit the fNames
for (int j = i; j >= 0; --j) {
if (rec[j].fNames != NULL) {
return SkFontHost::CreateTypeface(NULL,
rec[j].fNames[0], (SkTypeface::Style)style);
}
}
}
}
}
return NULL;
}
bool SkCLImageDiffer::loadKernelStream(SkStream* stream, const char name[], cl_kernel* kernel) {
// Read the kernel source into memory
SkString sourceString;
sourceString.resize(stream->getLength());
size_t bytesRead = stream->read(sourceString.writable_str(), sourceString.size());
if (bytesRead != sourceString.size()) {
SkDebugf("Failed to read kernel source file");
return false;
}
return loadKernelSource(sourceString.c_str(), name, kernel);
}
void SkXMLWriter::addAttributeLen(const char name[], const char value[], size_t length) {
SkString valueStr;
if (fDoEscapeMarkup) {
size_t extra = escape_markup(nullptr, value, length);
if (extra) {
valueStr.resize(length + extra);
(void)escape_markup(valueStr.writable_str(), value, length);
value = valueStr.c_str();
length += extra;
}
}
this->onAddAttributeLen(name, value, length);
}
static SkTypeface* deserializeLocked(SkStream* stream) {
loadSystemFontsLocked();
// check if the font is a custom or system font
bool isCustomFont = stream->readBool();
if (isCustomFont) {
// read the length of the custom font from the stream
uint32_t len = stream->readU32();
// generate a new stream to store the custom typeface
SkMemoryStream* fontStream = new SkMemoryStream(len);
stream->read((void*)fontStream->getMemoryBase(), len);
SkTypeface* face = createTypefaceFromStreamLocked(fontStream);
fontStream->unref();
// SkDebugf("--- fonthost custom deserialize %d %d\n", face->style(), len);
return face;
} else {
int style = stream->readU8();
int len = stream->readPackedUInt();
if (len > 0) {
SkString str;
str.resize(len);
stream->read(str.writable_str(), len);
// Embedded fonts.
for (int i = 0; i < gSystemFonts.count(); i++) {
SkString fullpath;
getFullPathForSysFonts( &fullpath, gSystemFonts[i].fFileName );
const char * name = fullpath.c_str();
if (strcmp(name, str.c_str()) == 0) {
// backup until we hit the fNames
for (int j = i; j >= 0; --j) {
if (gSystemFonts[j].fNames != NULL) {
return createTypefaceLocked(NULL,
gSystemFonts[j].fNames[0], NULL, 0,
(SkTypeface::Style)style);
}
}
}
}
// Download fonts.
SkFontManager * fmg = getInstance();
uint32_t numAllFonts = fmg->getFamilyCount();
uint32_t numEmbeddedFonts = fmg->getEmbeddedFamilyCount();
for (int i = numEmbeddedFonts; i < numAllFonts; i++) {
SkFontData * font = fmg->getFont( i );
const char * name = font->getFontFullPath();
if (strcmp(name, str.c_str()) == 0) {
// backup until we hit the fNames
return createTypefaceLocked(NULL,
font->getWebFaceName(), NULL, 0,
(SkTypeface::Style)style);
}
}
}
}
return NULL;
}