flutter::testing::TestGLSurface Class Reference

#include <test_gl_surface.h>

Public Member Functions
	TestGLSurface (SkISize surface_size)
	~TestGLSurface ()
const SkISize &	GetSurfaceSize () const
bool	MakeCurrent ()
bool	ClearCurrent ()
bool	Present ()
uint32_t	GetFramebuffer (uint32_t width, uint32_t height) const
bool	MakeResourceCurrent ()
void *	GetProcAddress (const char *name) const
sk_sp< SkSurface >	GetOnscreenSurface ()
sk_sp< GrDirectContext >	GetGrContext ()
sk_sp< GrDirectContext >	CreateGrContext ()
sk_sp< SkImage >	GetRasterSurfaceSnapshot ()
uint32_t	GetWindowFBOId () const

Detailed Description

Definition at line 18 of file test_gl_surface.h.

Constructor & Destructor Documentation

TestGLSurface()

flutter::testing::TestGLSurface::TestGLSurface ( SkISize  surface_size )

explicit

Definition at line 133 of file test_gl_surface.cc.

    : surface_size_(surface_size) {
  display_ = CreateSwangleDisplay();
  FML_CHECK(display_ != EGL_NO_DISPLAY);
 
  auto result = ::eglInitialize(display_, nullptr, nullptr);
  FML_CHECK(result == EGL_TRUE) << GetEGLError();
 
  EGLConfig config = {0};
 
  EGLint num_config = 0;
  const EGLint attribute_list[] = {EGL_RED_SIZE,
                                   8,
                                   EGL_GREEN_SIZE,
                                   8,
                                   EGL_BLUE_SIZE,
                                   8,
                                   EGL_ALPHA_SIZE,
                                   8,
                                   EGL_SURFACE_TYPE,
                                   EGL_PBUFFER_BIT,
                                   EGL_CONFORMANT,
                                   EGL_OPENGL_ES2_BIT,
                                   EGL_RENDERABLE_TYPE,
                                   EGL_OPENGL_ES2_BIT,
                                   EGL_NONE};
 
  result = ::eglChooseConfig(display_, attribute_list, &config, 1, &num_config);
  FML_CHECK(result == EGL_TRUE) << GetEGLError();
  FML_CHECK(num_config == 1) << GetEGLError();
 
  {
    const EGLint onscreen_surface_attributes[] = {
        EGL_WIDTH,  surface_size_.width(),   //
        EGL_HEIGHT, surface_size_.height(),  //
        EGL_NONE,
    };
 
    onscreen_surface_ = ::eglCreatePbufferSurface(
        display_,                    // display connection
        config,                      // config
        onscreen_surface_attributes  // surface attributes
    );
    FML_CHECK(onscreen_surface_ != EGL_NO_SURFACE) << GetEGLError();
  }
 
  {
    const EGLint offscreen_surface_attributes[] = {
        EGL_WIDTH,  1,  //
        EGL_HEIGHT, 1,  //
        EGL_NONE,
    };
    offscreen_surface_ = ::eglCreatePbufferSurface(
        display_,                     // display connection
        config,                       // config
        offscreen_surface_attributes  // surface attributes
    );
    FML_CHECK(offscreen_surface_ != EGL_NO_SURFACE) << GetEGLError();
  }
 
  {
    const EGLint context_attributes[] = {
        EGL_CONTEXT_CLIENT_VERSION,  //
        2,                           //
        EGL_NONE                     //
    };
 
    onscreen_context_ =
        ::eglCreateContext(display_,           // display connection
                           config,             // config
                           EGL_NO_CONTEXT,     // sharegroup
                           context_attributes  // context attributes
        );
    FML_CHECK(onscreen_context_ != EGL_NO_CONTEXT) << GetEGLError();
 
    offscreen_context_ =
        ::eglCreateContext(display_,           // display connection
                           config,             // config
                           onscreen_context_,  // sharegroup
                           context_attributes  // context attributes
        );
    FML_CHECK(offscreen_context_ != EGL_NO_CONTEXT) << GetEGLError();
  }
}

~TestGLSurface()

flutter::testing::TestGLSurface::~TestGLSurface

(

)

Definition at line 218 of file test_gl_surface.cc.

                              {
  context_ = nullptr;
 
  auto result = ::eglDestroyContext(display_, onscreen_context_);
  FML_CHECK(result == EGL_TRUE) << GetEGLError();
 
  result = ::eglDestroyContext(display_, offscreen_context_);
  FML_CHECK(result == EGL_TRUE) << GetEGLError();
 
  result = ::eglDestroySurface(display_, onscreen_surface_);
  FML_CHECK(result == EGL_TRUE) << GetEGLError();
 
  result = ::eglDestroySurface(display_, offscreen_surface_);
  FML_CHECK(result == EGL_TRUE) << GetEGLError();
 
  result = ::eglTerminate(display_);
  FML_CHECK(result == EGL_TRUE);
}

Member Function Documentation

ClearCurrent()

bool flutter::testing::TestGLSurface::ClearCurrent

(

)

Definition at line 252 of file test_gl_surface.cc.

                                 {
  auto result = ::eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE,
                                 EGL_NO_CONTEXT);
 
  if (result == EGL_FALSE) {
    FML_LOG(ERROR) << "Could not clear the current context. " << GetEGLError();
  }
 
  return result == EGL_TRUE;
}

CreateGrContext()

sk_sp< GrDirectContext > flutter::testing::TestGLSurface::CreateGrContext

(

)

Definition at line 308 of file test_gl_surface.cc.

                                                      {
  if (!MakeCurrent()) {
    return nullptr;
  }
 
  auto get_string =
      reinterpret_cast<PFNGLGETSTRINGPROC>(GetProcAddress("glGetString"));
 
  if (!get_string) {
    return nullptr;
  }
 
  auto c_version = reinterpret_cast<const char*>(get_string(GL_VERSION));
 
  if (c_version == NULL) {
    return nullptr;
  }
 
  GrGLGetProc get_proc = [](void* context, const char name[]) -> GrGLFuncPtr {
    return reinterpret_cast<GrGLFuncPtr>(
        reinterpret_cast<TestGLSurface*>(context)->GetProcAddress(name));
  };
 
  std::string version(c_version);
  auto interface = version.find("OpenGL ES") == std::string::npos
                       ? GrGLMakeAssembledGLInterface(this, get_proc)
                       : GrGLMakeAssembledGLESInterface(this, get_proc);
 
  if (!interface) {
    return nullptr;
  }
 
  context_ = GrDirectContexts::MakeGL(interface);
  return context_;
}

GetFramebuffer()

uint32_t flutter::testing::TestGLSurface::GetFramebuffer	(	uint32_t	width,
		uint32_t	height
	)		const

Definition at line 273 of file test_gl_surface.cc.

                                                                            {
  return GetWindowFBOId();
}

GetGrContext()

sk_sp< GrDirectContext > flutter::testing::TestGLSurface::GetGrContext

(

)

Definition at line 300 of file test_gl_surface.cc.

                                                   {
  if (context_) {
    return context_;
  }
 
  return CreateGrContext();
}

GetOnscreenSurface()

sk_sp< SkSurface > flutter::testing::TestGLSurface::GetOnscreenSurface

(

)

Definition at line 344 of file test_gl_surface.cc.

                                                   {
  FML_CHECK(::eglGetCurrentContext() != EGL_NO_CONTEXT);
 
  GrGLFramebufferInfo framebuffer_info = {};
  const uint32_t width = surface_size_.width();
  const uint32_t height = surface_size_.height();
  framebuffer_info.fFBOID = GetFramebuffer(width, height);
#if FML_OS_MACOSX
  framebuffer_info.fFormat = 0x8058;  // GL_RGBA8
#else
  framebuffer_info.fFormat = 0x93A1;  // GL_BGRA8;
#endif
 
  auto backend_render_target =
      GrBackendRenderTargets::MakeGL(width,            // width
                                     height,           // height
                                     1,                // sample count
                                     8,                // stencil bits
                                     framebuffer_info  // framebuffer info
      );
 
  SkSurfaceProps surface_properties(0, kUnknown_SkPixelGeometry);
 
  auto surface = SkSurfaces::WrapBackendRenderTarget(
      GetGrContext().get(),         // context
      backend_render_target,        // backend render target
      kBottomLeft_GrSurfaceOrigin,  // surface origin
      kN32_SkColorType,             // color type
      SkColorSpace::MakeSRGB(),     // color space
      &surface_properties,          // surface properties
      nullptr,                      // release proc
      nullptr                       // release context
  );
 
  if (!surface) {
    FML_LOG(ERROR) << "Could not wrap the surface while attempting to "
                      "snapshot the GL surface.";
    return nullptr;
  }
 
  return surface;
}

GetProcAddress()

void * flutter::testing::TestGLSurface::GetProcAddress

(

const char *

name

)

const

Definition at line 289 of file test_gl_surface.cc.

                                                          {
  if (name == nullptr) {
    return nullptr;
  }
  auto symbol = ::eglGetProcAddress(name);
  if (symbol == NULL) {
    FML_LOG(ERROR) << "Could not fetch symbol for name: " << name;
  }
  return reinterpret_cast<void*>(symbol);
}

GetRasterSurfaceSnapshot()

sk_sp< SkImage > flutter::testing::TestGLSurface::GetRasterSurfaceSnapshot

(

)

Definition at line 387 of file test_gl_surface.cc.

                                                       {
  auto surface = GetOnscreenSurface();
 
  if (!surface) {
    FML_LOG(ERROR) << "Aborting snapshot because of on-screen surface "
                      "acquisition failure.";
    return nullptr;
  }
 
  auto device_snapshot = surface->makeImageSnapshot();
 
  if (!device_snapshot) {
    FML_LOG(ERROR) << "Could not create the device snapshot while attempting "
                      "to snapshot the GL surface.";
    return nullptr;
  }
 
  auto host_snapshot = device_snapshot->makeRasterImage();
 
  if (!host_snapshot) {
    FML_LOG(ERROR) << "Could not create the host snapshot while attempting to "
                      "snapshot the GL surface.";
    return nullptr;
  }
 
  return host_snapshot;
}

GetSurfaceSize()

const SkISize & flutter::testing::TestGLSurface::GetSurfaceSize

(

)

const

Definition at line 237 of file test_gl_surface.cc.

                                                   {
  return surface_size_;
}

GetWindowFBOId()

uint32_t flutter::testing::TestGLSurface::GetWindowFBOId

(

)

const

Definition at line 415 of file test_gl_surface.cc.

                                             {
  return 0u;
}

MakeCurrent()

bool flutter::testing::TestGLSurface::MakeCurrent

(

)

Definition at line 241 of file test_gl_surface.cc.

                                {
  auto result = ::eglMakeCurrent(display_, onscreen_surface_, onscreen_surface_,
                                 onscreen_context_);
 
  if (result == EGL_FALSE) {
    FML_LOG(ERROR) << "Could not make the context current. " << GetEGLError();
  }
 
  return result == EGL_TRUE;
}

MakeResourceCurrent()

bool flutter::testing::TestGLSurface::MakeResourceCurrent

(

)

Definition at line 277 of file test_gl_surface.cc.

                                        {
  auto result = ::eglMakeCurrent(display_, offscreen_surface_,
                                 offscreen_surface_, offscreen_context_);
 
  if (result == EGL_FALSE) {
    FML_LOG(ERROR) << "Could not make the resource context current. "
                   << GetEGLError();
  }
 
  return result == EGL_TRUE;
}

Present()

bool flutter::testing::TestGLSurface::Present

(

)

Definition at line 263 of file test_gl_surface.cc.

                            {
  auto result = ::eglSwapBuffers(display_, onscreen_surface_);
 
  if (result == EGL_FALSE) {
    FML_LOG(ERROR) << "Could not swap buffers. " << GetEGLError();
  }
 
  return result == EGL_TRUE;
}

---

The documentation for this class was generated from the following files:

• testing/test_gl_surface.h
• testing/test_gl_surface.cc