BackendTextureTest.cpp File Reference

#include "tests/Test.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkSurface.h"
#include "include/gpu/MutableTextureState.h"
#include "include/gpu/graphite/BackendTexture.h"
#include "include/gpu/graphite/Context.h"
#include "include/gpu/graphite/Image.h"
#include "include/gpu/graphite/Recorder.h"
#include "include/gpu/graphite/Surface.h"
#include "include/gpu/vk/VulkanMutableTextureState.h"
#include "include/gpu/vk/VulkanTypes.h"
#include "src/gpu/graphite/Caps.h"
#include "src/gpu/graphite/ContextPriv.h"
#include "src/gpu/graphite/ResourceTypes.h"

Go to the source code of this file.

Functions
	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (BackendTextureTest, reporter, context, CtsEnforcement::kNextRelease)
	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (SurfaceBackendTextureTest, reporter, context, CtsEnforcement::kNextRelease)
	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ImageBackendTextureTest, reporter, context, CtsEnforcement::kNextRelease)

Function Documentation

DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [1/3]

DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	BackendTextureTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 31 of file BackendTextureTest.cpp.

                                                               {
    // TODO: Remove this check once Vulkan supports creating default TexutreInfo from caps and we
    // implement createBackendTexture.
    if (context->backend() == BackendApi::kVulkan) {
        return;
    }
 
    auto caps = context->priv().caps();
    auto recorder = context->makeRecorder();
 
    TextureInfo info = caps->getDefaultSampledTextureInfo(kRGBA_8888_SkColorType,
                                                          /*mipmapped=*/Mipmapped::kNo,
                                                          Protected::kNo,
                                                          Renderable::kNo);
    REPORTER_ASSERT(reporter, info.isValid());
 
    auto texture1 = recorder->createBackendTexture(kSize, info);
    REPORTER_ASSERT(reporter, texture1.isValid());
 
    // We make a copy to do the remaining tests so we still have texture1 to safely delete the
    // backend object.
    auto texture1Copy = texture1;
    REPORTER_ASSERT(reporter, texture1Copy.isValid());
    REPORTER_ASSERT(reporter, texture1 == texture1Copy);
 
    auto texture2 = recorder->createBackendTexture(kSize, info);
    REPORTER_ASSERT(reporter, texture2.isValid());
 
    REPORTER_ASSERT(reporter, texture1Copy != texture2);
 
    // Test state after assignment
    texture1Copy = texture2;
    REPORTER_ASSERT(reporter, texture1Copy.isValid());
    REPORTER_ASSERT(reporter, texture1Copy == texture2);
 
    BackendTexture invalidTexture;
    REPORTER_ASSERT(reporter, !invalidTexture.isValid());
 
    texture1Copy = invalidTexture;
    REPORTER_ASSERT(reporter, !texture1Copy.isValid());
 
    texture1Copy = texture1;
    REPORTER_ASSERT(reporter, texture1Copy.isValid());
    REPORTER_ASSERT(reporter, texture1 == texture1Copy);
 
    recorder->deleteBackendTexture(texture1);
    recorder->deleteBackendTexture(texture2);
 
    // Test that deleting is safe from the Context or a different Recorder.
    texture1 = recorder->createBackendTexture(kSize, info);
    context->deleteBackendTexture(texture1);
 
    auto recorder2 = context->makeRecorder();
    texture1 = recorder->createBackendTexture(kSize, info);
    recorder2->deleteBackendTexture(texture1);
}

DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [2/3]

DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ImageBackendTextureTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 152 of file BackendTextureTest.cpp.

                                                               {
    // TODO: Right now this just tests very basic combinations of images. This should be expanded
    // to cover a much broader set of things once we add more support in Graphite for different
    // formats, color types, etc.
 
    // TODO: Remove this check once Vulkan supports creating default TexutreInfo from caps and we
    // implement createBackendTexture.
    if (context->backend() == BackendApi::kVulkan) {
        return;
    }
 
    const Caps* caps = context->priv().caps();
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
 
    for (Mipmapped mipmapped : { Mipmapped::kYes, Mipmapped::kNo }) {
        for (Renderable renderable : { Renderable::kYes, Renderable::kNo }) {
 
            TextureInfo info = caps->getDefaultSampledTextureInfo(kRGBA_8888_SkColorType,
                                                                  mipmapped,
                                                                  Protected::kNo,
                                                                  renderable);
 
            BackendTexture texture = recorder->createBackendTexture(kSize, info);
            REPORTER_ASSERT(reporter, texture.isValid());
 
            sk_sp<SkImage> image = SkImages::WrapTexture(recorder.get(),
                                                         texture,
                                                         kRGBA_8888_SkColorType,
                                                         kPremul_SkAlphaType,
                                                         /*colorSpace=*/nullptr);
            REPORTER_ASSERT(reporter, image);
            REPORTER_ASSERT(reporter, image->hasMipmaps() == (mipmapped == Mipmapped::kYes));
 
            image.reset();
 
            // We should fail when trying to wrap the same texture in an image with a non-compatible
            // color type.
            image = SkImages::WrapTexture(recorder.get(),
                                          texture,
                                          kAlpha_8_SkColorType,
                                          kPremul_SkAlphaType,
                                          /* colorSpace= */ nullptr);
            REPORTER_ASSERT(reporter, !image);
 
            recorder->deleteBackendTexture(texture);
        }
    }
}

DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [3/3]

DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	SurfaceBackendTextureTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 90 of file BackendTextureTest.cpp.

                                                               {
    // TODO: Right now this just tests very basic combinations of surfaces. This should be expanded
    // to cover a much broader set of things once we add more support in Graphite for different
    // formats, color types, etc.
 
    // TODO: Remove this check once Vulkan supports creating default TexutreInfo from caps and we
    // implement createBackendTexture.
    if (context->backend() == BackendApi::kVulkan) {
        return;
    }
 
    auto caps = context->priv().caps();
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
 
    TextureInfo info = caps->getDefaultSampledTextureInfo(kRGBA_8888_SkColorType,
                                                          /*mipmapped=*/Mipmapped::kNo,
                                                          Protected::kNo,
                                                          Renderable::kYes);
 
    auto texture = recorder->createBackendTexture(kSize, info);
    REPORTER_ASSERT(reporter, texture.isValid());
 
    sk_sp<SkSurface> surface = SkSurfaces::WrapBackendTexture(recorder.get(),
                                                              texture,
                                                              kRGBA_8888_SkColorType,
                                                              /*colorSpace=*/nullptr,
                                                              /*props=*/nullptr);
    REPORTER_ASSERT(reporter, surface);
 
    surface.reset();
 
    // We should fail when trying to wrap the same texture in a surface with a non-compatible
    // color type.
    surface = SkSurfaces::WrapBackendTexture(recorder.get(),
                                             texture,
                                             kAlpha_8_SkColorType,
                                             /*colorSpace=*/nullptr,
                                             /*props=*/nullptr);
    REPORTER_ASSERT(reporter, !surface);
 
    recorder->deleteBackendTexture(texture);
 
    // We should fail to wrap a non-renderable texture in a surface.
    info = caps->getDefaultSampledTextureInfo(kRGBA_8888_SkColorType,
                                              /*mipmapped=*/Mipmapped::kNo,
                                              Protected::kNo,
                                              Renderable::kNo);
    texture = recorder->createBackendTexture(kSize, info);
    REPORTER_ASSERT(reporter, texture.isValid());
 
    surface = SkSurfaces::WrapBackendTexture(recorder.get(),
                                             texture,
                                             kRGBA_8888_SkColorType,
                                             /*colorSpace=*/nullptr,
                                             /*props=*/nullptr);
 
    REPORTER_ASSERT(reporter, !surface);
    recorder->deleteBackendTexture(texture);
}