| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/resources/display_item_list.h" | |
| 6 | |
| 7 #include <vector> | |
| 8 | |
| 9 #include "cc/output/filter_operation.h" | |
| 10 #include "cc/output/filter_operations.h" | |
| 11 #include "cc/resources/clip_display_item.h" | |
| 12 #include "cc/resources/drawing_display_item.h" | |
| 13 #include "cc/resources/filter_display_item.h" | |
| 14 #include "cc/resources/transform_display_item.h" | |
| 15 #include "cc/test/skia_common.h" | |
| 16 #include "skia/ext/refptr.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 #include "third_party/skia/include/core/SkBitmap.h" | |
| 19 #include "third_party/skia/include/core/SkCanvas.h" | |
| 20 #include "third_party/skia/include/core/SkColor.h" | |
| 21 #include "third_party/skia/include/core/SkPictureRecorder.h" | |
| 22 #include "third_party/skia/include/effects/SkBitmapSource.h" | |
| 23 #include "third_party/skia/include/utils/SkPictureUtils.h" | |
| 24 #include "ui/gfx/geometry/rect_conversions.h" | |
| 25 #include "ui/gfx/skia_util.h" | |
| 26 | |
| 27 namespace cc { | |
| 28 | |
| 29 TEST(DisplayItemListTest, SingleDrawingItem) { | |
| 30 gfx::Rect layer_rect(100, 100); | |
| 31 SkPictureRecorder recorder; | |
| 32 skia::RefPtr<SkCanvas> canvas; | |
| 33 skia::RefPtr<SkPicture> picture; | |
| 34 SkPaint blue_paint; | |
| 35 blue_paint.setColor(SK_ColorBLUE); | |
| 36 SkPaint red_paint; | |
| 37 red_paint.setColor(SK_ColorRED); | |
| 38 unsigned char pixels[4 * 100 * 100] = {0}; | |
| 39 const bool use_cached_picture = true; | |
| 40 scoped_refptr<DisplayItemList> list = | |
| 41 DisplayItemList::Create(layer_rect, use_cached_picture); | |
| 42 | |
| 43 gfx::PointF offset(8.f, 9.f); | |
| 44 gfx::RectF recording_rect(offset, layer_rect.size()); | |
| 45 canvas = skia::SharePtr( | |
| 46 recorder.beginRecording(gfx::RectFToSkRect(recording_rect))); | |
| 47 canvas->translate(offset.x(), offset.y()); | |
| 48 canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); | |
| 49 canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); | |
| 50 picture = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 51 auto* item = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 52 item->SetNew(picture); | |
| 53 list->ProcessAppendedItems(); | |
| 54 list->CreateAndCacheSkPicture(); | |
| 55 DrawDisplayList(pixels, layer_rect, list); | |
| 56 | |
| 57 SkBitmap expected_bitmap; | |
| 58 unsigned char expected_pixels[4 * 100 * 100] = {0}; | |
| 59 SkImageInfo info = | |
| 60 SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height()); | |
| 61 expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes()); | |
| 62 SkCanvas expected_canvas(expected_bitmap); | |
| 63 expected_canvas.clipRect(gfx::RectToSkRect(layer_rect)); | |
| 64 expected_canvas.drawRectCoords(0.f + offset.x(), 0.f + offset.y(), | |
| 65 60.f + offset.x(), 60.f + offset.y(), | |
| 66 red_paint); | |
| 67 expected_canvas.drawRectCoords(50.f + offset.x(), 50.f + offset.y(), | |
| 68 75.f + offset.x(), 75.f + offset.y(), | |
| 69 blue_paint); | |
| 70 | |
| 71 EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100)); | |
| 72 } | |
| 73 | |
| 74 TEST(DisplayItemListTest, ClipItem) { | |
| 75 gfx::Rect layer_rect(100, 100); | |
| 76 SkPictureRecorder recorder; | |
| 77 skia::RefPtr<SkCanvas> canvas; | |
| 78 skia::RefPtr<SkPicture> picture; | |
| 79 SkPaint blue_paint; | |
| 80 blue_paint.setColor(SK_ColorBLUE); | |
| 81 SkPaint red_paint; | |
| 82 red_paint.setColor(SK_ColorRED); | |
| 83 unsigned char pixels[4 * 100 * 100] = {0}; | |
| 84 const bool use_cached_picture = true; | |
| 85 scoped_refptr<DisplayItemList> list = | |
| 86 DisplayItemList::Create(layer_rect, use_cached_picture); | |
| 87 | |
| 88 gfx::PointF first_offset(8.f, 9.f); | |
| 89 gfx::RectF first_recording_rect(first_offset, layer_rect.size()); | |
| 90 canvas = skia::SharePtr( | |
| 91 recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect))); | |
| 92 canvas->translate(first_offset.x(), first_offset.y()); | |
| 93 canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); | |
| 94 picture = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 95 auto* item1 = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 96 item1->SetNew(picture.Pass()); | |
| 97 | |
| 98 gfx::Rect clip_rect(60, 60, 10, 10); | |
| 99 auto* item2 = list->CreateAndAppendItem<ClipDisplayItem>(); | |
| 100 item2->SetNew(clip_rect, std::vector<SkRRect>()); | |
| 101 | |
| 102 gfx::PointF second_offset(2.f, 3.f); | |
| 103 gfx::RectF second_recording_rect(second_offset, layer_rect.size()); | |
| 104 canvas = skia::SharePtr( | |
| 105 recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect))); | |
| 106 canvas->translate(second_offset.x(), second_offset.y()); | |
| 107 canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); | |
| 108 picture = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 109 auto* item3 = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 110 item3->SetNew(picture.Pass()); | |
| 111 | |
| 112 list->CreateAndAppendItem<EndClipDisplayItem>(); | |
| 113 list->ProcessAppendedItems(); | |
| 114 list->CreateAndCacheSkPicture(); | |
| 115 | |
| 116 DrawDisplayList(pixels, layer_rect, list); | |
| 117 | |
| 118 SkBitmap expected_bitmap; | |
| 119 unsigned char expected_pixels[4 * 100 * 100] = {0}; | |
| 120 SkImageInfo info = | |
| 121 SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height()); | |
| 122 expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes()); | |
| 123 SkCanvas expected_canvas(expected_bitmap); | |
| 124 expected_canvas.clipRect(gfx::RectToSkRect(layer_rect)); | |
| 125 expected_canvas.drawRectCoords(0.f + first_offset.x(), 0.f + first_offset.y(), | |
| 126 60.f + first_offset.x(), | |
| 127 60.f + first_offset.y(), red_paint); | |
| 128 expected_canvas.clipRect(gfx::RectToSkRect(clip_rect)); | |
| 129 expected_canvas.drawRectCoords( | |
| 130 50.f + second_offset.x(), 50.f + second_offset.y(), | |
| 131 75.f + second_offset.x(), 75.f + second_offset.y(), blue_paint); | |
| 132 | |
| 133 EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100)); | |
| 134 } | |
| 135 | |
| 136 TEST(DisplayItemListTest, TransformItem) { | |
| 137 gfx::Rect layer_rect(100, 100); | |
| 138 SkPictureRecorder recorder; | |
| 139 skia::RefPtr<SkCanvas> canvas; | |
| 140 skia::RefPtr<SkPicture> picture; | |
| 141 SkPaint blue_paint; | |
| 142 blue_paint.setColor(SK_ColorBLUE); | |
| 143 SkPaint red_paint; | |
| 144 red_paint.setColor(SK_ColorRED); | |
| 145 unsigned char pixels[4 * 100 * 100] = {0}; | |
| 146 const bool use_cached_picture = true; | |
| 147 scoped_refptr<DisplayItemList> list = | |
| 148 DisplayItemList::Create(layer_rect, use_cached_picture); | |
| 149 | |
| 150 gfx::PointF first_offset(8.f, 9.f); | |
| 151 gfx::RectF first_recording_rect(first_offset, layer_rect.size()); | |
| 152 canvas = skia::SharePtr( | |
| 153 recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect))); | |
| 154 canvas->translate(first_offset.x(), first_offset.y()); | |
| 155 canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); | |
| 156 picture = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 157 auto* item1 = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 158 item1->SetNew(picture); | |
| 159 | |
| 160 gfx::Transform transform; | |
| 161 transform.Rotate(45.0); | |
| 162 auto* item2 = list->CreateAndAppendItem<TransformDisplayItem>(); | |
| 163 item2->SetNew(transform); | |
| 164 | |
| 165 gfx::PointF second_offset(2.f, 3.f); | |
| 166 gfx::RectF second_recording_rect(second_offset, layer_rect.size()); | |
| 167 canvas = skia::SharePtr( | |
| 168 recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect))); | |
| 169 canvas->translate(second_offset.x(), second_offset.y()); | |
| 170 canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); | |
| 171 picture = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 172 auto* item3 = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 173 item3->SetNew(picture); | |
| 174 | |
| 175 list->CreateAndAppendItem<EndTransformDisplayItem>(); | |
| 176 list->ProcessAppendedItems(); | |
| 177 list->CreateAndCacheSkPicture(); | |
| 178 | |
| 179 DrawDisplayList(pixels, layer_rect, list); | |
| 180 | |
| 181 SkBitmap expected_bitmap; | |
| 182 unsigned char expected_pixels[4 * 100 * 100] = {0}; | |
| 183 SkImageInfo info = | |
| 184 SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height()); | |
| 185 expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes()); | |
| 186 SkCanvas expected_canvas(expected_bitmap); | |
| 187 expected_canvas.clipRect(gfx::RectToSkRect(layer_rect)); | |
| 188 expected_canvas.drawRectCoords(0.f + first_offset.x(), 0.f + first_offset.y(), | |
| 189 60.f + first_offset.x(), | |
| 190 60.f + first_offset.y(), red_paint); | |
| 191 expected_canvas.setMatrix(transform.matrix()); | |
| 192 expected_canvas.drawRectCoords( | |
| 193 50.f + second_offset.x(), 50.f + second_offset.y(), | |
| 194 75.f + second_offset.x(), 75.f + second_offset.y(), blue_paint); | |
| 195 | |
| 196 EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100)); | |
| 197 } | |
| 198 | |
| 199 TEST(DisplayItemListTest, FilterItem) { | |
| 200 gfx::Rect layer_rect(100, 100); | |
| 201 FilterOperations filters; | |
| 202 unsigned char pixels[4 * 100 * 100] = {0}; | |
| 203 const bool use_cached_picture = true; | |
| 204 scoped_refptr<DisplayItemList> list = | |
| 205 DisplayItemList::Create(layer_rect, use_cached_picture); | |
| 206 | |
| 207 SkBitmap source_bitmap; | |
| 208 source_bitmap.allocN32Pixels(50, 50); | |
| 209 SkCanvas source_canvas(source_bitmap); | |
| 210 source_canvas.clear(SkColorSetRGB(128, 128, 128)); | |
| 211 | |
| 212 // For most SkImageFilters, the |dst| bounds computed by computeFastBounds are | |
| 213 // dependent on the provided |src| bounds. This means, for example, that | |
| 214 // translating |src| results in a corresponding translation of |dst|. But this | |
| 215 // is not the case for all SkImageFilters; for some of them (e.g. | |
| 216 // SkBitmapSource), the computation of |dst| in computeFastBounds doesn't | |
| 217 // involve |src| at all. Incorrectly assuming such a relationship (e.g. by | |
| 218 // translating |dst| after it is computed by computeFastBounds, rather than | |
| 219 // translating |src| before it provided to computedFastBounds) can cause | |
| 220 // incorrect clipping of filter output. To test for this, we include an | |
| 221 // SkBitmapSource filter in |filters|. Here, |src| is |filter_bounds|, defined | |
| 222 // below. | |
| 223 skia::RefPtr<SkImageFilter> image_filter = | |
| 224 skia::AdoptRef(SkBitmapSource::Create(source_bitmap)); | |
| 225 filters.Append(FilterOperation::CreateReferenceFilter(image_filter)); | |
| 226 filters.Append(FilterOperation::CreateBrightnessFilter(0.5f)); | |
| 227 gfx::RectF filter_bounds(10.f, 10.f, 50.f, 50.f); | |
| 228 auto* item = list->CreateAndAppendItem<FilterDisplayItem>(); | |
| 229 item->SetNew(filters, filter_bounds); | |
| 230 list->CreateAndAppendItem<EndFilterDisplayItem>(); | |
| 231 list->ProcessAppendedItems(); | |
| 232 list->CreateAndCacheSkPicture(); | |
| 233 | |
| 234 DrawDisplayList(pixels, layer_rect, list); | |
| 235 | |
| 236 SkBitmap expected_bitmap; | |
| 237 unsigned char expected_pixels[4 * 100 * 100] = {0}; | |
| 238 SkPaint paint; | |
| 239 paint.setColor(SkColorSetRGB(64, 64, 64)); | |
| 240 SkImageInfo info = | |
| 241 SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height()); | |
| 242 expected_bitmap.installPixels(info, expected_pixels, info.minRowBytes()); | |
| 243 SkCanvas expected_canvas(expected_bitmap); | |
| 244 expected_canvas.drawRect(RectFToSkRect(filter_bounds), paint); | |
| 245 | |
| 246 EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100)); | |
| 247 } | |
| 248 | |
| 249 TEST(DisplayItemListTest, CompactingItems) { | |
| 250 gfx::Rect layer_rect(100, 100); | |
| 251 SkPictureRecorder recorder; | |
| 252 skia::RefPtr<SkCanvas> canvas; | |
| 253 skia::RefPtr<SkPicture> picture; | |
| 254 SkPaint blue_paint; | |
| 255 blue_paint.setColor(SK_ColorBLUE); | |
| 256 SkPaint red_paint; | |
| 257 red_paint.setColor(SK_ColorRED); | |
| 258 unsigned char pixels[4 * 100 * 100] = {0}; | |
| 259 | |
| 260 gfx::PointF offset(8.f, 9.f); | |
| 261 gfx::RectF recording_rect(offset, layer_rect.size()); | |
| 262 | |
| 263 bool use_cached_picture = false; | |
| 264 scoped_refptr<DisplayItemList> list_without_caching = | |
| 265 DisplayItemList::Create(layer_rect, use_cached_picture); | |
| 266 | |
| 267 canvas = skia::SharePtr( | |
| 268 recorder.beginRecording(gfx::RectFToSkRect(recording_rect))); | |
| 269 canvas->translate(offset.x(), offset.y()); | |
| 270 canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint); | |
| 271 canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint); | |
| 272 picture = skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 273 auto* item1 = list_without_caching->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 274 item1->SetNew(picture); | |
| 275 list_without_caching->ProcessAppendedItems(); | |
| 276 DrawDisplayList(pixels, layer_rect, list_without_caching); | |
| 277 | |
| 278 unsigned char expected_pixels[4 * 100 * 100] = {0}; | |
| 279 use_cached_picture = true; | |
| 280 scoped_refptr<DisplayItemList> list_with_caching = | |
| 281 DisplayItemList::Create(layer_rect, use_cached_picture); | |
| 282 auto* item2 = list_with_caching->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 283 item2->SetNew(picture); | |
| 284 list_with_caching->ProcessAppendedItems(); | |
| 285 list_with_caching->CreateAndCacheSkPicture(); | |
| 286 DrawDisplayList(expected_pixels, layer_rect, list_with_caching); | |
| 287 | |
| 288 EXPECT_EQ(0, memcmp(pixels, expected_pixels, 4 * 100 * 100)); | |
| 289 } | |
| 290 | |
| 291 TEST(DisplayItemListTest, PictureMemoryUsage) { | |
| 292 scoped_refptr<DisplayItemList> list; | |
| 293 size_t memory_usage; | |
| 294 | |
| 295 // Make an SkPicture whose size is known. | |
| 296 gfx::Rect layer_rect(100, 100); | |
| 297 SkPictureRecorder recorder; | |
| 298 SkPaint blue_paint; | |
| 299 blue_paint.setColor(SK_ColorBLUE); | |
| 300 SkCanvas* canvas = recorder.beginRecording(gfx::RectFToSkRect(layer_rect)); | |
| 301 for (int i = 0; i < 100; i++) | |
| 302 canvas->drawPaint(blue_paint); | |
| 303 skia::RefPtr<SkPicture> picture = | |
| 304 skia::AdoptRef(recorder.endRecordingAsPicture()); | |
| 305 size_t picture_size = SkPictureUtils::ApproximateBytesUsed(picture.get()); | |
| 306 ASSERT_GE(picture_size, 100 * sizeof(SkPaint)); | |
| 307 ASSERT_LE(picture_size, 200 * sizeof(SkPaint)); | |
| 308 | |
| 309 // Using a cached picture, we should get about the right size. | |
| 310 list = DisplayItemList::Create(layer_rect, true); | |
| 311 auto* item = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 312 item->SetNew(picture); | |
| 313 list->ProcessAppendedItems(); | |
| 314 list->CreateAndCacheSkPicture(); | |
| 315 memory_usage = list->PictureMemoryUsage(); | |
| 316 EXPECT_GE(memory_usage, picture_size); | |
| 317 EXPECT_LE(memory_usage, 2 * picture_size); | |
| 318 | |
| 319 // Using no cached picture, we should still get the right size. | |
| 320 list = DisplayItemList::Create(layer_rect, false); | |
| 321 item = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 322 item->SetNew(picture); | |
| 323 list->ProcessAppendedItems(); | |
| 324 memory_usage = list->PictureMemoryUsage(); | |
| 325 EXPECT_GE(memory_usage, picture_size); | |
| 326 EXPECT_LE(memory_usage, 2 * picture_size); | |
| 327 | |
| 328 // To avoid double counting, we expect zero size to be computed if both the | |
| 329 // picture and items are retained (currently this only happens due to certain | |
| 330 // categories being traced). | |
| 331 list = new DisplayItemList(layer_rect, true, true); | |
| 332 item = list->CreateAndAppendItem<DrawingDisplayItem>(); | |
| 333 item->SetNew(picture); | |
| 334 list->ProcessAppendedItems(); | |
| 335 list->CreateAndCacheSkPicture(); | |
| 336 memory_usage = list->PictureMemoryUsage(); | |
| 337 EXPECT_EQ(static_cast<size_t>(0), memory_usage); | |
| 338 } | |
| 339 | |
| 340 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1144693002:
cc: Move files out of cc/resources/. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master