static void serialize_and_compare_typeface(sk_sp<SkTypeface> typeface, const char* text,
skiatest::Reporter* reporter)
{
// Create a paint with the typeface.
SkPaint paint;
paint.setColor(SK_ColorGRAY);
paint.setTextSize(SkIntToScalar(30));
paint.setTypeface(std::move(typeface));
// Paint some text.
SkPictureRecorder recorder;
SkIRect canvasRect = SkIRect::MakeWH(kBitmapSize, kBitmapSize);
SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(canvasRect.width()),
SkIntToScalar(canvasRect.height()),
nullptr, 0);
canvas->drawColor(SK_ColorWHITE);
canvas->drawText(text, 2, 24, 32, paint);
sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
// Serlialize picture and create its clone from stream.
SkDynamicMemoryWStream stream;
picture->serialize(&stream);
std::unique_ptr<SkStream> inputStream(stream.detachAsStream());
sk_sp<SkPicture> loadedPicture(SkPicture::MakeFromStream(inputStream.get()));
// Draw both original and clone picture and compare bitmaps -- they should be identical.
SkBitmap origBitmap = draw_picture(*picture);
SkBitmap destBitmap = draw_picture(*loadedPicture);
compare_bitmaps(reporter, origBitmap, destBitmap);
}
static SkString emit_to_string(T& obj) {
SkDynamicMemoryWStream buffer;
obj.emitObject(&buffer);
SkString tmp(buffer.bytesWritten());
buffer.copyTo(tmp.writable_str());
return tmp;
}
SkData* Request::getJsonBatchList(int n) {
SkCanvas* canvas = this->getCanvas();
SkASSERT(fGPUEnabled);
// TODO if this is inefficient we could add a method to GrAuditTrail which takes
// a Json::Value and is only compiled in this file
Json::Value parsedFromString;
#if SK_SUPPORT_GPU
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
SkASSERT(rt);
GrContext* ctx = rt->getContext();
SkASSERT(ctx);
GrAuditTrail* at = ctx->getAuditTrail();
GrAuditTrail::AutoManageBatchList enable(at);
fDebugCanvas->drawTo(canvas, n);
Json::Reader reader;
SkDEBUGCODE(bool parsingSuccessful = )reader.parse(at->toJson(true).c_str(),
parsedFromString);
SkASSERT(parsingSuccessful);
#endif
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(parsedFromString).c_str());
return stream.copyToData();
}
void SkPDFStream::emitObject(SkWStream* stream,
const SkPDFObjNumMap& objNumMap,
const SkPDFSubstituteMap& substitutes) {
if (fState == kUnused_State) {
fState = kNoCompression_State;
SkDynamicMemoryWStream compressedData;
SkAssertResult(
SkFlate::Deflate(fDataStream.get(), &compressedData));
SkAssertResult(fDataStream->rewind());
if (compressedData.getOffset() < this->dataSize()) {
SkAutoTDelete<SkStream> compressed(
compressedData.detachAsStream());
this->setData(compressed.get());
this->insertName("Filter", "FlateDecode");
}
fState = kCompressed_State;
this->insertInt("Length", this->dataSize());
}
this->INHERITED::emitObject(stream, objNumMap, substitutes);
stream->writeText(" stream\n");
stream->writeStream(fDataStream.get(), fDataStream->getLength());
SkAssertResult(fDataStream->rewind());
stream->writeText("\nendstream");
}
int DownloadHandler::handle(Request* request, MHD_Connection* connection,
const char* url, const char* method,
const char* upload_data, size_t* upload_data_size) {
if (!request->hasPicture()) {
return MHD_NO;
}
// TODO move to a function
// Playback into picture recorder
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(Request::kImageWidth,
Request::kImageHeight);
request->fDebugCanvas->draw(canvas);
SkAutoTUnref<SkPicture> picture(recorder.endRecording());
SkDynamicMemoryWStream outStream;
SkAutoTUnref<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
picture->serialize(&outStream, serializer);
SkAutoTUnref<SkData> data(outStream.copyToData());
// TODO fancier name handling
return SendData(connection, data, "application/octet-stream", true,
"attachment; filename=something.skp;");
}
bool SkPdfNativeObject::applyFlateDecodeFilter() {
if (!SkFlate::HaveFlate()) {
SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNoFlateLibrary_SkPdfIssue,
"forgot to link with flate library?", NULL, NULL);
return false;
}
const unsigned char* old = fStr.fBuffer;
bool deleteOld = isStreamOwned();
SkMemoryStream skstream(fStr.fBuffer, fStr.fBytes >> 2, false);
SkDynamicMemoryWStream uncompressedData;
if (SkFlate::Inflate(&skstream, &uncompressedData)) {
fStr.fBytes = (uncompressedData.bytesWritten() << 2) + kOwnedStreamBit +
kUnfilteredStreamBit;
fStr.fBuffer = (const unsigned char*)new unsigned char[uncompressedData.bytesWritten()];
uncompressedData.copyTo((void*)fStr.fBuffer);
if (deleteOld) {
delete[] old;
}
return true;
} else {
SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kBadStream_SkPdfIssue, "inflate failed", this, NULL);
return false;
}
}
// Test that image encoding failures do not break picture serialization/deserialization.
DEF_TEST(Image_Serialize_Encoding_Failure, reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
surface->getCanvas()->clear(SK_ColorGREEN);
SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
REPORTER_ASSERT(reporter, image);
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(100, 100);
canvas->drawImage(image, 0, 0);
SkAutoTUnref<SkPicture> picture(recorder.endRecording());
REPORTER_ASSERT(reporter, picture);
REPORTER_ASSERT(reporter, picture->approximateOpCount() > 0);
MockSerializer emptySerializer([]() -> SkData* { return SkData::NewEmpty(); });
MockSerializer nullSerializer([]() -> SkData* { return nullptr; });
MockSerializer* serializers[] = { &emptySerializer, &nullSerializer };
for (size_t i = 0; i < SK_ARRAY_COUNT(serializers); ++i) {
SkDynamicMemoryWStream wstream;
REPORTER_ASSERT(reporter, !serializers[i]->didEncode());
picture->serialize(&wstream, serializers[i]);
REPORTER_ASSERT(reporter, serializers[i]->didEncode());
SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rstream));
REPORTER_ASSERT(reporter, deserialized);
REPORTER_ASSERT(reporter, deserialized->approximateOpCount() > 0);
}
}
/**
* Test that for Jpeg files that use the JFIF colorspace, they are
* directly embedded into the PDF (without re-encoding) when that
* makes sense.
*/
DEF_TEST(PDFJpegEmbedTest, r) {
const char test[] = "PDFJpegEmbedTest";
SkAutoTUnref<SkData> mandrillData(
load_resource(r, test, "mandrill_512_q075.jpg"));
SkAutoTUnref<SkData> cmykData(load_resource(r, test, "CMYK.jpg"));
if (!mandrillData || !cmykData) {
return;
}
SkDynamicMemoryWStream pdf;
SkAutoTUnref<SkDocument> document(SkDocument::CreatePDF(&pdf));
SkCanvas* canvas = document->beginPage(642, 1028);
canvas->clear(SK_ColorLTGRAY);
SkBitmap bm1(bitmap_from_data(mandrillData));
canvas->drawBitmap(bm1, 65.0, 0.0, NULL);
SkBitmap bm2(bitmap_from_data(cmykData));
canvas->drawBitmap(bm2, 0.0, 512.0, NULL);
canvas->flush();
document->endPage();
document->close();
SkAutoTUnref<SkData> pdfData(pdf.copyToData());
SkASSERT(pdfData);
pdf.reset();
REPORTER_ASSERT(r, is_subset_of(mandrillData, pdfData));
// This JPEG uses a nonstandard colorspace - it can not be
// embedded into the PDF directly.
REPORTER_ASSERT(r, !is_subset_of(cmykData, pdfData));
}
static SkData* create_data_from_bitmap(const SkBitmap& bm) {
SkDynamicMemoryWStream stream;
if (SkImageEncoder::EncodeStream(&stream, bm, SkImageEncoder::kPNG_Type, 100)) {
return stream.copyToData();
}
return NULL;
}
DEF_TEST(SkPDF_unicode_metadata, r) {
REQUIRE_PDF_DOCUMENT(SkPDF_unicode_metadata, r);
SkPDF::Metadata pdfMetadata;
pdfMetadata.fTitle = "𝓐𝓑𝓒𝓓𝓔 𝓕𝓖𝓗𝓘𝓙"; // Out of basic multilingual plane
pdfMetadata.fAuthor = "ABCDE FGHIJ"; // ASCII
pdfMetadata.fSubject = "αβγδε ζηθικ"; // inside basic multilingual plane
pdfMetadata.fPDFA = true;
SkDynamicMemoryWStream wStream;
{
auto doc = SkPDF::MakeDocument(&wStream, pdfMetadata);
doc->beginPage(612, 792)->drawColor(SK_ColorCYAN);
}
sk_sp<SkData> data(wStream.detachAsData());
static const char* expectations[] = {
"<</Title <FEFFD835DCD0D835DCD1D835DCD2D835DCD3D835DCD40020"
"D835DCD5D835DCD6D835DCD7D835DCD8D835DCD9>",
"/Author (ABCDE FGHIJ)",
"Subject <FEFF03B103B203B303B403B5002003B603B703B803B903BA>",
};
for (const char* expectation : expectations) {
if (!contains(data->bytes(), data->size(), expectation)) {
ERRORF(r, "PDF expectation missing: '%s'.", expectation);
}
}
}
static void TestSubstitute(skiatest::Reporter* reporter) {
SkAutoTUnref<SkPDFTestDict> proxy(new SkPDFTestDict());
SkAutoTUnref<SkPDFTestDict> stub(new SkPDFTestDict());
SkAutoTUnref<SkPDFInt> int33(new SkPDFInt(33));
SkAutoTUnref<SkPDFDict> stubResource(new SkPDFDict());
SkAutoTUnref<SkPDFInt> int44(new SkPDFInt(44));
stub->insert("Value", int33.get());
stubResource->insert("InnerValue", int44.get());
stub->addResource(stubResource.get());
SkPDFCatalog catalog((SkPDFDocument::Flags)0);
catalog.addObject(proxy.get(), false);
catalog.setSubstitute(proxy.get(), stub.get());
SkDynamicMemoryWStream buffer;
proxy->emit(&buffer, &catalog, false);
catalog.emitSubstituteResources(&buffer, false);
char objectResult[] = "2 0 obj\n<</Value 33\n>>\nendobj\n";
REPORTER_ASSERT(
reporter,
catalog.setFileOffset(proxy.get(), 0) == strlen(objectResult));
char expectedResult[] =
"<</Value 33\n>>1 0 obj\n<</InnerValue 44\n>>\nendobj\n";
REPORTER_ASSERT(reporter, buffer.getOffset() == strlen(expectedResult));
REPORTER_ASSERT(reporter, stream_equals(buffer, 0, expectedResult,
buffer.getOffset()));
}
void draw(SkCanvas*) {
constexpr SkSize ansiLetterSize{8.5f * 72, 11.0f * 72};
SkDynamicMemoryWStream buffer;
WritePDF(&buffer, "SkPDF Example", &write_page, 1, ansiLetterSize);
sk_sp<SkData> pdfData = buffer.detachAsData();
print_data(pdfData.get(), "skpdf_example.pdf");
}
void SkParsePath::ToSVGString(const SkPath& path, SkString* str) {
SkDynamicMemoryWStream stream;
SkPath::Iter iter(path, false);
SkPoint pts[4];
for (;;) {
switch (iter.next(pts, false)) {
case SkPath::kMove_Verb:
append_scalars(&stream, 'M', &pts[0].fX, 2);
break;
case SkPath::kLine_Verb:
append_scalars(&stream, 'L', &pts[1].fX, 2);
break;
case SkPath::kQuad_Verb:
append_scalars(&stream, 'Q', &pts[1].fX, 4);
break;
case SkPath::kCubic_Verb:
append_scalars(&stream, 'C', &pts[1].fX, 6);
break;
case SkPath::kClose_Verb:
stream.write("Z", 1);
break;
case SkPath::kDone_Verb:
str->resize(stream.getOffset());
stream.copyTo(str->writable_str());
return;
}
}
}
DEF_TEST(StreamPeek_BlockMemoryStream, rep) {
const static int kSeed = 1234;
SkRandom valueSource(kSeed);
SkRandom rand(kSeed << 1);
uint8_t buffer[4096];
SkDynamicMemoryWStream dynamicMemoryWStream;
for (int i = 0; i < 32; ++i) {
// Randomize the length of the blocks.
size_t size = rand.nextRangeU(1, sizeof(buffer));
for (size_t j = 0; j < size; ++j) {
buffer[j] = valueSource.nextU() & 0xFF;
}
dynamicMemoryWStream.write(buffer, size);
}
SkAutoTDelete<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
SkAutoTUnref<SkData> expected(SkData::NewUninitialized(asset->getLength()));
uint8_t* expectedPtr = static_cast<uint8_t*>(expected->writable_data());
valueSource.setSeed(kSeed); // reseed.
// We want the exact same same "random" string of numbers to put
// in expected. i.e.: don't rely on SkDynamicMemoryStream to work
// correctly while we are testing SkDynamicMemoryStream.
for (size_t i = 0; i < asset->getLength(); ++i) {
expectedPtr[i] = valueSource.nextU() & 0xFF;
}
stream_peek_test(rep, asset, expected);
}
static void TestPackedUInt(skiatest::Reporter* reporter) {
// we know that packeduint tries to write 1, 2 or 4 bytes for the length,
// so we test values around each of those transitions (and a few others)
const size_t sizes[] = {
0, 1, 2, 0xFC, 0xFD, 0xFE, 0xFF, 0x100, 0x101, 32767, 32768, 32769,
0xFFFD, 0xFFFE, 0xFFFF, 0x10000, 0x10001,
0xFFFFFD, 0xFFFFFE, 0xFFFFFF, 0x1000000, 0x1000001,
0x7FFFFFFE, 0x7FFFFFFF, 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF
};
size_t i;
SkDynamicMemoryWStream wstream;
for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
bool success = wstream.writePackedUInt(sizes[i]);
REPORTER_ASSERT(reporter, success);
}
std::unique_ptr<SkStreamAsset> rstream(wstream.detachAsStream());
for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
size_t n;
if (!rstream->readPackedUInt(&n)) {
ERRORF(reporter, "[%d] sizes:%x could not be read\n", i, sizes[i]);
}
if (sizes[i] != n) {
ERRORF(reporter, "[%d] sizes:%x != n:%x\n", i, sizes[i], n);
}
}
}
static void test_bitmap_with_encoded_data(skiatest::Reporter* reporter) {
// Create a bitmap that will be encoded.
SkBitmap original;
make_bm(&original, 100, 100, SK_ColorBLUE, true);
SkDynamicMemoryWStream wStream;
if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
return;
}
SkAutoDataUnref data(wStream.copyToData());
SkBitmap bm;
bool installSuccess = SkDecodingImageGenerator::Install(data, &bm);
REPORTER_ASSERT(reporter, installSuccess);
// Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
// Flattening original will follow the old path of performing an encode, while flattening bm
// will use the already encoded data.
SkAutoDataUnref picture1(serialized_picture_from_bitmap(original));
SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
REPORTER_ASSERT(reporter, picture1->equals(picture2));
// Now test that a parse error was generated when trying to create a new SkPicture without
// providing a function to decode the bitmap.
ErrorContext context;
context.fErrors = 0;
context.fReporter = reporter;
SkSetErrorCallback(assert_one_parse_error_cb, &context);
SkMemoryStream pictureStream(picture1);
SkClearLastError();
SkAutoUnref pictureFromStream(SkPicture::CreateFromStream(&pictureStream, NULL));
REPORTER_ASSERT(reporter, pictureFromStream.get() != NULL);
SkClearLastError();
SkSetErrorCallback(NULL, NULL);
}
static void TestWStream(skiatest::Reporter* reporter) {
SkDynamicMemoryWStream ds;
const char s[] = "abcdefghijklmnopqrstuvwxyz";
int i;
for (i = 0; i < 100; i++) {
REPORTER_ASSERT(reporter, ds.write(s, 26));
}
REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);
char* dst = new char[100 * 26 + 1];
dst[100*26] = '*';
ds.copyTo(dst);
REPORTER_ASSERT(reporter, dst[100*26] == '*');
// char* p = dst;
for (i = 0; i < 100; i++) {
REPORTER_ASSERT(reporter, memcmp(&dst[i * 26], s, 26) == 0);
}
{
SkData* data = ds.copyToData();
REPORTER_ASSERT(reporter, 100 * 26 == data->size());
REPORTER_ASSERT(reporter, memcmp(dst, data->data(), data->size()) == 0);
data->unref();
}
delete[] dst;
}
static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
SkPicture picture;
SkCanvas* canvas = picture.beginRecording(bitmap.width(), bitmap.height());
canvas->drawBitmap(bitmap, 0, 0);
SkDynamicMemoryWStream wStream;
picture.serialize(&wStream, &encode_bitmap_to_data);
return wStream.copyToData();
}
static void test_empty(skiatest::Reporter* reporter) {
SkDynamicMemoryWStream stream;
SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(&stream));
doc->close();
REPORTER_ASSERT(reporter, stream.bytesWritten() == 0);
}
static int SendJSON(MHD_Connection* connection, SkDebugCanvas* debugCanvas, int n) {
SkDynamicMemoryWStream stream;
SkAutoTUnref<SkJSONCanvas> jsonCanvas(new SkJSONCanvas(kImageWidth, kImageHeight, stream));
debugCanvas->drawTo(jsonCanvas, n);
jsonCanvas->finish();
SkAutoTUnref<SkData> data(stream.copyToData());
return SendData(connection, data, "application/json");
}
static void test_empty(skiatest::Reporter* reporter) {
SkDynamicMemoryWStream stream;
auto doc = SkPDF::MakeDocument(&stream);
doc->close();
REPORTER_ASSERT(reporter, stream.bytesWritten() == 0);
}
SkData* Request::getJsonOps(int n) {
SkCanvas* canvas = this->getCanvas();
Json::Value root = fDebugCanvas->toJSON(fUrlDataManager, n, canvas);
root["mode"] = Json::Value(fGPUEnabled ? "gpu" : "cpu");
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(root).c_str());
return stream.copyToData();
}
static void TestWStream(skiatest::Reporter* reporter) {
SkDynamicMemoryWStream ds;
const char s[] = "abcdefghijklmnopqrstuvwxyz";
int i;
for (i = 0; i < 100; i++) {
REPORTER_ASSERT(reporter, ds.write(s, 26));
}
REPORTER_ASSERT(reporter, ds.bytesWritten() == 100 * 26);
char* dst = new char[100 * 26 + 1];
dst[100*26] = '*';
ds.copyTo(dst);
REPORTER_ASSERT(reporter, dst[100*26] == '*');
for (i = 0; i < 100; i++) {
REPORTER_ASSERT(reporter, memcmp(&dst[i * 26], s, 26) == 0);
}
{
std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
REPORTER_ASSERT(reporter, 100 * 26 == stream->getLength());
REPORTER_ASSERT(reporter, ds.bytesWritten() == 0);
test_loop_stream(reporter, stream.get(), s, 26, 100);
std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
test_loop_stream(reporter, stream2.get(), s, 26, 100);
std::unique_ptr<SkStreamAsset> stream3(stream->fork());
REPORTER_ASSERT(reporter, stream3->isAtEnd());
char tmp;
size_t bytes = stream->read(&tmp, 1);
REPORTER_ASSERT(reporter, 0 == bytes);
stream3->rewind();
test_loop_stream(reporter, stream3.get(), s, 26, 100);
}
for (i = 0; i < 100; i++) {
REPORTER_ASSERT(reporter, ds.write(s, 26));
}
REPORTER_ASSERT(reporter, ds.bytesWritten() == 100 * 26);
{
// Test that this works after a snapshot.
std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
REPORTER_ASSERT(reporter, ds.bytesWritten() == 0);
test_loop_stream(reporter, stream.get(), s, 26, 100);
std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
test_loop_stream(reporter, stream2.get(), s, 26, 100);
}
delete[] dst;
SkString tmpDir = skiatest::GetTmpDir();
if (!tmpDir.isEmpty()) {
test_filestreams(reporter, tmpDir.c_str());
}
}
void PipingBench::onDraw(int loops, SkCanvas*) {
SkDynamicMemoryWStream stream;
SkPipeSerializer serializer;
while (loops --> 0) {
fSrc->playback(serializer.beginWrite(fSrc->cullRect(), &stream));
serializer.endWrite();
stream.reset();
}
}
SkData* Request::writeCanvasToPng(SkCanvas* canvas) {
// capture pixels
SkAutoTDelete<SkBitmap> bmp(getBitmapFromCanvas(canvas));
SkASSERT(bmp);
// write to png
SkDynamicMemoryWStream buffer;
write_png((const png_bytep) bmp->getPixels(), bmp->width(), bmp->height(), buffer);
return buffer.copyToData();
}
DEF_TEST(SkDeflateWStream, r) {
SkRandom random(123456);
for (int i = 0; i < 50; ++i) {
uint32_t size = random.nextULessThan(10000);
SkAutoTMalloc<uint8_t> buffer(size);
for (uint32_t j = 0; j < size; ++j) {
buffer[j] = random.nextU() & 0xff;
}
SkDynamicMemoryWStream dynamicMemoryWStream;
{
SkDeflateWStream deflateWStream(&dynamicMemoryWStream);
uint32_t j = 0;
while (j < size) {
uint32_t writeSize =
SkTMin(size - j, random.nextRangeU(1, 400));
if (!deflateWStream.write(&buffer[j], writeSize)) {
ERRORF(r, "something went wrong.");
return;
}
j += writeSize;
}
}
SkAutoTDelete<SkStreamAsset> compressed(
dynamicMemoryWStream.detachAsStream());
SkAutoTDelete<SkStreamAsset> decompressed(stream_inflate(compressed));
if (decompressed->getLength() != size) {
ERRORF(r, "Decompression failed to get right size [%d]."
" %u != %u", i, (unsigned)(decompressed->getLength()),
(unsigned)size);
SkString s = SkStringPrintf("/tmp/deftst_compressed_%d", i);
SkFILEWStream o(s.c_str());
o.writeStream(compressed.get(), compressed->getLength());
compressed->rewind();
s = SkStringPrintf("/tmp/deftst_input_%d", i);
SkFILEWStream o2(s.c_str());
o2.write(&buffer[0], size);
continue;
}
uint32_t minLength = SkTMin(size,
(uint32_t)(decompressed->getLength()));
for (uint32_t i = 0; i < minLength; ++i) {
uint8_t c;
SkDEBUGCODE(size_t rb =)decompressed->read(&c, sizeof(uint8_t));
SkASSERT(sizeof(uint8_t) == rb);
if (buffer[i] != c) {
ERRORF(r, "Decompression failed at byte %u.", (unsigned)i);
break;
}
}
}
}
sk_sp<SkData> Request::getJsonOps(int n) {
SkCanvas* canvas = this->getCanvas();
Json::Value root = fDebugCanvas->toJSON(fUrlDataManager, n, canvas);
root["mode"] = Json::Value(fGPUEnabled ? "gpu" : "cpu");
root["drawGpuBatchBounds"] = Json::Value(fDebugCanvas->getDrawGpuBatchBounds());
root["colorMode"] = Json::Value(fColorMode);
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(root).c_str());
return stream.detachAsData();
}
static SkString emit_to_string(T& obj, Catalog* catPtr = nullptr) {
Catalog catalog;
SkDynamicMemoryWStream buffer;
if (!catPtr) {
catPtr = &catalog;
}
obj.emitObject(&buffer, catPtr->numbers, catPtr->substitutes);
SkString tmp(buffer.bytesWritten());
buffer.copyTo(tmp.writable_str());
return tmp;
}
SkData* Request::getJsonBatchList(int n) {
SkCanvas* canvas = this->getCanvas();
SkASSERT(fGPUEnabled);
Json::Value result = fDebugCanvas->toJSONBatchList(n, canvas);
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(result).c_str());
return stream.copyToData();
}
static size_t writeTypeface(SkWriter32* writer, SkTypeface* typeface) {
SkASSERT(typeface);
SkDynamicMemoryWStream stream;
typeface->serialize(&stream);
size_t size = stream.getOffset();
if (writer) {
writer->write32(size);
SkAutoDataUnref data(stream.copyToData());
writer->writePad(data->data(), size);
}
return 4 + SkAlign4(size);
}
