1 /*
2  * Copyright 2017 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #ifndef GrSurfaceProxyPriv_DEFINED
9 #define GrSurfaceProxyPriv_DEFINED
10 
11 #include "GrSurfaceProxy.h"
12 
13 #include "GrResourceProvider.h"
14 
15 /** Class that adds methods to GrSurfaceProxy that are only intended for use internal to Skia.
16     This class is purely a privileged window into GrSurfaceProxy. It should never have additional
17     data members or virtual methods. */
18 class GrSurfaceProxyPriv {
19 public:
20     // Beware! Woe betide anyone whosoever calls this method.
21     // The refs on proxies and their backing GrSurfaces shift around based on whether the proxy
22     // is instantiated or not. Additionally, the lifetime of a proxy (and a GrSurface) also
23     // depends on the read and write refs (So this method can validly return 0).
24     int32_t getProxyRefCnt() const { return fProxy->getProxyRefCnt(); }
25 
26     // Beware! This call is only guaranteed to tell you if the proxy in question has
27     // any pending IO in its current state. It won't tell you about the IO state in the
28     // future when the proxy is actually used/instantiated.
29     bool hasPendingIO() const { return fProxy->hasPendingIO(); }
30 
31     // Beware! This call is only guaranteed to tell you if the proxy in question has
32     // any pending writes in its current state. It won't tell you about the IO state in the
33     // future when the proxy is actually used/instantiated.
34     bool hasPendingWrite() const { return fProxy->hasPendingWrite(); }
35 
36     void computeScratchKey(GrScratchKey* key) const { return fProxy->computeScratchKey(key); }
37 
38     // Create a GrSurface-derived class that meets the requirements (i.e, desc, renderability)
39     // of the GrSurfaceProxy.
40     sk_sp<GrSurface> createSurface(GrResourceProvider* resourceProvider) const {
41         return fProxy->createSurface(resourceProvider);
42     }
43 
44     // Assign this proxy the provided GrSurface as its backing surface
45     void assign(sk_sp<GrSurface> surface) { fProxy->assign(std::move(surface)); }
46 
47     bool requiresNoPendingIO() const {
48         return fProxy->fSurfaceFlags & GrInternalSurfaceFlags::kNoPendingIO;
49     }
50 
51     // Don't abuse this call!!!!!!!
52     bool isExact() const { return SkBackingFit::kExact == fProxy->fFit; }
53 
54     // Don't. Just don't.
55     void exactify();
56 
57     bool doLazyInstantiation(GrResourceProvider*);
58 
59     GrSurfaceProxy::LazyInstantiationType lazyInstantiationType() const {
60         return fProxy->fLazyInstantiationType;
61     }
62 
63     bool isSafeToDeinstantiate() const {
64         return SkToBool(fProxy->fTarget) &&
65                SkToBool(fProxy->fLazyInstantiateCallback) &&
66                GrSurfaceProxy::LazyInstantiationType::kDeinstantiate == lazyInstantiationType();
67     }
68 
69     static bool SK_WARN_UNUSED_RESULT AttachStencilIfNeeded(GrResourceProvider*, GrSurface*,
70                                                             bool needsStencil);
71 
72 private:
73     explicit GrSurfaceProxyPriv(GrSurfaceProxy* proxy) : fProxy(proxy) {}
74     GrSurfaceProxyPriv(const GrSurfaceProxyPriv&) {} // unimpl
75     GrSurfaceProxyPriv& operator=(const GrSurfaceProxyPriv&); // unimpl
76 
77     // No taking addresses of this type.
78     const GrSurfaceProxyPriv* operator&() const;
79     GrSurfaceProxyPriv* operator&();
80 
81     GrSurfaceProxy* fProxy;
82 
83     friend class GrSurfaceProxy; // to construct/copy this type.
84 };
85 
86 inline GrSurfaceProxyPriv GrSurfaceProxy::priv() { return GrSurfaceProxyPriv(this); }
87 
88 inline const GrSurfaceProxyPriv GrSurfaceProxy::priv () const {
89     return GrSurfaceProxyPriv(const_cast<GrSurfaceProxy*>(this));
90 }
91 
92 #endif
93