Revert of Clip mask manager sets stencil on draw type

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 288 matching lines @@
      * which (called as part of GrGpu's implementation of onDraw and
      * onStencilPath member functions.) The GrGpu subclass should flush the
      * stencil state to the 3D API in its implementation of flushGraphicsState.
      */
     void enableScissor(const SkIRect& rect) {
         fScissorState.fEnabled = true;
         fScissorState.fRect = rect;
     }
     void disableScissor() { fScissorState.fEnabled = false; }
 
+    /**
+     * Like the scissor methods above this is called by setupClipping and
+     * should be flushed by the GrGpu subclass in flushGraphicsState. These
+     * stencil settings should be used in place of those on the GrDrawState.
+     * They have been adjusted to account for any interactions between the
+     * GrDrawState's stencil settings and stencil clipping.
+     */
+    void setStencilSettings(const GrStencilSettings& settings) {
+        fStencilSettings = settings;
+    }
+    void disableStencil() { fStencilSettings.setDisabled(); }
+
     // GrGpu subclass sets clip bit in the stencil buffer. The subclass is
     // free to clear the remaining bits to zero if masked clears are more
     // expensive than clearing all bits.
     virtual void clearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) = 0;
 
     enum PrivateDrawStateStateBits {
         kFirstBit = (GrDrawState::kLastPublicStateBit << 1),
 
         kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify
                                                  // stencil bits used for
@@ skipping 31 matching lines @@
                 return kDrawLines_DrawType;
             default:
                 SkFAIL("Unexpected primitive type");
                 return kDrawTriangles_DrawType;
         }
     }
 
     // prepares clip flushes gpu state before a draw
     bool setupClipAndFlushState(DrawType,
                                 const GrDeviceCoordTexture* dstCopy,
-                                GrDrawState::AutoRestoreEffects*,
-                                GrDrawState::AutoRestoreStencil*,
+                                GrDrawState::AutoRestoreEffects* are,
                                 const SkRect* devBounds);
 
     // 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,
                                           bool clipInStencil,
                                           unsigned int clipBit,
                                           unsigned int userBits,
@@ skipping 14 matching lines @@
     const GeometryPoolState& getGeomPoolState() {
         return fGeomPoolStateStack.back();
     }
 
     // The state of the scissor is controlled by the clip manager
     struct ScissorState {
         bool    fEnabled;
         SkIRect fRect;
     } fScissorState;
 
+    // The final stencil settings to use as determined by the clip manager.
+    GrStencilSettings fStencilSettings;
+
     // Helpers for setting up geometry state
     void finalizeReservedVertices();
     void finalizeReservedIndices();
 
     SkAutoTDelete<GrPathRendering> fPathRendering;
 
 private:
     // GrDrawTarget overrides
     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE;
     virtual bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE;
@@ skipping 108 matching lines @@
     // counts number of uses of vertex/index pool in the geometry stack
     int                                                                 fVertexPoolUseCnt;
     int                                                                 fIndexPoolUseCnt;
     // these are mutable so they can be created on-demand
     mutable GrIndexBuffer*                                              fQuadIndexBuffer;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif