Move some of the adding stencil attachment logic of Gpu and into Render Target.

src/gpu/GrGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpu_DEFINED
 #define GrGpu_DEFINED
 
@@ skipping 356 matching lines @@
     Stats* stats() { return &fStats; }
 
     // creation and deletion of raw texture for testing
     // only to be used in GPU-specific tests
     virtual GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
                                                             GrPixelConfig config) const = 0;
     virtual bool isTestingOnlyBackendTexture(GrBackendObject id) const = 0;
     virtual void deleteTestingOnlyBackendTexture(GrBackendObject id) const = 0;
 
     // Given a rt, find or create a stencil buffer and attach it
-    bool attachStencilAttachmentToRenderTarget(GrRenderTarget* target);
+//    bool attachStencilAttachmentToRenderTarget(GrRenderTarget* target);
+
+    // Given the input GrRenderTarget, this function sets GrStencilAttachment* either
+    // from a cached stencil attachment or by creating a new one. If the GrStencilAttachment*
+    // that is returned is non-null, the caller will own the ref on the GrStencilAttachment.
+    // This function returns true if the returned GrStencilAttachment was newly created in case
+    // the caller wants to do any special thing with the stencil (e.g. clearning it).
+    bool getStencilAttachment(const GrRenderTarget*, GrStencilAttachment**);
+
+    // clears target's entire stencil buffer to 0
+    virtual void clearStencil(GrRenderTarget* target) = 0;

[egdaniel, 2015/09/11 17:59:49]

Since we are not letting the RT handle the attaching, the RT also has to be
responsible for calling clear on the stencil. For future work, maybe this clear
should really be implemented in the RT and not the gpu.

 
     // This is only to be used in GL-specific tests.
     virtual const GrGLContext* glContextForTesting() const { return nullptr; }
 
 protected:
     // Functions used to map clip-respecting stencil tests into normal
     // stencil funcs supported by GPUs.
     static GrStencilFunc ConvertStencilFunc(bool stencilInClip,
                                             GrStencilFunc func);
     static void ConvertStencilFuncAndMask(GrStencilFunc func,
@@ skipping 76 matching lines @@
     // overridden by backend-specific derived class to perform the resolve
     virtual void onResolveRenderTarget(GrRenderTarget* target) = 0;
 
     // overridden by backend specific derived class to perform the copy surface
     virtual bool onCopySurface(GrSurface* dst,
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) = 0;
 
     // width and height may be larger than rt (if underlying API allows it).
-    // Should attach the SB to the RT. Returns false if compatible sb could
-    // not be created.
-    virtual bool createStencilAttachmentForRenderTarget(GrRenderTarget*, int width, int height) = 0;
-
-    // attaches an existing SB to an existing RT.
-    virtual bool attachStencilAttachmentToRenderTarget(GrStencilAttachment*, GrRenderTarget*) = 0;
-
-    // clears target's entire stencil buffer to 0
-    virtual void clearStencil(GrRenderTarget* target) = 0;
+    // Returns nullptr if compatible sb could not be created.
+    virtual GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
+                                                                        int width,
+                                                                        int height) = 0;
 
     void resetContext() {
         this->onResetContext(fResetBits);
         fResetBits = 0;
         ++fResetTimestamp;
     }
 
     void handleDirtyContext() {
         if (fResetBits) {
             this->resetContext();
         }
     }
 
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     friend class GrPathRendering;
     typedef SkRefCnt INHERITED;
 };
 
 #endif