OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "cc/paint/paint_op_buffer.h" |
| 6 #include "cc/test/test_skcanvas.h" |
| 7 #include "testing/gtest/include/gtest/gtest.h" |
| 8 |
| 9 namespace { |
| 10 |
| 11 template <typename T> |
| 12 void CheckRefCnt(const T& obj, int32_t count) { |
| 13 // Skia doesn't define getRefCnt in all builds. |
| 14 #ifdef SK_DEBUG |
| 15 EXPECT_EQ(obj->getRefCnt(), count); |
| 16 #endif |
| 17 } |
| 18 |
| 19 } // namespace |
| 20 |
| 21 namespace cc { |
| 22 |
| 23 TEST(PaintOpBufferTest, Empty) { |
| 24 PaintOpBuffer buffer; |
| 25 EXPECT_EQ(buffer.approximateOpCount(), 0); |
| 26 EXPECT_EQ(buffer.approximateBytesUsed(), sizeof(PaintOpBuffer)); |
| 27 EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false); |
| 28 |
| 29 buffer.Reset(); |
| 30 EXPECT_EQ(buffer.approximateOpCount(), 0); |
| 31 EXPECT_EQ(buffer.approximateBytesUsed(), sizeof(PaintOpBuffer)); |
| 32 EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false); |
| 33 } |
| 34 |
| 35 TEST(PaintOpBufferTest, SimpleAppend) { |
| 36 SkRect rect = SkRect::MakeXYWH(2, 3, 4, 5); |
| 37 PaintFlags flags; |
| 38 flags.setColor(SK_ColorMAGENTA); |
| 39 flags.setAlpha(100); |
| 40 SkColor draw_color = SK_ColorRED; |
| 41 SkBlendMode blend = SkBlendMode::kSrc; |
| 42 |
| 43 PaintOpBuffer buffer; |
| 44 buffer.push<SaveLayerOp>(&rect, &flags); |
| 45 buffer.push<SaveOp>(); |
| 46 buffer.push<DrawColorOp>(draw_color, blend); |
| 47 buffer.push<RestoreOp>(); |
| 48 |
| 49 EXPECT_EQ(buffer.approximateOpCount(), 4); |
| 50 |
| 51 PaintOpBuffer::Iterator iter(&buffer); |
| 52 ASSERT_EQ(iter->GetType(), PaintOpType::SaveLayer); |
| 53 SaveLayerOp* save_op = static_cast<SaveLayerOp*>(*iter); |
| 54 EXPECT_EQ(save_op->bounds, rect); |
| 55 EXPECT_TRUE(save_op->flags == flags); |
| 56 ++iter; |
| 57 |
| 58 ASSERT_EQ(iter->GetType(), PaintOpType::Save); |
| 59 ++iter; |
| 60 |
| 61 ASSERT_EQ(iter->GetType(), PaintOpType::DrawColor); |
| 62 DrawColorOp* op = static_cast<DrawColorOp*>(*iter); |
| 63 EXPECT_EQ(op->color, draw_color); |
| 64 EXPECT_EQ(op->mode, blend); |
| 65 ++iter; |
| 66 |
| 67 ASSERT_EQ(iter->GetType(), PaintOpType::Restore); |
| 68 ++iter; |
| 69 |
| 70 EXPECT_FALSE(iter); |
| 71 } |
| 72 |
| 73 // PaintOpBuffer has a special case for first ops stored locally, so |
| 74 // make sure that appending different kind of ops as a first op works |
| 75 // properly, as well as resetting and reusing the first local op. |
| 76 TEST(PaintOpBufferTest, FirstOpWithAndWithoutData) { |
| 77 PaintOpBuffer buffer; |
| 78 char text[] = "asdf"; |
| 79 |
| 80 // Use a color filter and its ref count to verify that the destructor |
| 81 // is called on ops after reset. |
| 82 PaintFlags flags; |
| 83 sk_sp<SkColorFilter> filter = |
| 84 SkColorFilter::MakeModeFilter(SK_ColorMAGENTA, SkBlendMode::kSrcOver); |
| 85 flags.setColorFilter(filter); |
| 86 CheckRefCnt(filter, 2); |
| 87 |
| 88 buffer.push_with_data<DrawTextOp>(text, arraysize(text), 0.f, 0.f, flags); |
| 89 CheckRefCnt(filter, 3); |
| 90 |
| 91 // Verify that when the first op has data, which may not fit in the |
| 92 // PaintRecord internal buffer, that it adds a noop as the first op |
| 93 // and then appends the "op with data" into the heap buffer. |
| 94 ASSERT_EQ(buffer.approximateOpCount(), 2); |
| 95 EXPECT_EQ(buffer.GetFirstOp()->GetType(), PaintOpType::Noop); |
| 96 |
| 97 // Verify iteration behavior and brief smoke test of op state. |
| 98 { |
| 99 PaintOpBuffer::Iterator iter(&buffer); |
| 100 PaintOp* noop = *iter; |
| 101 EXPECT_EQ(buffer.GetFirstOp(), noop); |
| 102 ++iter; |
| 103 |
| 104 PaintOp* op = *iter; |
| 105 ASSERT_EQ(op->GetType(), PaintOpType::DrawText); |
| 106 DrawTextOp* draw_text_op = static_cast<DrawTextOp*>(op); |
| 107 EXPECT_EQ(draw_text_op->bytes, arraysize(text)); |
| 108 |
| 109 void* data = paint_op_data(draw_text_op); |
| 110 EXPECT_EQ(memcmp(data, text, arraysize(text)), 0); |
| 111 |
| 112 ++iter; |
| 113 EXPECT_FALSE(iter); |
| 114 } |
| 115 |
| 116 // Reset, verify state, and append an op that will fit in the first slot. |
| 117 buffer.Reset(); |
| 118 CheckRefCnt(filter, 2); |
| 119 |
| 120 ASSERT_EQ(buffer.approximateOpCount(), 0); |
| 121 EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false); |
| 122 |
| 123 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 124 buffer.push<DrawRectOp>(rect, flags); |
| 125 CheckRefCnt(filter, 3); |
| 126 |
| 127 ASSERT_EQ(buffer.approximateOpCount(), 1); |
| 128 EXPECT_EQ(buffer.GetFirstOp()->GetType(), PaintOpType::DrawRect); |
| 129 |
| 130 PaintOpBuffer::Iterator iter(&buffer); |
| 131 ASSERT_EQ(iter->GetType(), PaintOpType::DrawRect); |
| 132 DrawRectOp* draw_rect_op = static_cast<DrawRectOp*>(*iter); |
| 133 EXPECT_EQ(draw_rect_op->rect, rect); |
| 134 |
| 135 ++iter; |
| 136 EXPECT_FALSE(iter); |
| 137 |
| 138 buffer.Reset(); |
| 139 ASSERT_EQ(buffer.approximateOpCount(), 0); |
| 140 CheckRefCnt(filter, 2); |
| 141 } |
| 142 |
| 143 TEST(PaintOpBufferTest, Peek) { |
| 144 PaintOpBuffer buffer; |
| 145 |
| 146 uint8_t alpha = 100; |
| 147 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 148 PaintFlags draw_flags; |
| 149 buffer.push<DrawRectOp>(SkRect::MakeXYWH(1, 2, 3, 4), draw_flags); |
| 150 buffer.push<RestoreOp>(); |
| 151 buffer.push<SaveOp>(); |
| 152 buffer.push<NoopOp>(); |
| 153 buffer.push<RestoreOp>(); |
| 154 |
| 155 PaintOpBuffer::Iterator init_iter(&buffer); |
| 156 PaintOp* peek[2] = {*init_iter, init_iter.peek1()}; |
| 157 |
| 158 // Expect that while iterating that next = current.peek1() and that |
| 159 // next.peek1() == current.peek2(). |
| 160 for (PaintOpBuffer::Iterator iter(&buffer); iter; ++iter) { |
| 161 EXPECT_EQ(*iter, peek[0]) << iter.op_idx(); |
| 162 EXPECT_EQ(iter.peek1(), peek[1]) << iter.op_idx(); |
| 163 |
| 164 peek[0] = iter.peek1(); |
| 165 peek[1] = iter.peek2(); |
| 166 } |
| 167 } |
| 168 |
| 169 TEST(PaintOpBufferTest, PeekEmpty) { |
| 170 PaintOpBuffer empty; |
| 171 PaintOpBuffer::Iterator empty_iter(&empty); |
| 172 EXPECT_EQ(nullptr, empty_iter.peek1()); |
| 173 EXPECT_EQ(nullptr, empty_iter.peek2()); |
| 174 } |
| 175 |
| 176 // Verify that a SaveLayerAlpha / Draw / Restore can be optimized to just |
| 177 // a draw with opacity. |
| 178 TEST(PaintOpBufferTest, SaveDrawRestore) { |
| 179 PaintOpBuffer buffer; |
| 180 |
| 181 uint8_t alpha = 100; |
| 182 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 183 |
| 184 PaintFlags draw_flags; |
| 185 draw_flags.setColor(SK_ColorMAGENTA); |
| 186 draw_flags.setAlpha(50); |
| 187 EXPECT_TRUE(draw_flags.SupportsFoldingAlpha()); |
| 188 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 189 buffer.push<DrawRectOp>(rect, draw_flags); |
| 190 buffer.push<RestoreOp>(); |
| 191 |
| 192 SaveCountingCanvas canvas; |
| 193 buffer.playback(&canvas); |
| 194 |
| 195 EXPECT_EQ(0, canvas.save_count_); |
| 196 EXPECT_EQ(0, canvas.restore_count_); |
| 197 EXPECT_EQ(rect, canvas.draw_rect_); |
| 198 |
| 199 // Expect the alpha from the draw and the save layer to be folded together. |
| 200 // Since alpha is stored in a uint8_t and gets rounded, so use tolerance. |
| 201 float expected_alpha = alpha * 50 / 255.f; |
| 202 EXPECT_LE(std::abs(expected_alpha - canvas.paint_.getAlpha()), 1.f); |
| 203 } |
| 204 |
| 205 // The same as SaveDrawRestore, but test that the optimization doesn't apply |
| 206 // when the drawing op's flags are not compatible with being folded into the |
| 207 // save layer with opacity. |
| 208 TEST(PaintOpBufferTest, SaveDrawRestoreFail_BadFlags) { |
| 209 PaintOpBuffer buffer; |
| 210 |
| 211 uint8_t alpha = 100; |
| 212 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 213 |
| 214 PaintFlags draw_flags; |
| 215 draw_flags.setColor(SK_ColorMAGENTA); |
| 216 draw_flags.setAlpha(50); |
| 217 draw_flags.setBlendMode(SkBlendMode::kSrc); |
| 218 EXPECT_FALSE(draw_flags.SupportsFoldingAlpha()); |
| 219 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 220 buffer.push<DrawRectOp>(rect, draw_flags); |
| 221 buffer.push<RestoreOp>(); |
| 222 |
| 223 SaveCountingCanvas canvas; |
| 224 buffer.playback(&canvas); |
| 225 |
| 226 EXPECT_EQ(1, canvas.save_count_); |
| 227 EXPECT_EQ(1, canvas.restore_count_); |
| 228 EXPECT_EQ(rect, canvas.draw_rect_); |
| 229 EXPECT_EQ(draw_flags.getAlpha(), canvas.paint_.getAlpha()); |
| 230 } |
| 231 |
| 232 // The same as SaveDrawRestore, but test that the optimization doesn't apply |
| 233 // when there are more than one ops between the save and restore. |
| 234 TEST(PaintOpBufferTest, SaveDrawRestoreFail_TooManyOps) { |
| 235 PaintOpBuffer buffer; |
| 236 |
| 237 uint8_t alpha = 100; |
| 238 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 239 |
| 240 PaintFlags draw_flags; |
| 241 draw_flags.setColor(SK_ColorMAGENTA); |
| 242 draw_flags.setAlpha(50); |
| 243 draw_flags.setBlendMode(SkBlendMode::kSrcOver); |
| 244 EXPECT_TRUE(draw_flags.SupportsFoldingAlpha()); |
| 245 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 246 buffer.push<DrawRectOp>(rect, draw_flags); |
| 247 buffer.push<NoopOp>(); |
| 248 buffer.push<RestoreOp>(); |
| 249 |
| 250 SaveCountingCanvas canvas; |
| 251 buffer.playback(&canvas); |
| 252 |
| 253 EXPECT_EQ(1, canvas.save_count_); |
| 254 EXPECT_EQ(1, canvas.restore_count_); |
| 255 EXPECT_EQ(rect, canvas.draw_rect_); |
| 256 EXPECT_EQ(draw_flags.getAlpha(), canvas.paint_.getAlpha()); |
| 257 } |
| 258 |
| 259 // Verify that the save draw restore code works with a single op |
| 260 // that's not a draw op, and the optimization does not kick in. |
| 261 TEST(PaintOpBufferTest, SaveDrawRestore_SingleOpNotADrawOp) { |
| 262 PaintOpBuffer buffer; |
| 263 |
| 264 uint8_t alpha = 100; |
| 265 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 266 |
| 267 buffer.push<NoopOp>(); |
| 268 buffer.push<RestoreOp>(); |
| 269 |
| 270 SaveCountingCanvas canvas; |
| 271 buffer.playback(&canvas); |
| 272 |
| 273 EXPECT_EQ(1, canvas.save_count_); |
| 274 EXPECT_EQ(1, canvas.restore_count_); |
| 275 } |
| 276 |
| 277 // Test that the save/draw/restore optimization applies if the single op |
| 278 // is a DrawRecord that itself has a single draw op. |
| 279 TEST(PaintOpBufferTest, SaveDrawRestore_SingleOpRecordWithSingleOp) { |
| 280 sk_sp<PaintRecord> record = sk_make_sp<PaintRecord>(); |
| 281 |
| 282 PaintFlags draw_flags; |
| 283 draw_flags.setColor(SK_ColorMAGENTA); |
| 284 draw_flags.setAlpha(50); |
| 285 EXPECT_TRUE(draw_flags.SupportsFoldingAlpha()); |
| 286 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 287 record->push<DrawRectOp>(rect, draw_flags); |
| 288 EXPECT_EQ(record->approximateOpCount(), 1); |
| 289 |
| 290 PaintOpBuffer buffer; |
| 291 |
| 292 uint8_t alpha = 100; |
| 293 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 294 buffer.push<DrawRecordOp>(std::move(record)); |
| 295 buffer.push<RestoreOp>(); |
| 296 |
| 297 SaveCountingCanvas canvas; |
| 298 buffer.playback(&canvas); |
| 299 |
| 300 EXPECT_EQ(0, canvas.save_count_); |
| 301 EXPECT_EQ(0, canvas.restore_count_); |
| 302 EXPECT_EQ(rect, canvas.draw_rect_); |
| 303 |
| 304 float expected_alpha = alpha * 50 / 255.f; |
| 305 EXPECT_LE(std::abs(expected_alpha - canvas.paint_.getAlpha()), 1.f); |
| 306 } |
| 307 |
| 308 // The same as the above SingleOpRecord test, but the single op is not |
| 309 // a draw op. So, there's no way to fold in the save layer optimization. |
| 310 // Verify that the optimization doesn't apply and that this doesn't crash. |
| 311 // See: http://crbug.com/712093. |
| 312 TEST(PaintOpBufferTest, SaveDrawRestore_SingleOpRecordWithSingleNonDrawOp) { |
| 313 sk_sp<PaintRecord> record = sk_make_sp<PaintRecord>(); |
| 314 record->push<NoopOp>(); |
| 315 EXPECT_EQ(record->approximateOpCount(), 1); |
| 316 EXPECT_FALSE(record->GetFirstOp()->IsDrawOp()); |
| 317 |
| 318 PaintOpBuffer buffer; |
| 319 |
| 320 uint8_t alpha = 100; |
| 321 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 322 buffer.push<DrawRecordOp>(std::move(record)); |
| 323 buffer.push<RestoreOp>(); |
| 324 |
| 325 SaveCountingCanvas canvas; |
| 326 buffer.playback(&canvas); |
| 327 |
| 328 EXPECT_EQ(1, canvas.save_count_); |
| 329 EXPECT_EQ(1, canvas.restore_count_); |
| 330 } |
| 331 |
| 332 } // namespace cc |
OLD | NEW |