1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrTest.h"
#include "GrInOrderDrawBuffer.h"
#include "GrResourceCache2.h"
void GrTestTarget::init(GrContext* ctx, GrDrawTarget* target) {
SkASSERT(!fContext);
fContext.reset(SkRef(ctx));
fDrawTarget.reset(SkRef(target));
SkNEW_IN_TLAZY(&fACR, GrDrawTarget::AutoClipRestore, (target));
SkNEW_IN_TLAZY(&fAGP, GrDrawTarget::AutoGeometryPush, (target));
}
void GrContext::getTestTarget(GrTestTarget* tar) {
this->flush();
// We could create a proxy GrDrawTarget that passes through to fGpu until ~GrTextTarget() and
// then disconnects. This would help prevent test writers from mixing using the returned
// GrDrawTarget and regular drawing. We could also assert or fail in GrContext drawing methods
// until ~GrTestTarget().
tar->init(this, fDrawBuffer);
}
///////////////////////////////////////////////////////////////////////////////
void GrContext::setMaxTextureSizeOverride(int maxTextureSizeOverride) {
fMaxTextureSizeOverride = maxTextureSizeOverride;
}
void GrContext::purgeAllUnlockedResources() {
fResourceCache2->purgeAllUnlocked();
}
///////////////////////////////////////////////////////////////////////////////
// Code for the mock context. It's built on a mock GrGpu class that does nothing.
////
#include "GrBufferAllocPool.h"
#include "GrInOrderDrawBuffer.h"
#include "GrGpu.h"
class GrOptDrawState;
class MockGpu : public GrGpu {
public:
MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrDrawTargetCaps)); }
virtual ~MockGpu() { }
virtual bool canWriteTexturePixels(const GrTexture*,
GrPixelConfig srcConfig) const SK_OVERRIDE {
return true;
}
virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
int left, int top,
int width, int height,
GrPixelConfig config,
size_t rowBytes) const SK_OVERRIDE { return false; }
virtual void buildProgramDesc(const GrOptDrawState&,
const GrProgramDesc::DescInfo&,
GrGpu::DrawType,
GrProgramDesc* desc) SK_OVERRIDE { }
virtual void discard(GrRenderTarget*) SK_OVERRIDE { }
virtual bool canCopySurface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
virtual bool copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
private:
virtual void onResetContext(uint32_t resetBits) { };
virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc,
const void* srcData,
size_t rowBytes) SK_OVERRIDE {
return NULL;
}
virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
const void* srcData) SK_OVERRIDE {
return NULL;
}
virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) SK_OVERRIDE {
return NULL;
}
virtual GrRenderTarget* onWrapBackendRenderTarget(
const GrBackendRenderTargetDesc&) SK_OVERRIDE {
return NULL;
}
virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) SK_OVERRIDE {
return NULL;
}
virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) SK_OVERRIDE {
return NULL;
}
virtual void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
bool canIgnoreRect) SK_OVERRIDE { }
virtual void onClearStencilClip(GrRenderTarget*,
const SkIRect& rect,
bool insideClip) SK_OVERRIDE { }
virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE { }
virtual bool onReadPixels(GrRenderTarget* target,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
size_t rowBytes) SK_OVERRIDE {
return false;
}
virtual bool onWriteTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) SK_OVERRIDE {
return false;
}
virtual void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE {
return;
}
virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width,
int height) SK_OVERRIDE {
return false;
}
virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) SK_OVERRIDE {
return false;
}
virtual bool flushGraphicsState(const GrOptDrawState&, DrawType) SK_OVERRIDE {
return false;
}
virtual void clearStencil(GrRenderTarget* target) SK_OVERRIDE { }
virtual void didAddGpuTraceMarker() SK_OVERRIDE { }
virtual void didRemoveGpuTraceMarker() SK_OVERRIDE { }
typedef GrGpu INHERITED;
};
GrContext* GrContext::CreateMockContext() {
GrContext* context = SkNEW_ARGS(GrContext, (Options()));
context->initMockContext();
return context;
}
void GrContext::initMockContext() {
SkASSERT(NULL == fGpu);
fGpu = SkNEW_ARGS(MockGpu, (this));
SkASSERT(fGpu);
this->initCommon();
// We delete these because we want to test the cache starting with zero resources. Also, none of
// these objects are required for any of tests that use this context. TODO: make stop allocating
// resources in the buffer pools.
SkDELETE(fDrawBuffer);
SkDELETE(fDrawBufferVBAllocPool);
SkDELETE(fDrawBufferIBAllocPool);
fDrawBuffer = NULL;
fDrawBufferVBAllocPool = NULL;
fDrawBufferIBAllocPool = NULL;
}
|
