| /* |
| * Copyright (c) 2013, Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "third_party/blink/renderer/core/imagebitmap/image_bitmap.h" |
| |
| #include "base/test/null_task_runner.h" |
| #include "build/build_config.h" |
| #include "components/viz/test/test_raster_interface.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h" |
| #include "third_party/blink/renderer/core/dom/document.h" |
| #include "third_party/blink/renderer/core/frame/local_frame_view.h" |
| #include "third_party/blink/renderer/core/html/canvas/html_canvas_element.h" |
| #include "third_party/blink/renderer/core/html/canvas/image_data.h" |
| #include "third_party/blink/renderer/core/html/html_image_element.h" |
| #include "third_party/blink/renderer/core/html/media/html_video_element.h" |
| #include "third_party/blink/renderer/core/loader/resource/image_resource_content.h" |
| #include "third_party/blink/renderer/core/testing/dummy_page_holder.h" |
| #include "third_party/blink/renderer/platform/graphics/accelerated_static_bitmap_image.h" |
| #include "third_party/blink/renderer/platform/graphics/gpu/shared_gpu_context.h" |
| #include "third_party/blink/renderer/platform/graphics/skia/skia_utils.h" |
| #include "third_party/blink/renderer/platform/graphics/test/fake_gles2_interface.h" |
| #include "third_party/blink/renderer/platform/graphics/test/fake_web_graphics_context_3d_provider.h" |
| #include "third_party/blink/renderer/platform/graphics/test/gpu_test_utils.h" |
| #include "third_party/blink/renderer/platform/graphics/unaccelerated_static_bitmap_image.h" |
| #include "third_party/blink/renderer/platform/heap/garbage_collected.h" |
| #include "third_party/blink/renderer/platform/heap/thread_state.h" |
| #include "third_party/blink/renderer/platform/image-decoders/image_decoder.h" |
| #include "third_party/blink/renderer/platform/loader/fetch/fetch_parameters.h" |
| #include "third_party/blink/renderer/platform/loader/fetch/memory_cache.h" |
| #include "third_party/blink/renderer/platform/loader/fetch/resource_request.h" |
| #include "third_party/blink/renderer/platform/testing/task_environment.h" |
| #include "third_party/skia/include/core/SkCanvas.h" |
| #include "third_party/skia/include/core/SkImage.h" |
| #include "third_party/skia/include/core/SkPixelRef.h" |
| #include "third_party/skia/include/core/SkSurface.h" |
| |
| namespace blink { |
| |
| class ExceptionState; |
| |
| class ImageBitmapTest : public testing::Test { |
| protected: |
| ImageBitmapTest() |
| : scoped_memory_cache_(MakeGarbageCollected<MemoryCache>( |
| blink::scheduler::GetSingleThreadTaskRunnerForTesting())) {} |
| |
| void SetUp() override { |
| sk_sp<SkSurface> surface = |
| SkSurfaces::Raster(SkImageInfo::MakeN32Premul(10, 10)); |
| surface->getCanvas()->clear(0xFFFFFFFF); |
| image_ = surface->makeImageSnapshot(); |
| |
| sk_sp<SkSurface> surface2 = |
| SkSurfaces::Raster(SkImageInfo::MakeN32Premul(5, 5)); |
| surface2->getCanvas()->clear(0xAAAAAAAA); |
| image2_ = surface2->makeImageSnapshot(); |
| |
| test_context_provider_ = viz::TestContextProvider::CreateRaster(); |
| InitializeSharedGpuContext(test_context_provider_.get()); |
| } |
| |
| void TearDown() override { |
| // Garbage collection is required prior to switching out the |
| // test's memory cache; image resources are released, evicting |
| // them from the cache. |
| ThreadState::Current()->CollectAllGarbageForTesting( |
| ThreadState::StackState::kNoHeapPointers); |
| |
| SharedGpuContext::Reset(); |
| } |
| |
| protected: |
| test::TaskEnvironment task_environment_; |
| scoped_refptr<viz::TestContextProvider> test_context_provider_; |
| sk_sp<SkImage> image_, image2_; |
| ScopedMemoryCacheForTesting scoped_memory_cache_; |
| }; |
| |
| TEST_F(ImageBitmapTest, ImageResourceConsistency) { |
| const ImageBitmapOptions* default_options = ImageBitmapOptions::Create(); |
| auto dummy = std::make_unique<DummyPageHolder>(gfx::Size(800, 600)); |
| auto* image_element = |
| MakeGarbageCollected<HTMLImageElement>(dummy->GetDocument()); |
| sk_sp<SkColorSpace> src_rgb_color_space = SkColorSpace::MakeSRGB(); |
| SkImageInfo raster_image_info = |
| SkImageInfo::MakeN32Premul(5, 5, src_rgb_color_space); |
| sk_sp<SkSurface> surface(SkSurfaces::Raster(raster_image_info)); |
| sk_sp<SkImage> image = surface->makeImageSnapshot(); |
| ImageResourceContent* original_image_content = |
| ImageResourceContent::CreateLoaded( |
| UnacceleratedStaticBitmapImage::Create(image).get()); |
| image_element->SetImageForTest(original_image_content); |
| |
| std::optional<gfx::Rect> crop_rect = |
| gfx::Rect(0, 0, image_element->width(), image_element->height()); |
| auto* image_bitmap_no_crop = MakeGarbageCollected<ImageBitmap>( |
| image_element, crop_rect, default_options); |
| ASSERT_TRUE(image_bitmap_no_crop); |
| crop_rect = |
| gfx::Rect(image_element->width() / 2, image_element->height() / 2, |
| image_element->width() / 2, image_element->height() / 2); |
| auto* image_bitmap_interior_crop = MakeGarbageCollected<ImageBitmap>( |
| image_element, crop_rect, default_options); |
| ASSERT_TRUE(image_bitmap_interior_crop); |
| crop_rect = |
| gfx::Rect(-image_element->width() / 2, -image_element->height() / 2, |
| image_element->width(), image_element->height()); |
| auto* image_bitmap_exterior_crop = MakeGarbageCollected<ImageBitmap>( |
| image_element, crop_rect, default_options); |
| ASSERT_TRUE(image_bitmap_exterior_crop); |
| crop_rect = gfx::Rect(-image_element->width(), -image_element->height(), |
| image_element->width(), image_element->height()); |
| auto* image_bitmap_outside_crop = MakeGarbageCollected<ImageBitmap>( |
| image_element, crop_rect, default_options); |
| ASSERT_TRUE(image_bitmap_outside_crop); |
| |
| ASSERT_EQ(image_bitmap_no_crop->BitmapImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage(), |
| image_element->CachedImage() |
| ->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| ASSERT_NE(image_bitmap_interior_crop->BitmapImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage(), |
| image_element->CachedImage() |
| ->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| ASSERT_NE(image_bitmap_exterior_crop->BitmapImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage(), |
| image_element->CachedImage() |
| ->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| |
| scoped_refptr<StaticBitmapImage> empty_image = |
| image_bitmap_outside_crop->BitmapImage(); |
| ASSERT_NE(empty_image->PaintImageForCurrentFrame().GetSwSkImage(), |
| image_element->CachedImage() |
| ->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| } |
| |
| // Verifies that ImageBitmaps constructed from HTMLImageElements hold a |
| // reference to the original Image if the HTMLImageElement src is changed. |
| TEST_F(ImageBitmapTest, ImageBitmapSourceChanged) { |
| auto dummy = std::make_unique<DummyPageHolder>(gfx::Size(800, 600)); |
| auto* image = MakeGarbageCollected<HTMLImageElement>(dummy->GetDocument()); |
| sk_sp<SkColorSpace> src_rgb_color_space = SkColorSpace::MakeSRGB(); |
| SkImageInfo raster_image_info = |
| SkImageInfo::MakeN32Premul(5, 5, src_rgb_color_space); |
| sk_sp<SkSurface> raster_surface(SkSurfaces::Raster(raster_image_info)); |
| sk_sp<SkImage> raster_image = raster_surface->makeImageSnapshot(); |
| ImageResourceContent* original_image_content = |
| ImageResourceContent::CreateLoaded( |
| UnacceleratedStaticBitmapImage::Create(raster_image).get()); |
| image->SetImageForTest(original_image_content); |
| |
| const ImageBitmapOptions* default_options = ImageBitmapOptions::Create(); |
| std::optional<gfx::Rect> crop_rect = |
| gfx::Rect(0, 0, image->width(), image->height()); |
| auto* image_bitmap = |
| MakeGarbageCollected<ImageBitmap>(image, crop_rect, default_options); |
| ASSERT_TRUE(image_bitmap); |
| ASSERT_EQ( |
| image_bitmap->BitmapImage()->PaintImageForCurrentFrame().GetSwSkImage(), |
| original_image_content->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| |
| ImageResourceContent* new_image_content = ImageResourceContent::CreateLoaded( |
| UnacceleratedStaticBitmapImage::Create(image2_).get()); |
| image->SetImageForTest(new_image_content); |
| |
| { |
| ASSERT_EQ( |
| image_bitmap->BitmapImage()->PaintImageForCurrentFrame().GetSwSkImage(), |
| original_image_content->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| SkImage* image1 = image_bitmap->BitmapImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage() |
| .get(); |
| ASSERT_NE(image1, nullptr); |
| SkImage* image2 = original_image_content->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage() |
| .get(); |
| ASSERT_NE(image2, nullptr); |
| ASSERT_EQ(image1, image2); |
| } |
| |
| { |
| ASSERT_NE( |
| image_bitmap->BitmapImage()->PaintImageForCurrentFrame().GetSwSkImage(), |
| new_image_content->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage()); |
| SkImage* image1 = image_bitmap->BitmapImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage() |
| .get(); |
| ASSERT_NE(image1, nullptr); |
| SkImage* image2 = new_image_content->GetImage() |
| ->PaintImageForCurrentFrame() |
| .GetSwSkImage() |
| .get(); |
| ASSERT_NE(image2, nullptr); |
| ASSERT_NE(image1, image2); |
| } |
| } |
| |
| static void TestImageBitmapTextureBacked( |
| scoped_refptr<StaticBitmapImage> bitmap, |
| gfx::Rect& rect, |
| ImageBitmapOptions* options, |
| bool is_texture_backed) { |
| auto* image_bitmap = MakeGarbageCollected<ImageBitmap>(bitmap, rect, options); |
| EXPECT_TRUE(image_bitmap); |
| EXPECT_EQ(image_bitmap->BitmapImage()->IsTextureBacked(), is_texture_backed); |
| } |
| |
| TEST_F(ImageBitmapTest, AvoidGPUReadback) { |
| auto client_si = gpu::ClientSharedImage::CreateForTesting( |
| gpu::SHARED_IMAGE_USAGE_RASTER_READ); |
| gpu::SyncToken token; |
| token.Set(gpu::CommandBufferNamespace::GPU_IO, |
| gpu::CommandBufferId::FromUnsafeValue(64), 100); |
| |
| scoped_refptr<StaticBitmapImage> bitmap = |
| AcceleratedStaticBitmapImage::CreateFromCanvasSharedImage( |
| std::move(client_si), token, kPremul_SkAlphaType, gfx::HDRMetadata(), |
| SharedGpuContext::ContextProviderWrapper(), |
| base::PlatformThread::CurrentRef(), |
| base::MakeRefCounted<base::NullTaskRunner>(), base::DoNothing()); |
| ASSERT_TRUE(bitmap->IsTextureBacked()); |
| |
| auto* image_bitmap = MakeGarbageCollected<ImageBitmap>(bitmap); |
| EXPECT_TRUE(image_bitmap); |
| EXPECT_TRUE(image_bitmap->BitmapImage()->IsTextureBacked()); |
| |
| gfx::Rect image_bitmap_rect(25, 25, 50, 50); |
| { |
| ImageBitmapOptions* image_bitmap_options = ImageBitmapOptions::Create(); |
| TestImageBitmapTextureBacked(bitmap, image_bitmap_rect, |
| image_bitmap_options, true); |
| } |
| |
| std::list<V8ImageOrientation::Enum> image_orientations = { |
| V8ImageOrientation::Enum::kNone, V8ImageOrientation::Enum::kFlipY}; |
| std::list<V8PremultiplyAlpha::Enum> premultiply_alphas = { |
| V8PremultiplyAlpha::Enum::kNone, V8PremultiplyAlpha::Enum::kPremultiply, |
| V8PremultiplyAlpha::Enum::kDefault}; |
| std::list<V8ColorSpaceConversion::Enum> color_space_conversions = { |
| V8ColorSpaceConversion::Enum::kNone, |
| V8ColorSpaceConversion::Enum::kDefault}; |
| std::list<int> resize_widths = {25, 50, 75}; |
| std::list<int> resize_heights = {25, 50, 75}; |
| std::list<V8ResizeQuality::Enum> resize_qualities = { |
| V8ResizeQuality::Enum::kPixelated, V8ResizeQuality::Enum::kLow, |
| V8ResizeQuality::Enum::kMedium, V8ResizeQuality::Enum::kHigh}; |
| |
| for (auto image_orientation : image_orientations) { |
| for (auto premultiply_alpha : premultiply_alphas) { |
| for (auto color_space_conversion : color_space_conversions) { |
| for (auto resize_width : resize_widths) { |
| for (auto resize_height : resize_heights) { |
| for (auto resize_quality : resize_qualities) { |
| ImageBitmapOptions* image_bitmap_options = |
| ImageBitmapOptions::Create(); |
| image_bitmap_options->setImageOrientation(image_orientation); |
| image_bitmap_options->setPremultiplyAlpha(premultiply_alpha); |
| image_bitmap_options->setColorSpaceConversion( |
| color_space_conversion); |
| image_bitmap_options->setResizeWidth(resize_width); |
| image_bitmap_options->setResizeHeight(resize_height); |
| image_bitmap_options->setResizeQuality(resize_quality); |
| // Setting premuliply_alpha to none will cause a read back. |
| // Otherwise, we expect to avoid GPU readback when creaing an |
| // ImageBitmap from a texture-backed source. |
| TestImageBitmapTextureBacked( |
| bitmap, image_bitmap_rect, image_bitmap_options, |
| premultiply_alpha != V8PremultiplyAlpha::Enum::kNone); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // This test is failing on asan-clang-phone because memory allocation is |
| // declined. See <http://crbug.com/782286>. |
| // This test is failing on fuchsia because memory allocation is |
| // declined. <http://crbug.com/1090252>. |
| #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_FUCHSIA) |
| #define MAYBE_CreateImageBitmapFromTooBigImageDataDoesNotCrash \ |
| DISABLED_CreateImageBitmapFromTooBigImageDataDoesNotCrash |
| #else |
| #define MAYBE_CreateImageBitmapFromTooBigImageDataDoesNotCrash \ |
| CreateImageBitmapFromTooBigImageDataDoesNotCrash |
| #endif |
| |
| // This test verifies if requesting a large ImageData and creating an |
| // ImageBitmap from that does not crash. crbug.com/780358 |
| TEST_F(ImageBitmapTest, |
| MAYBE_CreateImageBitmapFromTooBigImageDataDoesNotCrash) { |
| constexpr int kWidth = 1 << 28; // 256M pixels width, resulting in 1GB data. |
| ImageData* image_data = ImageData::CreateForTest(gfx::Size(kWidth, 1)); |
| DCHECK(image_data); |
| ImageBitmapOptions* options = ImageBitmapOptions::Create(); |
| options->setColorSpaceConversion(V8ColorSpaceConversion::Enum::kDefault); |
| auto* image_bitmap = MakeGarbageCollected<ImageBitmap>( |
| image_data, gfx::Rect(image_data->Size()), options); |
| DCHECK(image_bitmap); |
| } |
| |
| TEST_F(ImageBitmapTest, ImageAlphaState) { |
| auto dummy = std::make_unique<DummyPageHolder>(gfx::Size(800, 600)); |
| auto* image_element = |
| MakeGarbageCollected<HTMLImageElement>(dummy->GetDocument()); |
| |
| // Load a 2x2 png file which has pixels (255, 102, 153, 0). It is a fully |
| // transparent image. |
| ResourceRequest resource_request( |
| "data:image/" |
| "png;base64," |
| "iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAYAAABytg0kAAAAEUlEQVR42mP8nzaTAQQYYQwA" |
| "LssD/5ca+r8AAAAASUVORK5CYII="); |
| |
| FetchParameters params = |
| FetchParameters::CreateForTest(std::move(resource_request)); |
| |
| ImageResourceContent* resource_content = |
| ImageResourceContent::Fetch(params, dummy->GetDocument().Fetcher()); |
| |
| image_element->SetImageForTest(resource_content); |
| |
| ImageBitmapOptions* options = ImageBitmapOptions::Create(); |
| // ImageBitmap created from unpremul source image result. |
| options->setPremultiplyAlpha(V8PremultiplyAlpha::Enum::kNone); |
| |
| // Additional operation shouldn't affect alpha op. |
| options->setImageOrientation(V8ImageOrientation::Enum::kFlipY); |
| |
| std::optional<gfx::Rect> crop_rect = |
| gfx::Rect(0, 0, image_element->width(), image_element->height()); |
| auto* image_bitmap = |
| MakeGarbageCollected<ImageBitmap>(image_element, crop_rect, options); |
| ASSERT_TRUE(image_bitmap); |
| |
| // Read 1 pixel |
| sk_sp<SkImage> result = |
| image_bitmap->BitmapImage()->PaintImageForCurrentFrame().GetSwSkImage(); |
| SkPixmap pixmap; |
| ASSERT_TRUE(result->peekPixels(&pixmap)); |
| const uint32_t* pixels = pixmap.addr32(); |
| |
| SkColorType result_color_type = result->colorType(); |
| SkColor expected = SkColorSetARGB(0, 0, 0, 0); |
| |
| switch (result_color_type) { |
| case SkColorType::kRGBA_8888_SkColorType: |
| // Set ABGR value as reverse of RGBA |
| expected = |
| SkColorSetARGB(/* a */ 0, /* b */ 153, /* g */ 102, /* r */ 255); |
| break; |
| case SkColorType::kBGRA_8888_SkColorType: |
| // Set ARGB value as reverse of BGRA |
| expected = |
| SkColorSetARGB(/* a */ 0, /* r */ 255, /* g */ 102, /* b */ 153); |
| break; |
| default: |
| NOTREACHED(); |
| } |
| |
| ASSERT_EQ(pixels[0], expected); |
| } |
| |
| } // namespace blink |
