Add Gr*Proxy classes

include/private/GrRenderTargetProxy.h

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrRenderTargetProxy_DEFINED
+#define GrRenderTargetProxy_DEFINED
+
+#include "GrRenderTarget.h"
+#include "GrSurfaceProxy.h"
+#include "GrTypes.h"
+
+class GrTextureProvider;
+
+// This class delays the acquisition of RenderTargets until they are actually
+// required
+// Beware: the uniqueID of the RenderTargetProxy will usually be different than
+// the uniqueID of the RenderTarget it represents!
+class GrRenderTargetProxy : public GrSurfaceProxy {
+public:
+    /**
+     * The caller gets the creation ref.
+     */
+    static sk_sp<GrRenderTargetProxy> Make(const GrCaps&, const GrSurfaceDesc&,
+                                           SkBackingFit, SkBudgeted);
+    static sk_sp<GrRenderTargetProxy> Make(sk_sp<GrRenderTarget> rt);
+
+    ~GrRenderTargetProxy() override;
+
+    // TODO: add asTextureProxy variants
+    GrRenderTargetProxy* asRenderTargetProxy() override { return this; }
+    const GrRenderTargetProxy* asRenderTargetProxy() const override { return this; }
+
+    // Actually instantiate the backing rendertarget, if necessary.
+    GrRenderTarget* instantiate(GrTextureProvider* texProvider);
+
+    /**
+     * @return true  if the surface is multisampled in all buffers,
+     *         false otherwise
+     */
+    bool isUnifiedMultisampled() const {
+        if (fSampleConfig != GrRenderTarget::kUnified_SampleConfig) {
+            return false;
+        }
+        return 0 != fDesc.fSampleCnt;
+    }
+
+    /**
+     * @return true if the surface is multisampled in the stencil buffer,
+     *         false otherwise
+     */
+    bool isStencilBufferMultisampled() const {
+        return 0 != fDesc.fSampleCnt;
+    }
+
+    /**
+     * @return the number of color samples-per-pixel, or zero if non-MSAA or
+     *         multisampled in the stencil buffer only.
+     */
+    int numColorSamples() const {
+        if (fSampleConfig == GrRenderTarget::kUnified_SampleConfig) {
+            return fDesc.fSampleCnt;
+        }
+        return 0;
+    }
+
+    /**
+     * @return the number of stencil samples-per-pixel, or zero if non-MSAA.
+     */
+    int numStencilSamples() const {
+        return fDesc.fSampleCnt;
+    }
+
+    /**
+     * @return true if the surface is mixed sampled, false otherwise.
+     */
+    bool hasMixedSamples() const {
+        SkASSERT(GrRenderTarget::kStencil_SampleConfig != fSampleConfig ||
+                 this->isStencilBufferMultisampled());
+        return GrRenderTarget::kStencil_SampleConfig == fSampleConfig;
+    }
+
+    void setLastDrawTarget(GrDrawTarget* dt);
+    GrDrawTarget* getLastDrawTarget() { return fLastDrawTarget; }
+
+private:
+    // TODO: we can probably munge the 'desc' in both the wrapped and deferred 
+    // cases to make the sampleConfig/numSamples stuff more rational.
+    GrRenderTargetProxy(const GrCaps& caps, const GrSurfaceDesc& desc,
+                        SkBackingFit fit, SkBudgeted budgeted)
+        : INHERITED(desc, fit, budgeted)
+        , fTarget(nullptr)
+        , fSampleConfig(GrRenderTarget::ComputeSampleConfig(caps, desc.fSampleCnt))
+        , fLastDrawTarget(nullptr) {
+    }
+
+    // Wrapped version
+    GrRenderTargetProxy(sk_sp<GrRenderTarget> rt);
+
+    // For wrapped render targets we store it here.
+    // For deferred proxies we will fill this in when we need to instantiate the deferred resource
+    sk_sp<GrRenderTarget>        fTarget;
+
+    // The sample config doesn't usually get computed until the render target is instantiated but
+    // the render target proxy may need to answer queries about it before then. For this reason
+    // we precompute it in the deferred case. In the wrapped case we just copy the wrapped
+    // rendertarget's info here.
+    GrRenderTarget::SampleConfig fSampleConfig;
+
+    // The last drawTarget that wrote to or is currently going to write to this renderTarget
+    // The drawTarget can be closed (e.g., no draw context is currently bound
+    // to this renderTarget).
+    // This back-pointer is required so that we can add a dependancy between
+    // the drawTarget used to create the current contents of this renderTarget
+    // and the drawTarget of a destination renderTarget to which this one is being drawn.
+    GrDrawTarget* fLastDrawTarget;
+
+    typedef GrSurfaceProxy INHERITED;
+};
+
+#endif