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
|
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrOnFlushResourceProvider.h"
#include "GrContext.h"
#include "GrContextPriv.h"
#include "GrDrawingManager.h"
#include "GrProxyProvider.h"
#include "GrRenderTargetContext.h"
#include "GrSurfaceProxy.h"
sk_sp<GrRenderTargetContext> GrOnFlushResourceProvider::makeRenderTargetContext(
const GrSurfaceDesc& desc,
GrSurfaceOrigin origin,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
GrSurfaceDesc tmpDesc = desc;
tmpDesc.fFlags |= kRenderTarget_GrSurfaceFlag;
auto proxyProvider = fDrawingMgr->getContext()->contextPriv().proxyProvider();
auto resourceProvider = fDrawingMgr->getContext()->contextPriv().resourceProvider();
// Because this is being allocated at the start of a flush we must ensure the proxy
// will, when instantiated, have no pending IO.
// TODO: fold the kNoPendingIO_Flag into GrSurfaceFlags?
sk_sp<GrSurfaceProxy> proxy =
proxyProvider->createProxy(tmpDesc, origin, SkBackingFit::kExact, SkBudgeted::kYes,
GrInternalSurfaceFlags::kNoPendingIO);
if (!proxy || !proxy->asRenderTargetProxy()) {
return nullptr;
}
sk_sp<GrRenderTargetContext> renderTargetContext(
fDrawingMgr->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace),
props, false));
if (!renderTargetContext) {
return nullptr;
}
// Since this is at flush time and these won't be allocated for us by the GrResourceAllocator
// we have to manually ensure it is allocated here. The proxy had best have been created
// with the kNoPendingIO flag!
if (!renderTargetContext->asSurfaceProxy()->instantiate(resourceProvider)) {
return nullptr;
}
renderTargetContext->discard();
return renderTargetContext;
}
sk_sp<GrRenderTargetContext> GrOnFlushResourceProvider::makeRenderTargetContext(
sk_sp<GrSurfaceProxy> proxy,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props) {
// Since this is at flush time and these won't be allocated for us by the GrResourceAllocator
// we have to manually ensure it is allocated here. The proxy had best have been created
// with the kNoPendingIO flag!
if (!this->instatiateProxy(proxy.get())) {
return nullptr;
}
sk_sp<GrRenderTargetContext> renderTargetContext(
fDrawingMgr->makeRenderTargetContext(std::move(proxy),
std::move(colorSpace),
props, false));
if (!renderTargetContext) {
return nullptr;
}
renderTargetContext->discard();
return renderTargetContext;
}
bool GrOnFlushResourceProvider::assignUniqueKeyToProxy(const GrUniqueKey& key,
GrTextureProxy* proxy) {
auto proxyProvider = fDrawingMgr->getContext()->contextPriv().proxyProvider();
return proxyProvider->assignUniqueKeyToProxy(key, proxy);
}
void GrOnFlushResourceProvider::removeUniqueKeyFromProxy(const GrUniqueKey& key,
GrTextureProxy* proxy) {
auto proxyProvider = fDrawingMgr->getContext()->contextPriv().proxyProvider();
proxyProvider->removeUniqueKeyFromProxy(key, proxy);
}
sk_sp<GrTextureProxy> GrOnFlushResourceProvider::findOrCreateProxyByUniqueKey(
const GrUniqueKey& key, GrSurfaceOrigin origin) {
auto proxyProvider = fDrawingMgr->getContext()->contextPriv().proxyProvider();
return proxyProvider->findOrCreateProxyByUniqueKey(key, origin);
}
bool GrOnFlushResourceProvider::instatiateProxy(GrSurfaceProxy* proxy) {
auto resourceProvider = fDrawingMgr->getContext()->contextPriv().resourceProvider();
if (GrSurfaceProxy::LazyState::kNot != proxy->lazyInstantiationState()) {
// DDL TODO: Decide if we ever plan to have these proxies use the GrUninstantiateTracker
// to support unistantiating them at the end of a flush.
return proxy->priv().doLazyInstantiation(resourceProvider);
}
return proxy->instantiate(resourceProvider);
}
sk_sp<GrBuffer> GrOnFlushResourceProvider::makeBuffer(GrBufferType intendedType, size_t size,
const void* data) {
auto resourceProvider = fDrawingMgr->getContext()->contextPriv().resourceProvider();
return sk_sp<GrBuffer>(resourceProvider->createBuffer(size, intendedType,
kDynamic_GrAccessPattern,
GrResourceProvider::kNoPendingIO_Flag,
data));
}
sk_sp<const GrBuffer> GrOnFlushResourceProvider::findOrMakeStaticBuffer(GrBufferType intendedType,
size_t size,
const void* data,
const GrUniqueKey& key) {
auto resourceProvider = fDrawingMgr->getContext()->contextPriv().resourceProvider();
sk_sp<const GrBuffer> buffer = resourceProvider->findOrMakeStaticBuffer(intendedType, size,
data, key);
// Static buffers should never have pending IO.
SkASSERT(!buffer->resourcePriv().hasPendingIO_debugOnly());
return buffer;
}
uint32_t GrOnFlushResourceProvider::contextUniqueID() const {
return fDrawingMgr->getContext()->uniqueID();
}
const GrCaps* GrOnFlushResourceProvider::caps() const {
return fDrawingMgr->getContext()->contextPriv().caps();
}
|
