1 /*
2 * Copyright 2019 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
8 #include "include/core/SkTypes.h"
9 #include "include/private/chromium/SkChromeRemoteGlyphCache.h"
10 #include "src/core/SkDescriptor.h"
11 #include "src/core/SkFontPriv.h"
12 #include "src/core/SkReadBuffer.h"
13 #include "src/core/SkScalerContext.h"
14 #include "src/core/SkWriteBuffer.h"
15 #include "src/gpu/GrResourceProvider.h"
16 #include "tests/Test.h"
17
18 #include <memory>
19
20 class SkDescriptorTestHelper {
21 public:
SetLength(SkDescriptor * desc,size_t length)22 static void SetLength(SkDescriptor* desc, size_t length) { desc->fLength = length; }
SetCount(SkDescriptor * desc,uint32_t count)23 static void SetCount(SkDescriptor* desc, uint32_t count) { desc->fCount = count; }
24 };
25
DEF_TEST(Descriptor_empty,r)26 DEF_TEST(Descriptor_empty, r) {
27 const size_t size = sizeof(SkDescriptor);
28
29 auto desc = SkDescriptor::Alloc(size);
30 REPORTER_ASSERT(r, desc->isValid());
31 REPORTER_ASSERT(r, desc->getLength() == size);
32 }
33
DEF_TEST(Descriptor_valid_simple,r)34 DEF_TEST(Descriptor_valid_simple, r) {
35 const size_t size =
36 sizeof(SkDescriptor) + sizeof(SkDescriptor::Entry) + sizeof(SkScalerContextRec);
37
38 auto desc = SkDescriptor::Alloc(size);
39 SkScalerContextRec rec;
40 desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
41 REPORTER_ASSERT(r, desc->isValid());
42 REPORTER_ASSERT(r, desc->getLength() == size);
43
44 SkDescriptorTestHelper::SetLength(desc.get(), size - 4);
45 REPORTER_ASSERT(r, !desc->isValid());
46 }
47
DEF_TEST(Descriptor_valid_simple_extra_space,r)48 DEF_TEST(Descriptor_valid_simple_extra_space, r) {
49 const size_t extra_space = 100;
50 const size_t size =
51 sizeof(SkDescriptor) + sizeof(SkDescriptor::Entry) + sizeof(SkScalerContextRec);
52
53 auto desc = SkDescriptor::Alloc(size + extra_space);
54 SkScalerContextRec rec;
55 desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
56 REPORTER_ASSERT(r, desc->isValid());
57 REPORTER_ASSERT(r, desc->getLength() == size);
58
59 SkDescriptorTestHelper::SetLength(desc.get(), size - 4);
60 REPORTER_ASSERT(r, !desc->isValid());
61 }
62
DEF_TEST(Descriptor_valid_more_tags,r)63 DEF_TEST(Descriptor_valid_more_tags, r) {
64 const size_t effectSize = 16;
65 const size_t testSize = 32;
66 const size_t size = sizeof(SkDescriptor) + 3 * sizeof(SkDescriptor::Entry) +
67 sizeof(SkScalerContextRec) + effectSize + testSize;
68
69 auto desc = SkDescriptor::Alloc(size);
70 SkScalerContextRec rec;
71 desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
72 desc->addEntry(kEffects_SkDescriptorTag, effectSize, nullptr);
73 desc->addEntry(SkSetFourByteTag('t', 'e', 's', 't'), testSize, nullptr);
74 REPORTER_ASSERT(r, desc->isValid());
75 REPORTER_ASSERT(r, desc->getLength() == size);
76
77 SkDescriptorTestHelper::SetLength(desc.get(), size - 4);
78 REPORTER_ASSERT(r, !desc->isValid());
79 }
80
DEF_TEST(Descriptor_invalid_rec_size,r)81 DEF_TEST(Descriptor_invalid_rec_size, r) {
82 const size_t size =
83 sizeof(SkDescriptor) + sizeof(SkDescriptor::Entry) + sizeof(SkScalerContextRec) - 4;
84
85 auto desc = SkDescriptor::Alloc(size);
86 SkScalerContextRec rec;
87 desc->addEntry(kRec_SkDescriptorTag, sizeof(rec) - 4, &rec);
88 REPORTER_ASSERT(r, desc->getLength() == size);
89 REPORTER_ASSERT(r, !desc->isValid());
90 }
91
DEF_TEST(Descriptor_invalid_length,r)92 DEF_TEST(Descriptor_invalid_length, r) {
93 const size_t size = sizeof(SkDescriptor) + sizeof(SkDescriptor::Entry);
94 const size_t effect_size = 1000;
95
96 auto desc = SkDescriptor::Alloc(size);
97 desc->addEntry(kEffects_SkDescriptorTag, effect_size, nullptr);
98
99 SkDescriptorTestHelper::SetLength(desc.get(), size);
100 REPORTER_ASSERT(r, !desc->isValid());
101
102 SkDescriptorTestHelper::SetLength(desc.get(), size + effect_size);
103 REPORTER_ASSERT(r, desc->isValid());
104 }
105
DEF_TEST(Descriptor_entry_too_big,r)106 DEF_TEST(Descriptor_entry_too_big, r) {
107 const size_t size = sizeof(SkDescriptor) + sizeof(SkDescriptor::Entry) + 4;
108 // Must be less than fLength, but big enough to be bigger then fLength when added.
109 const size_t effect_size = sizeof(SkDescriptor) + sizeof(SkDescriptor::Entry);
110
111 auto desc = SkDescriptor::Alloc(size);
112
113 desc->addEntry(kEffects_SkDescriptorTag, effect_size, nullptr);
114
115 SkDescriptorTestHelper::SetLength(desc.get(), size);
116 SkDescriptorTestHelper::SetCount(desc.get(), 2);
117 REPORTER_ASSERT(r, !desc->isValid());
118
119 SkDescriptorTestHelper::SetLength(desc.get(), size);
120 SkDescriptorTestHelper::SetCount(desc.get(), 1);
121 REPORTER_ASSERT(r, !desc->isValid());
122 }
123
DEF_TEST(Descriptor_entry_over_end,r)124 DEF_TEST(Descriptor_entry_over_end, r) {
125 auto desc = SkDescriptor::Alloc(36);
126
127 // Make the start of the Entry be in the SkDescriptor, but the second half falls out side the
128 // SkDescriptor. So: 12 (for descriptor) + 8 (for entry) + 12 (for entry length) = 32. An
129 // An Entry is 8 bytes, so 4 bytes are < 36 and 4 bytes > 36.
130 desc->addEntry(kEffects_SkDescriptorTag, 12, nullptr);
131
132 SkDescriptorTestHelper::SetLength(desc.get(), 36);
133 SkDescriptorTestHelper::SetCount(desc.get(), 2);
134 REPORTER_ASSERT(r, !desc->isValid());
135 }
136
DEF_TEST(Descriptor_flatten_unflatten,r)137 DEF_TEST(Descriptor_flatten_unflatten, r) {
138 {
139 SkBinaryWriteBuffer writer;
140 auto desc = SkDescriptor::Alloc(sizeof(SkDescriptor));
141 desc->computeChecksum();
142 desc->flatten(writer);
143 auto data = writer.snapshotAsData();
144 SkReadBuffer reader{data->data(), data->size()};
145 auto ad = SkAutoDescriptor::MakeFromBuffer(reader);
146 REPORTER_ASSERT(r, ad.has_value());
147 REPORTER_ASSERT(r, ad->getDesc()->isValid());
148 }
149
150 { // broken header
151 SkBinaryWriteBuffer writer;
152 writer.writeInt(0); // fChecksum
153 auto data = writer.snapshotAsData();
154 SkReadBuffer reader{data->data(), data->size()};
155 auto ad = SkAutoDescriptor::MakeFromBuffer(reader);
156 REPORTER_ASSERT(r, !ad.has_value());
157 }
158
159 { // length too big
160 SkBinaryWriteBuffer writer;
161 // Simulate a broken header
162 writer.writeInt(0); // fChecksum
163 writer.writeInt(4000); // fLength
164 writer.writeInt(0); // fCount
165 auto data = writer.snapshotAsData();
166 SkReadBuffer reader{data->data(), data->size()};
167 auto ad = SkAutoDescriptor::MakeFromBuffer(reader);
168 REPORTER_ASSERT(r, !ad.has_value());
169 }
170
171 { // length too small
172 SkBinaryWriteBuffer writer;
173 // Simulate a broken header
174 writer.writeInt(0); // fChecksum
175 writer.writeInt(3); // fLength
176 writer.writeInt(0); // fCount
177 auto data = writer.snapshotAsData();
178 SkReadBuffer reader{data->data(), data->size()};
179 auto ad = SkAutoDescriptor::MakeFromBuffer(reader);
180 REPORTER_ASSERT(r, !ad.has_value());
181 }
182
183 { // garbage in count
184 SkBinaryWriteBuffer writer;
185 // Simulate a broken header
186 writer.writeInt(0); // fChecksum
187 writer.writeInt(20); // fLength
188 writer.writeInt(10); // fCount
189 writer.writeInt(0);
190 writer.writeInt(0);
191 auto data = writer.snapshotAsData();
192 SkReadBuffer reader{data->data(), data->size()};
193 auto ad = SkAutoDescriptor::MakeFromBuffer(reader);
194 REPORTER_ASSERT(r, !ad.has_value());
195 }
196 }
197