gm_bindings.cpp File Reference

#include <set>
#include <string>
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/html5.h>
#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkData.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkStream.h"
#include "include/core/SkSurface.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/gpu/ganesh/gl/GrGLDirectContext.h"
#include "include/gpu/gl/GrGLInterface.h"
#include "include/gpu/gl/GrGLTypes.h"
#include "modules/canvaskit/WasmCommon.h"
#include "src/core/SkMD5.h"
#include "tests/Test.h"
#include "tests/TestHarness.h"
#include "tools/HashAndEncode.h"
#include "tools/ResourceFactory.h"
#include "tools/flags/CommandLineFlags.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/gpu/ContextType.h"

Go to the source code of this file.

Classes
struct	WasmReporter

Namespaces
namespace	skiatest
namespace	sk_gpu_test

Typedefs
using	skiatest::ContextType = skgpu::ContextType

Functions
static JSArray	ListGMs ()
static std::unique_ptr< skiagm::GM >	getGMWithName (std::string name)
static sk_sp< GrDirectContext >	MakeGrContext (EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context)
static void	LoadKnownDigest (std::string md5)
static sk_sp< SkData >	getResource (const char *name)
static void	LoadResource (std::string name, WASMPointerU8 bPtr, size_t len)
static JSObject	RunGM (sk_sp< GrDirectContext > ctx, std::string name)
static JSArray	ListTests ()
static skiatest::Test	getTestWithName (std::string name, bool *ok)
static JSObject	RunTest (std::string name)
bool	skiatest::IsGLContextType (skgpu::ContextType type)
bool	skiatest::IsMockContextType (skgpu::ContextType type)
bool	skiatest::IsVulkanContextType (skgpu::ContextType type)
bool	skiatest::IsMetalContextType (skgpu::ContextType type)
bool	skiatest::IsDirect3DContextType (skgpu::ContextType type)
bool	skiatest::IsDawnContextType (skgpu::ContextType type)
void	skiatest::RunWithGaneshTestContexts (GrContextTestFn *testFn, ContextTypeFilterFn *filter, Reporter *reporter, const GrContextOptions &options)
GLTestContext *	sk_gpu_test::CreatePlatformGLTestContext (GrGLStandard forcedGpuAPI, GLTestContext *shareContext)
void	Init ()
TestHarness	CurrentTestHarness ()
	EMSCRIPTEN_BINDINGS (GMs)

Variables
static std::set< std::string >	gKnownDigests
static std::map< std::string, sk_sp< SkData > >	gResources

Function Documentation

CurrentTestHarness()

TestHarness CurrentTestHarness

(

)

Definition at line 348 of file gm_bindings.cpp.

                                 {
    return TestHarness::kWasmGMTests;
}

EMSCRIPTEN_BINDINGS()

EMSCRIPTEN_BINDINGS

(

GMs

)

Definition at line 352 of file gm_bindings.cpp.

                         {
    function("Init", &Init);
    function("ListGMs", &ListGMs);
    function("ListTests", &ListTests);
    function("LoadKnownDigest", &LoadKnownDigest);
    function("_LoadResource", &LoadResource);
    function("MakeGrContext", &MakeGrContext);
    function("RunGM", &RunGM);
    function("RunTest", &RunTest);
 
    class_<GrDirectContext>("GrDirectContext")
        .smart_ptr<sk_sp<GrDirectContext>>("sk_sp<GrDirectContext>");
}

getGMWithName()

static std::unique_ptr< skiagm::GM > getGMWithName ( std::string  name )

static

Definition at line 55 of file gm_bindings.cpp.

                                                             {
    for (const skiagm::GMFactory& fact : skiagm::GMRegistry::Range()) {
        std::unique_ptr<skiagm::GM> gm(fact());
        if (gm->getName().c_str() == name) {
            return gm;
        }
    }
    return nullptr;
}

getResource()

static sk_sp< SkData > getResource ( const char *  name )

static

Definition at line 91 of file gm_bindings.cpp.

                                                   {
  auto it = gResources.find(name);
  if (it == gResources.end()) {
    SkDebugf("Resource %s not found\n", name);
    return nullptr;
  }
  return it->second;
}

getTestWithName()

static skiatest::Test getTestWithName ( std::string  name, bool *  ok  )

static

Definition at line 213 of file gm_bindings.cpp.

                                                              {
    for (auto test : skiatest::TestRegistry::Range()) {
        if (name == test.fName) {
          *ok = true;
          return test;
        }
    }
    *ok = false;
    return skiatest::Test::MakeCPU(nullptr, nullptr);
}

Init()

void Init

(

)

Definition at line 346 of file gm_bindings.cpp.

{ ToolUtils::UsePortableFontMgr(); }

ListGMs()

static JSArray ListGMs ( )

static

Returns a JS array of strings containing the names of the registered GMs. GMs are only registered when their source is included in the "link" step, not if they are in something like libgm.a. The names are also logged to the console.

Definition at line 44 of file gm_bindings.cpp.

                         {
    SkDebugf("Listing GMs\n");
    JSArray gms = emscripten::val::array();
    for (const skiagm::GMFactory& fact : skiagm::GMRegistry::Range()) {
        std::unique_ptr<skiagm::GM> gm(fact());
        SkDebugf("gm %s\n", gm->getName().c_str());
        gms.call<void>("push", std::string(gm->getName().c_str()));
    }
    return gms;
}

ListTests()

static JSArray ListTests ( )

static

Definition at line 203 of file gm_bindings.cpp.

                           {
    SkDebugf("Listing Tests\n");
    JSArray tests = emscripten::val::array();
    for (auto test : skiatest::TestRegistry::Range()) {
        SkDebugf("test %s\n", test.fName);
        tests.call<void>("push", std::string(test.fName));
    }
    return tests;
}

LoadKnownDigest()

static void LoadKnownDigest ( std::string  md5 )

static

Definition at line 85 of file gm_bindings.cpp.

                                           {
  gKnownDigests.insert(md5);
}

LoadResource()

static void LoadResource ( std::string  name, WASMPointerU8  bPtr, size_t  len  )

static

Definition at line 100 of file gm_bindings.cpp.

                                                                         {
  const uint8_t* bytes = reinterpret_cast<const uint8_t*>(bPtr);
  auto data = SkData::MakeFromMalloc(bytes, len);
  gResources[name] = std::move(data);
 
  if (!gResourceFactory) {
    gResourceFactory = getResource;
  }
}

MakeGrContext()

static sk_sp< GrDirectContext > MakeGrContext ( EMSCRIPTEN_WEBGL_CONTEXT_HANDLE  context )

static

Sets the given WebGL context to be "current" and then creates a GrDirectContext from that context.

Definition at line 69 of file gm_bindings.cpp.

{
    EMSCRIPTEN_RESULT r = emscripten_webgl_make_context_current(context);
    if (r < 0) {
        printf("failed to make webgl context current %d\n", r);
        return nullptr;
    }
    // setup GrDirectContext
    auto interface = GrGLMakeNativeInterface();
    // setup contexts
    sk_sp<GrDirectContext> dContext((GrDirectContexts::MakeGL(interface)));
    return dContext;
}

RunGM()

static JSObject RunGM ( sk_sp< GrDirectContext >  ctx, std::string  name  )

static

Runs the given GM and returns a JS object. If the GM was successful, the object will have the following properties: "png" - a Uint8Array of the PNG data extracted from the surface. "hash" - a string which is the md5 hash of the pixel contents and the metadata.

Definition at line 116 of file gm_bindings.cpp.

                                                                  {
    JSObject result = emscripten::val::object();
    auto gm = getGMWithName(name);
    if (!gm) {
        SkDebugf("Could not find gm with name %s\n", name.c_str());
        return result;
    }
    // TODO(kjlubick) make these configurable somehow. This probably makes sense to do as function
    //   parameters.
    auto alphaType = SkAlphaType::kPremul_SkAlphaType;
    auto colorType = SkColorType::kN32_SkColorType;
    SkISize size = gm->getISize();
    SkImageInfo info = SkImageInfo::Make(size, colorType, alphaType);
    sk_sp<SkSurface> surface(SkSurfaces::RenderTarget(
            ctx.get(), skgpu::Budgeted::kYes, info, 0, kBottomLeft_GrSurfaceOrigin, nullptr, true));
    if (!surface) {
        SkDebugf("Could not make surface\n");
        return result;
    }
    auto canvas = surface->getCanvas();
 
    gm->onceBeforeDraw();
    SkString msg;
    // Based on GMSrc::draw from DM.
    auto gpuSetupResult = gm->gpuSetup(canvas, &msg);
    if (gpuSetupResult == skiagm::DrawResult::kFail) {
        SkDebugf("Error with gpu setup for gm %s: %s\n", name.c_str(), msg.c_str());
        return result;
    } else if (gpuSetupResult == skiagm::DrawResult::kSkip) {
        return result;
    }
 
    auto drawResult = gm->draw(canvas, &msg);
    if (drawResult == skiagm::DrawResult::kFail) {
        SkDebugf("Error with gm %s: %s\n", name.c_str(), msg.c_str());
        return result;
    } else if (drawResult == skiagm::DrawResult::kSkip) {
        return result;
    }
    ctx->flushAndSubmit(surface.get(), GrSyncCpu::kYes);
 
    // Based on GPUSink::readBack
    SkBitmap bitmap;
    bitmap.allocPixels(info);
    if (!canvas->readPixels(bitmap, 0, 0)) {
        SkDebugf("Could not read pixels back\n");
        return result;
    }
 
    // Now we need to encode to PNG and get the md5 hash of the pixels (and colorspace and stuff).
    // This is based on Task::Run from DM.cpp
    std::unique_ptr<HashAndEncode> hashAndEncode = std::make_unique<HashAndEncode>(bitmap);
    SkString md5;
    SkMD5 hash;
    hashAndEncode->feedHash(&hash);
    SkMD5::Digest digest = hash.finish();
    for (int i = 0; i < 16; i++) {
        md5.appendf("%02x", digest.data[i]);
    }
 
    auto ok = gKnownDigests.find(md5.c_str());
    if (ok == gKnownDigests.end()) {
        // We only need to decode the image if it is "interesting", that is, we have not written it
        // before to disk and uploaded it to gold.
        SkDynamicMemoryWStream stream;
        // We do not need to include the keys because they are optional - they are not read by Gold.
        CommandLineFlags::StringArray empty;
        hashAndEncode->encodePNG(&stream, md5.c_str(), empty, empty);
 
        auto data = stream.detachAsData();
 
        // This is the cleanest way to create a new Uint8Array with a copy of the data that is not
        // in the WASM heap. kjlubick tried returning a pointer inside an SkData, but that lead to
        // some use after free issues. By making the copy using the JS transliteration, we don't
        // risk the SkData object being cleaned up before we make the copy.
        Uint8Array pngData = emscripten::val(
            // https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-views
            typed_memory_view(data->size(), data->bytes())
        ).call<Uint8Array>("slice"); // slice with no args makes a copy of the memory view.
 
        result.set("png", pngData);
        gKnownDigests.emplace(md5.c_str());
    }
    result.set("hash", md5.c_str());
    return result;
}

RunTest()

static JSObject RunTest ( std::string  name )

static

Runs the given Test and returns a JS object. If the Test was located, the object will have the following properties: "result" : One of "passed", "failed", "skipped". "msg": May be non-empty on failure

Definition at line 243 of file gm_bindings.cpp.

                                        {
    JSObject result = emscripten::val::object();
    bool ok = false;
    auto test = getTestWithName(name, &ok);
    if (!ok) {
        SkDebugf("Could not find test with name %s\n", name.c_str());
        return result;
    }
    GrContextOptions grOpts;
    if (test.fTestType == skiatest::TestType::kGanesh) {
        result.set("result", "passed"); // default to passing - the reporter will mark failed.
        WasmReporter reporter(name, result);
        test.modifyGrContextOptions(&grOpts);
        test.ganesh(&reporter, grOpts);
        return result;
    } else if (test.fTestType == skiatest::TestType::kGraphite) {
        SkDebugf("Graphite test %s not yet supported\n", name.c_str());
        return result;
    }
 
    result.set("result", "passed"); // default to passing - the reporter will mark failed.
    WasmReporter reporter(name, result);
    test.cpu(&reporter);
    return result;
}

Variable Documentation

gKnownDigests

std::set<std::string> gKnownDigests

static

Definition at line 83 of file gm_bindings.cpp.

gResources

std::map<std::string, sk_sp<SkData> > gResources

static

Definition at line 89 of file gm_bindings.cpp.