blob: 3de422b9696e1cdc49449525713bc373023e8b39 [file] [log] [blame]
commit-bot@chromium.org02512882013-10-31 18:37:50 +00001/*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
egdaniel4132de72016-06-15 14:28:17 -07008#include "Resources.h"
dvonbeck8811e402016-06-16 12:39:25 -07009#include "SkAnnotationKeys.h"
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +000010#include "SkCanvas.h"
bungeman41868fe2015-05-20 09:21:04 -070011#include "SkFixed.h"
12#include "SkFontDescriptor.h"
fmalita5598b632015-09-15 11:26:13 -070013#include "SkImage.h"
14#include "SkImageSource.h"
dvonbeck8811e402016-06-16 12:39:25 -070015#include "SkLightingShader.h"
bungemanf93d7112016-09-16 06:24:20 -070016#include "SkMakeUnique.h"
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +000017#include "SkMallocPixelRef.h"
dvonbeck5b794fa2016-07-06 13:58:36 -070018#include "SkNormalSource.h"
caseq26337e92014-06-30 12:14:52 -070019#include "SkOSFile.h"
robertphillips@google.com770963f2014-04-18 18:04:41 +000020#include "SkPictureRecorder.h"
senorblanco91c395a2014-09-25 15:51:35 -070021#include "SkTableColorFilter.h"
commit-bot@chromium.org1e7ee992014-03-14 21:22:22 +000022#include "SkTemplates.h"
caseq26337e92014-06-30 12:14:52 -070023#include "SkTypeface.h"
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000024#include "SkWriteBuffer.h"
commit-bot@chromium.org02512882013-10-31 18:37:50 +000025#include "SkValidatingReadBuffer.h"
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +000026#include "SkXfermodeImageFilter.h"
dvonbeck8811e402016-06-16 12:39:25 -070027#include "sk_tool_utils.h"
tfarina@chromium.org8f6884a2014-01-24 20:56:26 +000028#include "Test.h"
commit-bot@chromium.org02512882013-10-31 18:37:50 +000029
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000030static const uint32_t kArraySize = 64;
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +000031static const int kBitmapSize = 256;
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000032
33template<typename T>
34static void TestAlignment(T* testObj, skiatest::Reporter* reporter) {
35 // Test memory read/write functions directly
36 unsigned char dataWritten[1024];
37 size_t bytesWrittenToMemory = testObj->writeToMemory(dataWritten);
38 REPORTER_ASSERT(reporter, SkAlign4(bytesWrittenToMemory) == bytesWrittenToMemory);
39 size_t bytesReadFromMemory = testObj->readFromMemory(dataWritten, bytesWrittenToMemory);
40 REPORTER_ASSERT(reporter, SkAlign4(bytesReadFromMemory) == bytesReadFromMemory);
41}
42
43template<typename T> struct SerializationUtils {
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +000044 // Generic case for flattenables
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000045 static void Write(SkWriteBuffer& writer, const T* flattenable) {
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +000046 writer.writeFlattenable(flattenable);
47 }
48 static void Read(SkValidatingReadBuffer& reader, T** flattenable) {
mtklein3b375452016-04-04 14:57:19 -070049 *flattenable = (T*)reader.readFlattenable(T::GetFlattenableType());
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +000050 }
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000051};
52
53template<> struct SerializationUtils<SkMatrix> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000054 static void Write(SkWriteBuffer& writer, const SkMatrix* matrix) {
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000055 writer.writeMatrix(*matrix);
56 }
57 static void Read(SkValidatingReadBuffer& reader, SkMatrix* matrix) {
58 reader.readMatrix(matrix);
59 }
60};
61
62template<> struct SerializationUtils<SkPath> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000063 static void Write(SkWriteBuffer& writer, const SkPath* path) {
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000064 writer.writePath(*path);
65 }
66 static void Read(SkValidatingReadBuffer& reader, SkPath* path) {
67 reader.readPath(path);
68 }
69};
70
71template<> struct SerializationUtils<SkRegion> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000072 static void Write(SkWriteBuffer& writer, const SkRegion* region) {
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000073 writer.writeRegion(*region);
74 }
75 static void Read(SkValidatingReadBuffer& reader, SkRegion* region) {
76 reader.readRegion(region);
77 }
78};
79
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +000080template<> struct SerializationUtils<SkString> {
81 static void Write(SkWriteBuffer& writer, const SkString* string) {
82 writer.writeString(string->c_str());
83 }
84 static void Read(SkValidatingReadBuffer& reader, SkString* string) {
85 reader.readString(string);
86 }
87};
88
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000089template<> struct SerializationUtils<unsigned char> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000090 static void Write(SkWriteBuffer& writer, unsigned char* data, uint32_t arraySize) {
reed@google.com12a23862013-11-04 21:35:55 +000091 writer.writeByteArray(data, arraySize);
sugoi@google.com305f78e2013-11-04 16:18:15 +000092 }
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000093 static bool Read(SkValidatingReadBuffer& reader, unsigned char* data, uint32_t arraySize) {
94 return reader.readByteArray(data, arraySize);
95 }
96};
commit-bot@chromium.org02512882013-10-31 18:37:50 +000097
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +000098template<> struct SerializationUtils<SkColor> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +000099 static void Write(SkWriteBuffer& writer, SkColor* data, uint32_t arraySize) {
reed@google.com12a23862013-11-04 21:35:55 +0000100 writer.writeColorArray(data, arraySize);
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000101 }
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000102 static bool Read(SkValidatingReadBuffer& reader, SkColor* data, uint32_t arraySize) {
103 return reader.readColorArray(data, arraySize);
104 }
105};
sugoi@google.com305f78e2013-11-04 16:18:15 +0000106
brianosman97bbf822016-09-25 13:15:58 -0700107template<> struct SerializationUtils<SkColor4f> {
108 static void Write(SkWriteBuffer& writer, SkColor4f* data, uint32_t arraySize) {
109 writer.writeColor4fArray(data, arraySize);
110 }
111 static bool Read(SkValidatingReadBuffer& reader, SkColor4f* data, uint32_t arraySize) {
112 return reader.readColor4fArray(data, arraySize);
113 }
114};
115
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000116template<> struct SerializationUtils<int32_t> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +0000117 static void Write(SkWriteBuffer& writer, int32_t* data, uint32_t arraySize) {
reed@google.com12a23862013-11-04 21:35:55 +0000118 writer.writeIntArray(data, arraySize);
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000119 }
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000120 static bool Read(SkValidatingReadBuffer& reader, int32_t* data, uint32_t arraySize) {
121 return reader.readIntArray(data, arraySize);
122 }
123};
sugoi@google.com305f78e2013-11-04 16:18:15 +0000124
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000125template<> struct SerializationUtils<SkPoint> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +0000126 static void Write(SkWriteBuffer& writer, SkPoint* data, uint32_t arraySize) {
reed@google.com12a23862013-11-04 21:35:55 +0000127 writer.writePointArray(data, arraySize);
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000128 }
129 static bool Read(SkValidatingReadBuffer& reader, SkPoint* data, uint32_t arraySize) {
130 return reader.readPointArray(data, arraySize);
131 }
132};
reed@google.com12a23862013-11-04 21:35:55 +0000133
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000134template<> struct SerializationUtils<SkScalar> {
commit-bot@chromium.org8b0e8ac2014-01-30 18:58:24 +0000135 static void Write(SkWriteBuffer& writer, SkScalar* data, uint32_t arraySize) {
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000136 writer.writeScalarArray(data, arraySize);
137 }
138 static bool Read(SkValidatingReadBuffer& reader, SkScalar* data, uint32_t arraySize) {
139 return reader.readScalarArray(data, arraySize);
140 }
141};
reed@google.com12a23862013-11-04 21:35:55 +0000142
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +0000143template<typename T, bool testInvalid> struct SerializationTestUtils {
144 static void InvalidateData(unsigned char* data) {}
145};
146
147template<> struct SerializationTestUtils<SkString, true> {
148 static void InvalidateData(unsigned char* data) {
149 data[3] |= 0x80; // Reverse sign of 1st integer
150 }
151};
152
153template<typename T, bool testInvalid>
154static void TestObjectSerializationNoAlign(T* testObj, skiatest::Reporter* reporter) {
brianosmanfad98562016-05-04 11:06:28 -0700155 SkBinaryWriteBuffer writer;
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000156 SerializationUtils<T>::Write(writer, testObj);
157 size_t bytesWritten = writer.bytesWritten();
158 REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
reed@google.com12a23862013-11-04 21:35:55 +0000159
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000160 unsigned char dataWritten[1024];
161 writer.writeToMemory(dataWritten);
162
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +0000163 SerializationTestUtils<T, testInvalid>::InvalidateData(dataWritten);
164
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000165 // Make sure this fails when it should (test with smaller size, but still multiple of 4)
166 SkValidatingReadBuffer buffer(dataWritten, bytesWritten - 4);
commit-bot@chromium.org8f457e32013-11-08 19:22:57 +0000167 T obj;
168 SerializationUtils<T>::Read(buffer, &obj);
commit-bot@chromium.orgc2e9db32013-12-06 20:14:46 +0000169 REPORTER_ASSERT(reporter, !buffer.isValid());
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000170
171 // Make sure this succeeds when it should
172 SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
Robert Phillipsb2526042016-09-26 09:00:36 -0400173 size_t offsetBefore = buffer2.offset();
commit-bot@chromium.org8f457e32013-11-08 19:22:57 +0000174 T obj2;
175 SerializationUtils<T>::Read(buffer2, &obj2);
Robert Phillipsb2526042016-09-26 09:00:36 -0400176 size_t offsetAfter = buffer2.offset();
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000177 // This should have succeeded, since there are enough bytes to read this
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +0000178 REPORTER_ASSERT(reporter, buffer2.isValid() == !testInvalid);
179 // Note: This following test should always succeed, regardless of whether the buffer is valid,
180 // since if it is invalid, it will simply skip to the end, as if it had read the whole buffer.
Robert Phillipsb2526042016-09-26 09:00:36 -0400181 REPORTER_ASSERT(reporter, offsetAfter - offsetBefore == bytesWritten);
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +0000182}
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000183
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +0000184template<typename T>
185static void TestObjectSerialization(T* testObj, skiatest::Reporter* reporter) {
186 TestObjectSerializationNoAlign<T, false>(testObj, reporter);
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000187 TestAlignment(testObj, reporter);
188}
189
190template<typename T>
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000191static T* TestFlattenableSerialization(T* testObj, bool shouldSucceed,
192 skiatest::Reporter* reporter) {
brianosmanfad98562016-05-04 11:06:28 -0700193 SkBinaryWriteBuffer writer;
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000194 SerializationUtils<T>::Write(writer, testObj);
195 size_t bytesWritten = writer.bytesWritten();
196 REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
197
dvonbeck8811e402016-06-16 12:39:25 -0700198 SkASSERT(bytesWritten <= 4096);
senorblanco91c395a2014-09-25 15:51:35 -0700199 unsigned char dataWritten[4096];
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000200 writer.writeToMemory(dataWritten);
201
202 // Make sure this fails when it should (test with smaller size, but still multiple of 4)
203 SkValidatingReadBuffer buffer(dataWritten, bytesWritten - 4);
halcanary96fcdcc2015-08-27 07:41:13 -0700204 T* obj = nullptr;
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000205 SerializationUtils<T>::Read(buffer, &obj);
commit-bot@chromium.orgc2e9db32013-12-06 20:14:46 +0000206 REPORTER_ASSERT(reporter, !buffer.isValid());
halcanary96fcdcc2015-08-27 07:41:13 -0700207 REPORTER_ASSERT(reporter, nullptr == obj);
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000208
209 // Make sure this succeeds when it should
210 SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
211 const unsigned char* peekBefore = static_cast<const unsigned char*>(buffer2.skip(0));
halcanary96fcdcc2015-08-27 07:41:13 -0700212 T* obj2 = nullptr;
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000213 SerializationUtils<T>::Read(buffer2, &obj2);
214 const unsigned char* peekAfter = static_cast<const unsigned char*>(buffer2.skip(0));
215 if (shouldSucceed) {
216 // This should have succeeded, since there are enough bytes to read this
commit-bot@chromium.orgc2e9db32013-12-06 20:14:46 +0000217 REPORTER_ASSERT(reporter, buffer2.isValid());
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000218 REPORTER_ASSERT(reporter, static_cast<size_t>(peekAfter - peekBefore) == bytesWritten);
bsalomon49f085d2014-09-05 13:34:00 -0700219 REPORTER_ASSERT(reporter, obj2);
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000220 } else {
221 // If the deserialization was supposed to fail, make sure it did
commit-bot@chromium.orgc2e9db32013-12-06 20:14:46 +0000222 REPORTER_ASSERT(reporter, !buffer.isValid());
halcanary96fcdcc2015-08-27 07:41:13 -0700223 REPORTER_ASSERT(reporter, nullptr == obj2);
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000224 }
225
226 return obj2; // Return object to perform further validity tests on it
227}
228
229template<typename T>
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000230static void TestArraySerialization(T* data, skiatest::Reporter* reporter) {
brianosmanfad98562016-05-04 11:06:28 -0700231 SkBinaryWriteBuffer writer;
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000232 SerializationUtils<T>::Write(writer, data, kArraySize);
233 size_t bytesWritten = writer.bytesWritten();
234 // This should write the length (in 4 bytes) and the array
235 REPORTER_ASSERT(reporter, (4 + kArraySize * sizeof(T)) == bytesWritten);
236
brianosman97bbf822016-09-25 13:15:58 -0700237 unsigned char dataWritten[2048];
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000238 writer.writeToMemory(dataWritten);
239
240 // Make sure this fails when it should
241 SkValidatingReadBuffer buffer(dataWritten, bytesWritten);
242 T dataRead[kArraySize];
243 bool success = SerializationUtils<T>::Read(buffer, dataRead, kArraySize / 2);
244 // This should have failed, since the provided size was too small
245 REPORTER_ASSERT(reporter, !success);
246
247 // Make sure this succeeds when it should
248 SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
249 success = SerializationUtils<T>::Read(buffer2, dataRead, kArraySize);
250 // This should have succeeded, since there are enough bytes to read this
251 REPORTER_ASSERT(reporter, success);
252}
253
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000254static void TestBitmapSerialization(const SkBitmap& validBitmap,
255 const SkBitmap& invalidBitmap,
256 bool shouldSucceed,
257 skiatest::Reporter* reporter) {
reed9ce9d672016-03-17 10:51:11 -0700258 sk_sp<SkImage> validImage(SkImage::MakeFromBitmap(validBitmap));
robertphillips549c8992016-04-01 09:28:51 -0700259 sk_sp<SkImageFilter> validBitmapSource(SkImageSource::Make(std::move(validImage)));
reed9ce9d672016-03-17 10:51:11 -0700260 sk_sp<SkImage> invalidImage(SkImage::MakeFromBitmap(invalidBitmap));
robertphillips549c8992016-04-01 09:28:51 -0700261 sk_sp<SkImageFilter> invalidBitmapSource(SkImageSource::Make(std::move(invalidImage)));
reedcfb6bdf2016-03-29 11:32:50 -0700262 sk_sp<SkImageFilter> xfermodeImageFilter(
reed374772b2016-10-05 17:33:02 -0700263 SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
robertphillips8c0326d2016-04-05 12:48:34 -0700264 std::move(invalidBitmapSource),
265 std::move(validBitmapSource), nullptr));
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000266
Mike Reed5e257172016-11-01 11:22:05 -0400267 sk_sp<SkImageFilter> deserializedFilter(
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000268 TestFlattenableSerialization<SkImageFilter>(
reedcfb6bdf2016-03-29 11:32:50 -0700269 xfermodeImageFilter.get(), shouldSucceed, reporter));
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000270
271 // Try to render a small bitmap using the invalid deserialized filter
272 // to make sure we don't crash while trying to render it
273 if (shouldSucceed) {
274 SkBitmap bitmap;
mike@reedtribe.orgdeee4962014-02-13 14:41:43 +0000275 bitmap.allocN32Pixels(24, 24);
276 SkCanvas canvas(bitmap);
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000277 canvas.clear(0x00000000);
278 SkPaint paint;
279 paint.setImageFilter(deserializedFilter);
280 canvas.clipRect(SkRect::MakeXYWH(0, 0, SkIntToScalar(24), SkIntToScalar(24)));
281 canvas.drawBitmap(bitmap, 0, 0, &paint);
282 }
283}
284
senorblanco0f7197b2014-09-24 11:09:38 -0700285static void TestXfermodeSerialization(skiatest::Reporter* reporter) {
286 for (size_t i = 0; i <= SkXfermode::kLastMode; ++i) {
287 if (i == SkXfermode::kSrcOver_Mode) {
halcanary96fcdcc2015-08-27 07:41:13 -0700288 // skip SrcOver, as it is allowed to return nullptr from Create()
senorblanco0f7197b2014-09-24 11:09:38 -0700289 continue;
290 }
reedcfb6bdf2016-03-29 11:32:50 -0700291 auto mode(SkXfermode::Make(static_cast<SkXfermode::Mode>(i)));
292 REPORTER_ASSERT(reporter, mode);
Hal Canary342b7ac2016-11-04 11:49:42 -0400293 sk_sp<SkXfermode> copy(
senorblanco0f7197b2014-09-24 11:09:38 -0700294 TestFlattenableSerialization<SkXfermode>(mode.get(), true, reporter));
295 }
296}
297
senorblanco91c395a2014-09-25 15:51:35 -0700298static void TestColorFilterSerialization(skiatest::Reporter* reporter) {
299 uint8_t table[256];
300 for (int i = 0; i < 256; ++i) {
301 table[i] = (i * 41) % 256;
302 }
reedd053ce92016-03-22 10:17:23 -0700303 auto colorFilter(SkTableColorFilter::Make(table));
Hal Canary342b7ac2016-11-04 11:49:42 -0400304 sk_sp<SkColorFilter> copy(
senorblanco91c395a2014-09-25 15:51:35 -0700305 TestFlattenableSerialization<SkColorFilter>(colorFilter.get(), true, reporter));
306}
307
caseq26337e92014-06-30 12:14:52 -0700308static SkBitmap draw_picture(SkPicture& picture) {
309 SkBitmap bitmap;
halcanary9d524f22016-03-29 09:03:52 -0700310 bitmap.allocN32Pixels(SkScalarCeilToInt(picture.cullRect().width()),
robertphillipsa8d7f0b2014-08-29 08:03:56 -0700311 SkScalarCeilToInt(picture.cullRect().height()));
caseq26337e92014-06-30 12:14:52 -0700312 SkCanvas canvas(bitmap);
robertphillipsc5ba71d2014-09-04 08:42:50 -0700313 picture.playback(&canvas);
caseq26337e92014-06-30 12:14:52 -0700314 return bitmap;
315}
316
317static void compare_bitmaps(skiatest::Reporter* reporter,
318 const SkBitmap& b1, const SkBitmap& b2) {
319 REPORTER_ASSERT(reporter, b1.width() == b2.width());
320 REPORTER_ASSERT(reporter, b1.height() == b2.height());
321 SkAutoLockPixels autoLockPixels1(b1);
322 SkAutoLockPixels autoLockPixels2(b2);
323
324 if ((b1.width() != b2.width()) ||
325 (b1.height() != b2.height())) {
326 return;
327 }
328
329 int pixelErrors = 0;
330 for (int y = 0; y < b2.height(); ++y) {
331 for (int x = 0; x < b2.width(); ++x) {
332 if (b1.getColor(x, y) != b2.getColor(x, y))
333 ++pixelErrors;
334 }
335 }
336 REPORTER_ASSERT(reporter, 0 == pixelErrors);
337}
bungeman13b9c952016-05-12 10:09:30 -0700338static void serialize_and_compare_typeface(sk_sp<SkTypeface> typeface, const char* text,
bungeman41868fe2015-05-20 09:21:04 -0700339 skiatest::Reporter* reporter)
340{
341 // Create a paint with the typeface.
caseq26337e92014-06-30 12:14:52 -0700342 SkPaint paint;
343 paint.setColor(SK_ColorGRAY);
344 paint.setTextSize(SkIntToScalar(30));
bungeman13b9c952016-05-12 10:09:30 -0700345 paint.setTypeface(std::move(typeface));
caseq26337e92014-06-30 12:14:52 -0700346
347 // Paint some text.
348 SkPictureRecorder recorder;
349 SkIRect canvasRect = SkIRect::MakeWH(kBitmapSize, kBitmapSize);
halcanary9d524f22016-03-29 09:03:52 -0700350 SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(canvasRect.width()),
351 SkIntToScalar(canvasRect.height()),
halcanary96fcdcc2015-08-27 07:41:13 -0700352 nullptr, 0);
caseq26337e92014-06-30 12:14:52 -0700353 canvas->drawColor(SK_ColorWHITE);
bungeman41868fe2015-05-20 09:21:04 -0700354 canvas->drawText(text, 2, 24, 32, paint);
reedca2622b2016-03-18 07:25:55 -0700355 sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
caseq26337e92014-06-30 12:14:52 -0700356
357 // Serlialize picture and create its clone from stream.
358 SkDynamicMemoryWStream stream;
359 picture->serialize(&stream);
Ben Wagner145dbcd2016-11-03 14:40:50 -0400360 std::unique_ptr<SkStream> inputStream(stream.detachAsStream());
reedca2622b2016-03-18 07:25:55 -0700361 sk_sp<SkPicture> loadedPicture(SkPicture::MakeFromStream(inputStream.get()));
caseq26337e92014-06-30 12:14:52 -0700362
363 // Draw both original and clone picture and compare bitmaps -- they should be identical.
364 SkBitmap origBitmap = draw_picture(*picture);
365 SkBitmap destBitmap = draw_picture(*loadedPicture);
366 compare_bitmaps(reporter, origBitmap, destBitmap);
367}
368
bungeman41868fe2015-05-20 09:21:04 -0700369static void TestPictureTypefaceSerialization(skiatest::Reporter* reporter) {
370 {
371 // Load typeface from file to test CreateFromFile with index.
372 SkString filename = GetResourcePath("/fonts/test.ttc");
bungeman13b9c952016-05-12 10:09:30 -0700373 sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFile(filename.c_str(), 1));
bungeman41868fe2015-05-20 09:21:04 -0700374 if (!typeface) {
halcanary7d571242016-02-24 17:59:16 -0800375 INFOF(reporter, "Could not run fontstream test because test.ttc not found.");
bungeman41868fe2015-05-20 09:21:04 -0700376 } else {
bungeman13b9c952016-05-12 10:09:30 -0700377 serialize_and_compare_typeface(std::move(typeface), "A!", reporter);
bungeman41868fe2015-05-20 09:21:04 -0700378 }
379 }
380
381 {
382 // Load typeface as stream to create with axis settings.
bungemanf93d7112016-09-16 06:24:20 -0700383 std::unique_ptr<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf"));
bungeman41868fe2015-05-20 09:21:04 -0700384 if (!distortable) {
halcanary7d571242016-02-24 17:59:16 -0800385 INFOF(reporter, "Could not run fontstream test because Distortable.ttf not found.");
bungeman41868fe2015-05-20 09:21:04 -0700386 } else {
387 SkFixed axis = SK_FixedSqrt2;
bungeman13b9c952016-05-12 10:09:30 -0700388 sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(
bungemanf93d7112016-09-16 06:24:20 -0700389 skstd::make_unique<SkFontData>(std::move(distortable), 0, &axis, 1)));
bungeman41868fe2015-05-20 09:21:04 -0700390 if (!typeface) {
halcanary7d571242016-02-24 17:59:16 -0800391 INFOF(reporter, "Could not run fontstream test because Distortable.ttf not created.");
bungeman41868fe2015-05-20 09:21:04 -0700392 } else {
bungeman13b9c952016-05-12 10:09:30 -0700393 serialize_and_compare_typeface(std::move(typeface), "abc", reporter);
bungeman41868fe2015-05-20 09:21:04 -0700394 }
395 }
396 }
397}
398
reed84825042014-09-02 12:50:45 -0700399static void setup_bitmap_for_canvas(SkBitmap* bitmap) {
400 bitmap->allocN32Pixels(kBitmapSize, kBitmapSize);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000401}
402
reed84825042014-09-02 12:50:45 -0700403static void make_checkerboard_bitmap(SkBitmap& bitmap) {
404 setup_bitmap_for_canvas(&bitmap);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000405
406 SkCanvas canvas(bitmap);
407 canvas.clear(0x00000000);
408 SkPaint darkPaint;
409 darkPaint.setColor(0xFF804020);
410 SkPaint lightPaint;
411 lightPaint.setColor(0xFF244484);
412 const int i = kBitmapSize / 8;
413 const SkScalar f = SkIntToScalar(i);
414 for (int y = 0; y < kBitmapSize; y += i) {
415 for (int x = 0; x < kBitmapSize; x += i) {
416 canvas.save();
417 canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
418 canvas.drawRect(SkRect::MakeXYWH(0, 0, f, f), darkPaint);
419 canvas.drawRect(SkRect::MakeXYWH(f, 0, f, f), lightPaint);
420 canvas.drawRect(SkRect::MakeXYWH(0, f, f, f), lightPaint);
421 canvas.drawRect(SkRect::MakeXYWH(f, f, f, f), darkPaint);
422 canvas.restore();
423 }
424 }
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000425}
426
reed84825042014-09-02 12:50:45 -0700427static void draw_something(SkCanvas* canvas) {
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000428 SkPaint paint;
429 SkBitmap bitmap;
reed84825042014-09-02 12:50:45 -0700430 make_checkerboard_bitmap(bitmap);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000431
432 canvas->save();
433 canvas->scale(0.5f, 0.5f);
halcanary96fcdcc2015-08-27 07:41:13 -0700434 canvas->drawBitmap(bitmap, 0, 0, nullptr);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000435 canvas->restore();
436
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000437 paint.setAntiAlias(true);
438
439 paint.setColor(SK_ColorRED);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000440 canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000441 paint.setColor(SK_ColorBLACK);
442 paint.setTextSize(SkIntToScalar(kBitmapSize/3));
443 canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000444}
445
tfarina@chromium.orge4fafb12013-12-12 21:11:12 +0000446DEF_TEST(Serialization, reporter) {
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000447 // Test matrix serialization
448 {
449 SkMatrix matrix = SkMatrix::I();
450 TestObjectSerialization(&matrix, reporter);
caseq26337e92014-06-30 12:14:52 -0700451 }
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000452
453 // Test path serialization
454 {
455 SkPath path;
456 TestObjectSerialization(&path, reporter);
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000457 }
sugoi@google.com305f78e2013-11-04 16:18:15 +0000458
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000459 // Test region serialization
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000460 {
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000461 SkRegion region;
462 TestObjectSerialization(&region, reporter);
463 }
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000464
senorblanco0f7197b2014-09-24 11:09:38 -0700465 // Test xfermode serialization
466 {
467 TestXfermodeSerialization(reporter);
468 }
469
senorblanco91c395a2014-09-25 15:51:35 -0700470 // Test color filter serialization
471 {
472 TestColorFilterSerialization(reporter);
473 }
474
commit-bot@chromium.org1ac99c82014-04-29 15:35:23 +0000475 // Test string serialization
476 {
477 SkString string("string");
478 TestObjectSerializationNoAlign<SkString, false>(&string, reporter);
479 TestObjectSerializationNoAlign<SkString, true>(&string, reporter);
480 }
481
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000482 // Test rrect serialization
483 {
rmistry@google.comd6bab022013-12-02 13:50:38 +0000484 // SkRRect does not initialize anything.
485 // An uninitialized SkRRect can be serialized,
486 // but will branch on uninitialized data when deserialized.
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000487 SkRRect rrect;
rmistry@google.comd6bab022013-12-02 13:50:38 +0000488 SkRect rect = SkRect::MakeXYWH(1, 2, 20, 30);
489 SkVector corners[4] = { {1, 2}, {2, 3}, {3,4}, {4,5} };
490 rrect.setRectRadii(rect, corners);
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000491 TestAlignment(&rrect, reporter);
492 }
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000493
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000494 // Test readByteArray
495 {
rmistry@google.comd6bab022013-12-02 13:50:38 +0000496 unsigned char data[kArraySize] = { 1, 2, 3 };
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000497 TestArraySerialization(data, reporter);
498 }
sugoi@google.comb48a59a2013-11-04 20:28:23 +0000499
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000500 // Test readColorArray
501 {
rmistry@google.comd6bab022013-12-02 13:50:38 +0000502 SkColor data[kArraySize] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorRED };
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000503 TestArraySerialization(data, reporter);
504 }
505
brianosman97bbf822016-09-25 13:15:58 -0700506 // Test readColor4fArray
507 {
508 SkColor4f data[kArraySize] = {
509 SkColor4f::FromColor(SK_ColorBLACK),
510 SkColor4f::FromColor(SK_ColorWHITE),
511 SkColor4f::FromColor(SK_ColorRED),
512 { 1.f, 2.f, 4.f, 8.f }
513 };
514 TestArraySerialization(data, reporter);
515 }
516
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000517 // Test readIntArray
518 {
rmistry@google.comd6bab022013-12-02 13:50:38 +0000519 int32_t data[kArraySize] = { 1, 2, 4, 8 };
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000520 TestArraySerialization(data, reporter);
521 }
522
523 // Test readPointArray
524 {
rmistry@google.comd6bab022013-12-02 13:50:38 +0000525 SkPoint data[kArraySize] = { {6, 7}, {42, 128} };
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000526 TestArraySerialization(data, reporter);
527 }
528
529 // Test readScalarArray
530 {
rmistry@google.comd6bab022013-12-02 13:50:38 +0000531 SkScalar data[kArraySize] = { SK_Scalar1, SK_ScalarHalf, SK_ScalarMax };
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000532 TestArraySerialization(data, reporter);
commit-bot@chromium.org02512882013-10-31 18:37:50 +0000533 }
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000534
535 // Test invalid deserializations
536 {
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000537 SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize);
mike@reedtribe.orgdeee4962014-02-13 14:41:43 +0000538
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000539 SkBitmap validBitmap;
commit-bot@chromium.orga3264e52014-05-30 13:26:10 +0000540 validBitmap.setInfo(info);
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000541
542 // Create a bitmap with a really large height
543 SkBitmap invalidBitmap;
reede5ea5002014-09-03 11:54:58 -0700544 invalidBitmap.setInfo(info.makeWH(info.width(), 1000000000));
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000545
546 // The deserialization should succeed, and the rendering shouldn't crash,
547 // even when the device fails to initialize, due to its size
548 TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
commit-bot@chromium.orgcd3b15c2013-12-04 17:06:49 +0000549 }
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000550
551 // Test simple SkPicture serialization
552 {
robertphillips@google.com84b18c72014-04-13 19:09:42 +0000553 SkPictureRecorder recorder;
reed84825042014-09-02 12:50:45 -0700554 draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize),
555 SkIntToScalar(kBitmapSize),
halcanary96fcdcc2015-08-27 07:41:13 -0700556 nullptr, 0));
reedca2622b2016-03-18 07:25:55 -0700557 sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000558
559 // Serialize picture
brianosmanfad98562016-05-04 11:06:28 -0700560 SkBinaryWriteBuffer writer;
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000561 pict->flatten(writer);
562 size_t size = writer.bytesWritten();
commit-bot@chromium.org1e7ee992014-03-14 21:22:22 +0000563 SkAutoTMalloc<unsigned char> data(size);
564 writer.writeToMemory(static_cast<void*>(data.get()));
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000565
566 // Deserialize picture
commit-bot@chromium.org1e7ee992014-03-14 21:22:22 +0000567 SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size);
reedca2622b2016-03-18 07:25:55 -0700568 sk_sp<SkPicture> readPict(SkPicture::MakeFromBuffer(reader));
reedd921dbb2016-09-30 09:27:20 -0700569 REPORTER_ASSERT(reporter, reader.isValid());
bsalomon49f085d2014-09-05 13:34:00 -0700570 REPORTER_ASSERT(reporter, readPict.get());
commit-bot@chromium.org9e5f85e2014-03-12 14:46:41 +0000571 }
caseq26337e92014-06-30 12:14:52 -0700572
573 TestPictureTypefaceSerialization(reporter);
dvonbeck8811e402016-06-16 12:39:25 -0700574
575 // Test SkLightingShader/NormalMapSource serialization
576 {
577 const int kTexSize = 2;
578
579 SkLights::Builder builder;
580
vjiaoblack772b5ee2016-08-12 11:38:47 -0700581 builder.add(SkLights::Light::MakeDirectional(SkColor3f::Make(1.0f, 1.0f, 1.0f),
582 SkVector3::Make(1.0f, 0.0f, 0.0f)));
vjiaoblacka8eabc42016-08-29 10:22:09 -0700583 builder.setAmbientLightColor(SkColor3f::Make(0.2f, 0.2f, 0.2f));
dvonbeck8811e402016-06-16 12:39:25 -0700584
585 sk_sp<SkLights> fLights = builder.finish();
586
587 SkBitmap diffuse = sk_tool_utils::create_checkerboard_bitmap(
588 kTexSize, kTexSize,
589 sk_tool_utils::color_to_565(0x0),
590 sk_tool_utils::color_to_565(0xFF804020),
591 8);
592
593 SkRect bitmapBounds = SkRect::MakeIWH(diffuse.width(), diffuse.height());
594
595 SkMatrix matrix;
596 SkRect r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize));
597 matrix.setRectToRect(bitmapBounds, r, SkMatrix::kFill_ScaleToFit);
598
dvonbeck5b794fa2016-07-06 13:58:36 -0700599 SkMatrix ctm;
600 ctm.setRotate(45);
dvonbeck8811e402016-06-16 12:39:25 -0700601 SkBitmap normals;
602 normals.allocN32Pixels(kTexSize, kTexSize);
603
604 sk_tool_utils::create_frustum_normal_map(&normals, SkIRect::MakeWH(kTexSize, kTexSize));
reed1ec04d92016-08-05 12:07:41 -0700605 sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normals, SkShader::kClamp_TileMode,
606 SkShader::kClamp_TileMode, &matrix);
dvonbeck5b794fa2016-07-06 13:58:36 -0700607 sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
608 ctm);
reed1ec04d92016-08-05 12:07:41 -0700609 sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(diffuse,
610 SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
dvonbeckc526da92016-07-20 11:20:30 -0700611
612 sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuseShader,
613 normalSource,
dvonbeck6af677f2016-07-10 18:38:33 -0700614 fLights);
Hal Canary342b7ac2016-11-04 11:49:42 -0400615 sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
dvonbeck8811e402016-06-16 12:39:25 -0700616
dvonbeckc526da92016-07-20 11:20:30 -0700617 lightingShader = SkLightingShader::Make(std::move(diffuseShader),
618 nullptr,
619 fLights);
Hal Canary342b7ac2016-11-04 11:49:42 -0400620 sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
dvonbeckc526da92016-07-20 11:20:30 -0700621
622 lightingShader = SkLightingShader::Make(nullptr,
623 std::move(normalSource),
624 fLights);
Hal Canary342b7ac2016-11-04 11:49:42 -0400625 sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
dvonbeckc526da92016-07-20 11:20:30 -0700626
627 lightingShader = SkLightingShader::Make(nullptr,
628 nullptr,
629 fLights);
Hal Canary342b7ac2016-11-04 11:49:42 -0400630 sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
dvonbeck8811e402016-06-16 12:39:25 -0700631 }
dvonbeckbba4cfe2016-07-28 08:58:19 -0700632
633 // Test NormalBevelSource serialization
634 {
635 sk_sp<SkNormalSource> bevelSource = SkNormalSource::MakeBevel(
636 SkNormalSource::BevelType::kLinear, 2.0f, 5.0f);
637
Hal Canary342b7ac2016-11-04 11:49:42 -0400638 sk_sp<SkNormalSource>(TestFlattenableSerialization(bevelSource.get(), true, reporter));
dvonbeckbba4cfe2016-07-28 08:58:19 -0700639 // TODO test equality?
640
641 }
commit-bot@chromium.org02512882013-10-31 18:37:50 +0000642}
reedf70b5312016-03-04 16:36:20 -0800643
644///////////////////////////////////////////////////////////////////////////////////////////////////
645#include "SkAnnotation.h"
646
reedca2622b2016-03-18 07:25:55 -0700647static sk_sp<SkPicture> copy_picture_via_serialization(SkPicture* src) {
reedf70b5312016-03-04 16:36:20 -0800648 SkDynamicMemoryWStream wstream;
649 src->serialize(&wstream);
Ben Wagner145dbcd2016-11-03 14:40:50 -0400650 std::unique_ptr<SkStreamAsset> rstream(wstream.detachAsStream());
651 return SkPicture::MakeFromStream(rstream.get());
reedf70b5312016-03-04 16:36:20 -0800652}
653
654struct AnnotationRec {
655 const SkRect fRect;
656 const char* fKey;
bungeman38d909e2016-08-02 14:40:46 -0700657 sk_sp<SkData> fValue;
reedf70b5312016-03-04 16:36:20 -0800658};
659
660class TestAnnotationCanvas : public SkCanvas {
661 skiatest::Reporter* fReporter;
662 const AnnotationRec* fRec;
663 int fCount;
664 int fCurrIndex;
665
666public:
667 TestAnnotationCanvas(skiatest::Reporter* reporter, const AnnotationRec rec[], int count)
668 : SkCanvas(100, 100)
669 , fReporter(reporter)
670 , fRec(rec)
671 , fCount(count)
672 , fCurrIndex(0)
673 {}
674
675 ~TestAnnotationCanvas() {
676 REPORTER_ASSERT(fReporter, fCount == fCurrIndex);
677 }
678
679protected:
680 void onDrawAnnotation(const SkRect& rect, const char key[], SkData* value) {
681 REPORTER_ASSERT(fReporter, fCurrIndex < fCount);
682 REPORTER_ASSERT(fReporter, rect == fRec[fCurrIndex].fRect);
683 REPORTER_ASSERT(fReporter, !strcmp(key, fRec[fCurrIndex].fKey));
bungeman38d909e2016-08-02 14:40:46 -0700684 REPORTER_ASSERT(fReporter, value->equals(fRec[fCurrIndex].fValue.get()));
reedf70b5312016-03-04 16:36:20 -0800685 fCurrIndex += 1;
686 }
687};
688
689/*
690 * Test the 3 annotation types by recording them into a picture, serializing, and then playing
691 * them back into another canvas.
692 */
693DEF_TEST(Annotations, reporter) {
694 SkPictureRecorder recorder;
695 SkCanvas* recordingCanvas = recorder.beginRecording(SkRect::MakeWH(100, 100));
halcanary9d524f22016-03-29 09:03:52 -0700696
reedf70b5312016-03-04 16:36:20 -0800697 const char* str0 = "rect-with-url";
698 const SkRect r0 = SkRect::MakeWH(10, 10);
bungeman38d909e2016-08-02 14:40:46 -0700699 sk_sp<SkData> d0(SkData::MakeWithCString(str0));
700 SkAnnotateRectWithURL(recordingCanvas, r0, d0.get());
halcanary9d524f22016-03-29 09:03:52 -0700701
reedf70b5312016-03-04 16:36:20 -0800702 const char* str1 = "named-destination";
703 const SkRect r1 = SkRect::MakeXYWH(5, 5, 0, 0); // collapsed to a point
bungeman38d909e2016-08-02 14:40:46 -0700704 sk_sp<SkData> d1(SkData::MakeWithCString(str1));
705 SkAnnotateNamedDestination(recordingCanvas, {r1.x(), r1.y()}, d1.get());
halcanary9d524f22016-03-29 09:03:52 -0700706
reedf70b5312016-03-04 16:36:20 -0800707 const char* str2 = "link-to-destination";
708 const SkRect r2 = SkRect::MakeXYWH(20, 20, 5, 6);
bungeman38d909e2016-08-02 14:40:46 -0700709 sk_sp<SkData> d2(SkData::MakeWithCString(str2));
710 SkAnnotateLinkToDestination(recordingCanvas, r2, d2.get());
reedf70b5312016-03-04 16:36:20 -0800711
712 const AnnotationRec recs[] = {
bungeman38d909e2016-08-02 14:40:46 -0700713 { r0, SkAnnotationKeys::URL_Key(), std::move(d0) },
714 { r1, SkAnnotationKeys::Define_Named_Dest_Key(), std::move(d1) },
715 { r2, SkAnnotationKeys::Link_Named_Dest_Key(), std::move(d2) },
reedf70b5312016-03-04 16:36:20 -0800716 };
717
reedca2622b2016-03-18 07:25:55 -0700718 sk_sp<SkPicture> pict0(recorder.finishRecordingAsPicture());
719 sk_sp<SkPicture> pict1(copy_picture_via_serialization(pict0.get()));
reedf70b5312016-03-04 16:36:20 -0800720
721 TestAnnotationCanvas canvas(reporter, recs, SK_ARRAY_COUNT(recs));
722 canvas.drawPicture(pict1);
723}