1 2 /* 3 * Copyright 2016 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 #ifndef TestContext_DEFINED 10 #define TestContext_DEFINED 11 12 #include "include/core/SkRefCnt.h" 13 #include "include/gpu/GrTypes.h" 14 #include "include/private/SkNoncopyable.h" 15 #include "include/private/SkTemplates.h" 16 #include "src/core/SkScopeExit.h" 17 #include "tools/gpu/FenceSync.h" 18 19 class GrContext; 20 struct GrContextOptions; 21 22 namespace sk_gpu_test { 23 24 class GpuTimer; 25 26 /** 27 * An offscreen 3D context. This class is intended for Skia's internal testing needs and not 28 * for general use. 29 */ 30 class TestContext : public SkNoncopyable { 31 public: 32 virtual ~TestContext(); 33 fenceSyncSupport()34 bool fenceSyncSupport() const { return fFenceSync != nullptr; } fenceSync()35 FenceSync* fenceSync() { SkASSERT(fFenceSync); return fFenceSync.get(); } 36 gpuTimingSupport()37 bool gpuTimingSupport() const { return fGpuTimer != nullptr; } gpuTimer()38 GpuTimer* gpuTimer() const { SkASSERT(fGpuTimer); return fGpuTimer.get(); } 39 getMaxGpuFrameLag(int * maxFrameLag)40 bool getMaxGpuFrameLag(int *maxFrameLag) const { 41 if (!fFenceSync) { 42 return false; 43 } 44 *maxFrameLag = kMaxFrameLag; 45 return true; 46 } 47 48 void makeNotCurrent() const; 49 void makeCurrent() const; 50 51 /** 52 * Like makeCurrent() but this returns an object that will restore the previous current 53 * context in its destructor. Useful to undo the effect making this current before returning to 54 * a caller that doesn't expect the current context to be changed underneath it. 55 * 56 * The returned object restores the current context of the same type (e.g. egl, glx, ...) in its 57 * destructor. It is undefined behavior if that context is destroyed before the destructor 58 * executes. If the concept of a current context doesn't make sense for this context type then 59 * the returned object's destructor is a no-op. 60 */ 61 SkScopeExit SK_WARN_UNUSED_RESULT makeCurrentAndAutoRestore() const; 62 63 virtual GrBackendApi backend() = 0; 64 65 virtual sk_sp<GrContext> makeGrContext(const GrContextOptions&); 66 67 /** Swaps front and back buffer (if the context has such buffers) */ 68 void swapBuffers(); 69 70 /** 71 * The only purpose of this function it to provide a means of scheduling 72 * work on the GPU (since all of the subclasses create primary buffers for 73 * testing that are small and not meant to be rendered to the screen). 74 * 75 * If the platform supports fence syncs (OpenGL 3.2+ or EGL_KHR_fence_sync), 76 * this will not swap any buffers, but rather emulate triple buffer synchronization 77 * using fences. 78 * 79 * Otherwise it will call the platform SwapBuffers method. This may or may 80 * not perform some sort of synchronization, depending on whether the 81 * drawing surface provided by the platform is double buffered. 82 * 83 * Implicitly performs a submit(). 84 */ 85 void waitOnSyncOrSwap(); 86 87 /** 88 * This notifies the context that we are deliberately testing abandoning 89 * the context. It is useful for debugging contexts that would otherwise 90 * test that GPU resources are properly deleted. It also allows a debugging 91 * context to test that further API calls are not made by Skia GPU code. 92 */ 93 virtual void testAbandon(); 94 95 /** Ensures all work is submitted to the GPU for execution. */ 96 virtual void submit() = 0; 97 98 /** Wait until all GPU work is finished. */ 99 virtual void finish() = 0; 100 101 protected: 102 std::unique_ptr<FenceSync> fFenceSync; 103 std::unique_ptr<GpuTimer> fGpuTimer; 104 105 TestContext(); 106 107 /** This should destroy the 3D context. */ 108 virtual void teardown(); 109 110 virtual void onPlatformMakeNotCurrent() const = 0; 111 virtual void onPlatformMakeCurrent() const = 0; 112 /** 113 * Subclasses should implement such that the returned function will cause the current context 114 * of this type to be made current again when it is called. It should additionally be the 115 * case that if "this" is already current when this is called, then "this" is destroyed (thereby 116 * setting the null context as current), and then the std::function is called the null context 117 * should remain current. 118 */ 119 virtual std::function<void()> onPlatformGetAutoContextRestore() const = 0; 120 virtual void onPlatformSwapBuffers() const = 0; 121 122 private: 123 enum { 124 kMaxFrameLag = 3 125 }; 126 127 PlatformFence fFrameFences[kMaxFrameLag - 1]; 128 int fCurrentFenceIdx; 129 130 typedef SkNoncopyable INHERITED; 131 }; 132 } // namespace sk_gpu_test 133 #endif 134