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 "FenceSync.h"
13 #include "GrTypes.h"
14 #include "SkNoncopyable.h"
15 #include "SkRefCnt.h"
16 #include "SkScopeExit.h"
17 #include "SkTemplates.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 makeCurrent() const;
49 
50     /**
51      * Like makeCurrent() but this returns an object that will restore the previous current
52      * context in its destructor. Useful to undo the effect making this current before returning to
53      * a caller that doesn't expect the current context to be changed underneath it.
54      *
55      * The returned object restores the current context of the same type (e.g. egl, glx, ...) in its
56      * destructor. It is undefined behavior if that context is destroyed before the destructor
57      * executes. If the concept of a current context doesn't make sense for this context type then
58      * the returned object's destructor is a no-op.
59      */
60     SkScopeExit SK_WARN_UNUSED_RESULT makeCurrentAndAutoRestore() const;
61 
62     virtual GrBackendApi backend() = 0;
63 
64     virtual sk_sp<GrContext> makeGrContext(const GrContextOptions&);
65 
66     /** Swaps front and back buffer (if the context has such buffers) */
67     void swapBuffers();
68 
69     /**
70      * The only purpose of this function it to provide a means of scheduling
71      * work on the GPU (since all of the subclasses create primary buffers for
72      * testing that are small and not meant to be rendered to the screen).
73      *
74      * If the platform supports fence syncs (OpenGL 3.2+ or EGL_KHR_fence_sync),
75      * this will not swap any buffers, but rather emulate triple buffer synchronization
76      * using fences.
77      *
78      * Otherwise it will call the platform SwapBuffers method. This may or may
79      * not perform some sort of synchronization, depending on whether the
80      * drawing surface provided by the platform is double buffered.
81      *
82      * Implicitly performs a submit().
83      */
84     void waitOnSyncOrSwap();
85 
86     /**
87      * This notifies the context that we are deliberately testing abandoning
88      * the context. It is useful for debugging contexts that would otherwise
89      * test that GPU resources are properly deleted. It also allows a debugging
90      * context to test that further API calls are not made by Skia GPU code.
91      */
92     virtual void testAbandon();
93 
94     /** Ensures all work is submitted to the GPU for execution. */
95     virtual void submit() = 0;
96 
97     /** Wait until all GPU work is finished. */
98     virtual void finish() = 0;
99 
100 protected:
101     std::unique_ptr<FenceSync> fFenceSync;
102     std::unique_ptr<GpuTimer>  fGpuTimer;
103 
104     TestContext();
105 
106     /** This should destroy the 3D context. */
107     virtual void teardown();
108 
109     virtual void onPlatformMakeCurrent() const = 0;
110     /**
111      * Subclasses should implement such that the returned function will cause the current context
112      * of this type to be made current again when it is called. It should additionally be the
113      * case that if "this" is already current when this is called, then "this" is destroyed (thereby
114      * setting the null context as current), and then the std::function is called the null context
115      * should remain current.
116      */
117     virtual std::function<void()> onPlatformGetAutoContextRestore() const = 0;
118     virtual void onPlatformSwapBuffers() const = 0;
119 
120 private:
121     enum {
122         kMaxFrameLag = 3
123     };
124 
125     PlatformFence fFrameFences[kMaxFrameLag - 1];
126     int fCurrentFenceIdx;
127 
128     typedef SkNoncopyable INHERITED;
129 };
130 }  // namespace sk_gpu_test
131 #endif
132