skip call to clip::apply when clip is wide open

include/gpu/GrClip.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrClip_DEFINED
 #define GrClip_DEFINED
 
+#include "GrTypes.h"
 #include "GrFragmentProcessor.h"
-#include "GrTypesPriv.h"
-#include "SkClipStack.h"
 
-class GrDrawContext;
 class GrPipelineBuilder;
 
 /**
  * Produced by GrClip. It provides a set of modifications to the drawing state that are used to
  * create the final GrPipeline for a GrBatch.
  */
 class GrAppliedClip : public SkNoncopyable {
 public:
     GrAppliedClip() : fHasStencilClip(false), fDeviceBounds(SkRect::MakeLargest()) {}
     GrFragmentProcessor* getClipCoverageFragmentProcessor() const {
@@ skipping 76 matching lines @@
  */
 class GrClip {
 public:
     virtual bool quickContains(const SkRect&) const = 0;
     virtual void getConservativeBounds(int width, int height, SkIRect* devResult,
                                        bool* isIntersectionOfRects = nullptr) const = 0;
     virtual bool apply(GrContext*, const GrPipelineBuilder&, GrDrawContext*,
                        const SkRect* devBounds, GrAppliedClip*) const = 0;
 
     virtual ~GrClip() {}
+
+    bool isWideOpen() const { return fIsWideOpen; }
+
+protected:
+    GrClip(bool isWideOpen) : fIsWideOpen(isWideOpen) {}
+    bool fIsWideOpen;
 };
 
 /**
  * Specialized implementation for no clip.
  */
 class GrNoClip final : public GrClip {
+public:
+    GrNoClip() : INHERITED(true) {}
 private:
     bool quickContains(const SkRect&) const final { return true; }
     void getConservativeBounds(int width, int height, SkIRect* devResult,
                                bool* isIntersectionOfRects) const final;
     bool apply(GrContext*, const GrPipelineBuilder&, GrDrawContext*,
                const SkRect*, GrAppliedClip*) const final { return true; }
+    typedef GrClip INHERITED;
 };
 
 /**
  * GrFixedClip is a clip that can be represented by fixed-function hardware. It never modifies the
  * stencil buffer itself, but can be configured to use whatever clip is already there.
  */
 class GrFixedClip final : public GrClip {
 public:
-    GrFixedClip() : fDeviceBounds(SkRect::MakeLargest()), fHasStencilClip(false) {}
-    GrFixedClip(const SkIRect& scissorRect)
-        : fScissorState(scissorRect)
-        , fDeviceBounds(SkRect::Make(scissorRect))
-        , fHasStencilClip(false) {}
+    GrFixedClip() : INHERITED(true) {
+        fDeviceBounds = SkRect::MakeLargest();
+        fHasStencilClip = false;
+    }
+    GrFixedClip(const SkIRect& scissorRect) : INHERITED(false) {
+        fScissorState = scissorRect;
+        fDeviceBounds = SkRect::Make(scissorRect);
+        fHasStencilClip = false;
+    }
 
     void reset() {
+        fIsWideOpen = true;
         fScissorState.setDisabled();
         fDeviceBounds.setLargest();
         fHasStencilClip = false;
     }
 
     void reset(const SkIRect& scissorRect) {
+        fIsWideOpen = false;
         fScissorState.set(scissorRect);
         fDeviceBounds = SkRect::Make(scissorRect);
         fHasStencilClip = false;
     }
 
     /**
      * Enables stenciling. The stencil bounds is the device space bounds where the stencil test
      * may pass.
      */
     void enableStencilClip(const SkRect& stencilBounds) {
+        fIsWideOpen = false;
         fHasStencilClip = true;
         fDeviceBounds = stencilBounds;
         if (fScissorState.enabled()) {
             const SkIRect& s = fScissorState.rect();
             fDeviceBounds.fLeft   = SkTMax(fDeviceBounds.fLeft,   SkIntToScalar(s.fLeft));
             fDeviceBounds.fTop    = SkTMax(fDeviceBounds.fTop,    SkIntToScalar(s.fTop));
             fDeviceBounds.fRight  = SkTMin(fDeviceBounds.fRight,  SkIntToScalar(s.fRight));
             fDeviceBounds.fBottom = SkTMin(fDeviceBounds.fBottom, SkIntToScalar(s.fBottom));
         }
     }
 
     void disableStencilClip() {
         fHasStencilClip = false;
         if (fScissorState.enabled()) {
+            fIsWideOpen = false;
             fDeviceBounds = SkRect::Make(fScissorState.rect());
         } else {
+            fIsWideOpen = true;
             fDeviceBounds.setLargest();
         }
     }
 
     const GrScissorState& scissorState() const { return fScissorState; }
     bool hasStencilClip() const { return fHasStencilClip; }
 
     bool quickContains(const SkRect&) const final;
     void getConservativeBounds(int width, int height, SkIRect* devResult,
                                bool* isIntersectionOfRects) const final;
 
 private:
     bool apply(GrContext*, const GrPipelineBuilder&, GrDrawContext*,
                const SkRect* devBounds, GrAppliedClip* out) const final;
 
     GrScissorState   fScissorState;
     SkRect           fDeviceBounds;
     bool             fHasStencilClip;
-};
-
-/**
- * GrClipStackClip can apply a generic SkClipStack to the draw state. It may generate clip masks or
- * write to the stencil buffer during apply().
- */
-class GrClipStackClip final : public GrClip {
-public:
-    GrClipStackClip(const SkClipStack* stack = nullptr, const SkIPoint* origin = nullptr) {
-        this->reset(stack, origin);
-    }
-
-    void reset(const SkClipStack* stack = nullptr, const SkIPoint* origin = nullptr) {
-        fOrigin = origin ? *origin : SkIPoint::Make(0, 0);
-        fStack.reset(SkSafeRef(stack));
-    }
-
-    const SkIPoint& origin() const { return fOrigin; }
-    const SkClipStack* clipStack() const { return fStack; }
-
-    bool quickContains(const SkRect&) const final;
-    void getConservativeBounds(int width, int height, SkIRect* devResult,
-                               bool* isIntersectionOfRects) const final;
-    bool apply(GrContext*, const GrPipelineBuilder&, GrDrawContext*,
-               const SkRect* devBounds, GrAppliedClip*) const final;
-
-private:
-    SkIPoint                          fOrigin;
-    SkAutoTUnref<const SkClipStack>   fStack;
+    typedef GrClip INHERITED;
 };
 
 #endif