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/paint/test_skcanvas.h" |
| 7 #include "testing/gtest/include/gtest/gtest.h" |
| 8 |
| 9 namespace cc { |
| 10 |
| 11 TEST(PaintOpBufferTest, Empty) { |
| 12 PaintOpBuffer buffer; |
| 13 EXPECT_EQ(buffer.approximateOpCount(), 0); |
| 14 EXPECT_EQ(buffer.approximateBytesUsed(), sizeof(PaintOpBuffer)); |
| 15 EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false); |
| 16 |
| 17 buffer.Reset(); |
| 18 EXPECT_EQ(buffer.approximateOpCount(), 0); |
| 19 EXPECT_EQ(buffer.approximateBytesUsed(), sizeof(PaintOpBuffer)); |
| 20 EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false); |
| 21 } |
| 22 |
| 23 TEST(PaintOpBufferTest, SimpleAppend) { |
| 24 SkRect rect = SkRect::MakeXYWH(2, 3, 4, 5); |
| 25 PaintFlags flags; |
| 26 flags.setColor(SK_ColorMAGENTA); |
| 27 flags.setAlpha(100); |
| 28 SkColor draw_color = SK_ColorRED; |
| 29 SkBlendMode blend = SkBlendMode::kSrc; |
| 30 |
| 31 PaintOpBuffer buffer; |
| 32 buffer.push<SaveLayerOp>(&rect, &flags); |
| 33 buffer.push<SaveOp>(); |
| 34 buffer.push<DrawColorOp>(draw_color, blend); |
| 35 buffer.push<RestoreOp>(); |
| 36 |
| 37 EXPECT_EQ(buffer.approximateOpCount(), 4); |
| 38 |
| 39 PaintOpBuffer::Iterator iter(&buffer); |
| 40 ASSERT_EQ(iter->GetType(), PaintOpType::SaveLayer); |
| 41 SaveLayerOp* save_op = static_cast<SaveLayerOp*>(*iter); |
| 42 EXPECT_EQ(save_op->bounds, rect); |
| 43 EXPECT_TRUE(save_op->flags == flags); |
| 44 ++iter; |
| 45 |
| 46 ASSERT_EQ(iter->GetType(), PaintOpType::Save); |
| 47 ++iter; |
| 48 |
| 49 ASSERT_EQ(iter->GetType(), PaintOpType::DrawColor); |
| 50 DrawColorOp* op = static_cast<DrawColorOp*>(*iter); |
| 51 EXPECT_EQ(op->color, draw_color); |
| 52 EXPECT_EQ(op->mode, blend); |
| 53 ++iter; |
| 54 |
| 55 ASSERT_EQ(iter->GetType(), PaintOpType::Restore); |
| 56 ++iter; |
| 57 |
| 58 EXPECT_FALSE(iter); |
| 59 } |
| 60 |
| 61 // PaintOpBuffer has a special case for first ops stored locally, so |
| 62 // make sure that appending different kind of ops as a first op works |
| 63 // properly, as well as resetting and reusing the first local op. |
| 64 TEST(PaintOpBufferTest, FirstOpWithAndWithoutData) { |
| 65 PaintOpBuffer buffer; |
| 66 char text[] = "asdf"; |
| 67 |
| 68 // Use a color filter and its ref count to verify that the destructor |
| 69 // is called on ops after reset. |
| 70 PaintFlags flags; |
| 71 sk_sp<SkColorFilter> filter = |
| 72 SkColorFilter::MakeModeFilter(SK_ColorMAGENTA, SkBlendMode::kSrcOver); |
| 73 flags.setColorFilter(filter); |
| 74 EXPECT_EQ(filter->getRefCnt(), 2); |
| 75 |
| 76 buffer.push_with_data<DrawTextOp>(text, arraysize(text), 0.f, 0.f, flags); |
| 77 EXPECT_EQ(filter->getRefCnt(), 3); |
| 78 |
| 79 // Verify that when the first op has data, which may not fit in the |
| 80 // PaintRecord internal buffer, that it adds a noop as the first op |
| 81 // and then appends the "op with data" into the heap buffer. |
| 82 ASSERT_EQ(buffer.approximateOpCount(), 2); |
| 83 EXPECT_EQ(buffer.GetFirstOp()->GetType(), PaintOpType::Noop); |
| 84 |
| 85 // Verify iteration behavior and brief smoke test of op state. |
| 86 { |
| 87 PaintOpBuffer::Iterator iter(&buffer); |
| 88 PaintOp* noop = *iter; |
| 89 EXPECT_EQ(buffer.GetFirstOp(), noop); |
| 90 ++iter; |
| 91 |
| 92 PaintOp* op = *iter; |
| 93 ASSERT_EQ(op->GetType(), PaintOpType::DrawText); |
| 94 DrawTextOp* draw_text_op = static_cast<DrawTextOp*>(op); |
| 95 EXPECT_EQ(draw_text_op->bytes, arraysize(text)); |
| 96 |
| 97 void* data = paint_op_data(draw_text_op); |
| 98 EXPECT_EQ(memcmp(data, text, arraysize(text)), 0); |
| 99 |
| 100 ++iter; |
| 101 EXPECT_FALSE(iter); |
| 102 } |
| 103 |
| 104 // Reset, verify state, and append an op that will fit in the first slot. |
| 105 buffer.Reset(); |
| 106 EXPECT_EQ(filter->getRefCnt(), 2); |
| 107 |
| 108 ASSERT_EQ(buffer.approximateOpCount(), 0); |
| 109 EXPECT_EQ(PaintOpBuffer::Iterator(&buffer), false); |
| 110 |
| 111 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 112 buffer.push<DrawRectOp>(rect, flags); |
| 113 EXPECT_EQ(filter->getRefCnt(), 3); |
| 114 |
| 115 ASSERT_EQ(buffer.approximateOpCount(), 1); |
| 116 EXPECT_EQ(buffer.GetFirstOp()->GetType(), PaintOpType::DrawRect); |
| 117 |
| 118 PaintOpBuffer::Iterator iter(&buffer); |
| 119 ASSERT_EQ(iter->GetType(), PaintOpType::DrawRect); |
| 120 DrawRectOp* draw_rect_op = static_cast<DrawRectOp*>(*iter); |
| 121 EXPECT_EQ(draw_rect_op->rect, rect); |
| 122 |
| 123 ++iter; |
| 124 EXPECT_FALSE(iter); |
| 125 |
| 126 buffer.Reset(); |
| 127 ASSERT_EQ(buffer.approximateOpCount(), 0); |
| 128 EXPECT_EQ(filter->getRefCnt(), 2); |
| 129 } |
| 130 |
| 131 TEST(PaintOpBufferTest, Peek) { |
| 132 PaintOpBuffer buffer; |
| 133 |
| 134 uint8_t alpha = 100; |
| 135 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 136 PaintFlags draw_flags; |
| 137 buffer.push<DrawRectOp>(SkRect::MakeXYWH(1, 2, 3, 4), draw_flags); |
| 138 buffer.push<RestoreOp>(); |
| 139 buffer.push<SaveOp>(); |
| 140 buffer.push<NoopOp>(); |
| 141 buffer.push<RestoreOp>(); |
| 142 |
| 143 PaintOpBuffer::Iterator init_iter(&buffer); |
| 144 PaintOp* peek[2] = {*init_iter, init_iter.peek1()}; |
| 145 |
| 146 // Expect that while iterating that next = current.peek1() and that |
| 147 // next.peek1() == current.peek2(). |
| 148 for (PaintOpBuffer::Iterator iter(&buffer); iter; ++iter) { |
| 149 EXPECT_EQ(*iter, peek[0]) << iter.op_idx(); |
| 150 EXPECT_EQ(iter.peek1(), peek[1]) << iter.op_idx(); |
| 151 |
| 152 peek[0] = iter.peek1(); |
| 153 peek[1] = iter.peek2(); |
| 154 } |
| 155 } |
| 156 |
| 157 TEST(PaintOpBufferTest, PeekEmpty) { |
| 158 PaintOpBuffer empty; |
| 159 PaintOpBuffer::Iterator empty_iter(&empty); |
| 160 EXPECT_EQ(nullptr, empty_iter.peek1()); |
| 161 EXPECT_EQ(nullptr, empty_iter.peek2()); |
| 162 } |
| 163 |
| 164 // Verify that a SaveLayerAlpha / Draw / Restore can be optimized to just |
| 165 // a draw with opacity. |
| 166 TEST(PaintOpBufferTest, SaveDrawRestore) { |
| 167 PaintOpBuffer buffer; |
| 168 |
| 169 uint8_t alpha = 100; |
| 170 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 171 |
| 172 PaintFlags draw_flags; |
| 173 draw_flags.setColor(SK_ColorMAGENTA); |
| 174 draw_flags.setAlpha(50); |
| 175 EXPECT_TRUE(draw_flags.SupportsFoldingAlpha()); |
| 176 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 177 buffer.push<DrawRectOp>(rect, draw_flags); |
| 178 buffer.push<RestoreOp>(); |
| 179 |
| 180 SaveCountingCanvas canvas; |
| 181 buffer.playback(&canvas); |
| 182 |
| 183 EXPECT_EQ(0, canvas.restore_count_); |
| 184 EXPECT_EQ(rect, canvas.draw_rect_); |
| 185 |
| 186 // Expect the alpha from the draw and the save layer to be folded together. |
| 187 // Since alpha is stored in a uint8_t and gets rounded, so use tolerance. |
| 188 float expected_alpha = alpha * 50 / 255.f; |
| 189 EXPECT_LE(std::abs(expected_alpha - canvas.paint_.getAlpha()), 1.f); |
| 190 } |
| 191 |
| 192 // The same as SaveDrawRestore, but test that the optimization doesn't apply |
| 193 // when the drawing op's flags are not compatible with being folded into the |
| 194 // save layer with opacity. |
| 195 TEST(PaintOpBufferTest, SaveDrawRestoreFail_BadFlags) { |
| 196 PaintOpBuffer buffer; |
| 197 |
| 198 uint8_t alpha = 100; |
| 199 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 200 |
| 201 PaintFlags draw_flags; |
| 202 draw_flags.setColor(SK_ColorMAGENTA); |
| 203 draw_flags.setAlpha(50); |
| 204 draw_flags.setBlendMode(SkBlendMode::kSrc); |
| 205 EXPECT_FALSE(draw_flags.SupportsFoldingAlpha()); |
| 206 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 207 buffer.push<DrawRectOp>(rect, draw_flags); |
| 208 buffer.push<RestoreOp>(); |
| 209 |
| 210 SaveCountingCanvas canvas; |
| 211 buffer.playback(&canvas); |
| 212 |
| 213 EXPECT_EQ(1, canvas.restore_count_); |
| 214 EXPECT_EQ(rect, canvas.draw_rect_); |
| 215 EXPECT_EQ(draw_flags.getAlpha(), canvas.paint_.getAlpha()); |
| 216 } |
| 217 |
| 218 // The same as SaveDrawRestore, but test that the optimization doesn't apply |
| 219 // when there are more than one ops between the save and restore. |
| 220 TEST(PaintOpBufferTest, SaveDrawRestoreFail_TooManyOps) { |
| 221 PaintOpBuffer buffer; |
| 222 |
| 223 uint8_t alpha = 100; |
| 224 buffer.push<SaveLayerAlphaOp>(nullptr, alpha); |
| 225 |
| 226 PaintFlags draw_flags; |
| 227 draw_flags.setColor(SK_ColorMAGENTA); |
| 228 draw_flags.setAlpha(50); |
| 229 draw_flags.setBlendMode(SkBlendMode::kSrcOver); |
| 230 EXPECT_TRUE(draw_flags.SupportsFoldingAlpha()); |
| 231 SkRect rect = SkRect::MakeXYWH(1, 2, 3, 4); |
| 232 buffer.push<DrawRectOp>(rect, draw_flags); |
| 233 buffer.push<NoopOp>(); |
| 234 buffer.push<RestoreOp>(); |
| 235 |
| 236 SaveCountingCanvas canvas; |
| 237 buffer.playback(&canvas); |
| 238 |
| 239 EXPECT_EQ(1, canvas.restore_count_); |
| 240 EXPECT_EQ(rect, canvas.draw_rect_); |
| 241 EXPECT_EQ(draw_flags.getAlpha(), canvas.paint_.getAlpha()); |
| 242 } |
| 243 |
| 244 } // namespace cc |
OLD | NEW |