Merge GrClipMaskManager into GrClipStackClip

TBR=bsalomon@google.com
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2196393007

Review-Url: https://codereview.chromium.org/2196393007

14 files changed, 119 insertions, 175 deletions

diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi
index e6291a3296..4f4ff3546f 100644
--- a/gyp/gpu.gypi
+++ b/gyp/gpu.gypi
@@ -84,8 +84,8 @@
       '<(skia_src_path)/gpu/GrBufferAllocPool.h',
       '<(skia_src_path)/gpu/GrCaps.cpp',
       '<(skia_src_path)/gpu/GrClip.cpp',
-      '<(skia_src_path)/gpu/GrClipMaskManager.h',
-      '<(skia_src_path)/gpu/GrClipMaskManager.cpp',
+      '<(skia_src_path)/gpu/GrClipStackClip.h',
+      '<(skia_src_path)/gpu/GrClipStackClip.cpp',
       '<(skia_src_path)/gpu/GrColorSpaceXform.cpp',
       '<(skia_src_path)/gpu/GrContext.cpp',
       '<(skia_src_path)/gpu/GrContextPriv.h',
diff --git a/include/gpu/GrClip.h b/include/gpu/GrClip.h
index c74d25d77a..03b9f65b9c 100644
--- a/include/gpu/GrClip.h
+++ b/include/gpu/GrClip.h
@@ -10,7 +10,6 @@
 
 #include "GrFragmentProcessor.h"
 #include "GrTypesPriv.h"
-#include "SkClipStack.h"
 
 class GrDrawContext;
 
@@ -270,37 +269,4 @@ private:
     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*,
-               GrDrawContext*,
-               const SkRect* devBounds,
-               bool useHWAA,
-               bool hasUserStencilSettings,
-               GrAppliedClip* out) const final;
-
-private:
-    SkIPoint                          fOrigin;
-    SkAutoTUnref<const SkClipStack>   fStack;
-};
-
 #endif
diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 2a7c1383a0..a34a43733a 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -423,10 +423,11 @@ private:
 
     GrAuditTrail                            fAuditTrail;
 
-    // TODO: have the CMM use drawContexts and rm this friending
-    friend class GrClipMaskManager; // the CMM is friended just so it can call 'drawingManager'
-    friend class GrDrawingManager;  // for access to drawingManager for ProgramUnitTest
+    // TODO: have the GrClipStackClip use drawContexts and rm this friending
+    friend class GrClipStackClip;  // for access to drawingManager
+    friend class GrDrawingManager; // for access to drawingManager for ProgramUnitTest
     friend class GrContextPriv;
+
     GrDrawingManager* drawingManager() { return fDrawingManager; }
 
     GrContext(); // init must be called after the constructor.
diff --git a/include/gpu/GrDrawContext.h b/include/gpu/GrDrawContext.h
index 948577cffa..6b582a6a63 100644
--- a/include/gpu/GrDrawContext.h
+++ b/include/gpu/GrDrawContext.h
@@ -314,7 +314,6 @@ private:
     friend class GrDrawContextPriv;
     friend class GrTestTarget;  // for access to getDrawTarget
     friend class GrSWMaskHelper;                 // for access to drawBatch
-    friend class GrClipMaskManager;              // for access to drawBatch
 
     // All the path renderers currently make their own batches
     friend class GrSoftwarePathRenderer;         // for access to drawBatch
diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp
index 441e56631c..d20226c195 100644
--- a/src/gpu/GrBlurUtils.cpp
+++ b/src/gpu/GrBlurUtils.cpp
@@ -17,6 +17,7 @@
 #include "SkGrPriv.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
+#include "SkTLazy.h"
 
 static bool clip_bounds_quick_reject(const SkIRect& clipBounds, const SkIRect& rect) {
     return clipBounds.isEmpty() || rect.isEmpty() || !SkIRect::Intersects(clipBounds, rect);
diff --git a/src/gpu/GrClip.cpp b/src/gpu/GrClip.cpp
index b0c8db3744..3eccd801b5 100644
--- a/src/gpu/GrClip.cpp
+++ b/src/gpu/GrClip.cpp
@@ -7,7 +7,6 @@
 
 #include "GrClip.h"
 
-#include "GrClipMaskManager.h"
 #include "GrDrawContext.h"
 
 void GrNoClip::getConservativeBounds(int width, int height, SkIRect* devResult,
@@ -70,36 +69,3 @@ bool GrFixedClip::apply(GrContext*,
     out->makeStencil(fHasStencilClip, fDeviceBounds);
     return true;
 }
-
-bool GrClipStackClip::quickContains(const SkRect& rect) const {
-    if (!fStack) {
-        return true;
-    }
-    return fStack->quickContains(rect.makeOffset(SkIntToScalar(fOrigin.x()),
-                                                 SkIntToScalar(fOrigin.y())));
-}
-
-void GrClipStackClip::getConservativeBounds(int width, int height, SkIRect* devResult,
-                                            bool* isIntersectionOfRects) const {
-    if (!fStack) {
-        devResult->setXYWH(0, 0, width, height);
-        if (isIntersectionOfRects) {
-            *isIntersectionOfRects = true;
-        }
-        return;
-    }
-    SkRect devBounds;
-    fStack->getConservativeBounds(-fOrigin.x(), -fOrigin.y(), width, height, &devBounds,
-                                  isIntersectionOfRects);
-    devBounds.roundOut(devResult);
-}
-
-bool GrClipStackClip::apply(GrContext* context,
-                            GrDrawContext* drawContext,
-                            const SkRect* devBounds,
-                            bool useHWAA,
-                            bool hasUserStencilSettings,
-                            GrAppliedClip* out) const {
-    return GrClipMaskManager::SetupClipping(context, drawContext, *this, devBounds,
-                                            useHWAA, hasUserStencilSettings, out);
-}
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipStackClip.cpp
index 8e57fc84d5..4bd6d55134 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -1,27 +1,18 @@
 /*
- * Copyright 2012 Google Inc.
+ * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "GrClipMaskManager.h"
-#include "GrCaps.h"
+#include "GrClipStackClip.h"
+
 #include "GrDrawingManager.h"
 #include "GrDrawContextPriv.h"
 #include "GrGpuResourcePriv.h"
-#include "GrPaint.h"
-#include "GrPathRenderer.h"
-#include "GrRenderTarget.h"
-#include "GrRenderTargetPriv.h"
-#include "GrResourceProvider.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
-#include "SkRasterClip.h"
-#include "SkTLazy.h"
-#include "batches/GrRectBatchFactory.h"
 #include "effects/GrConvexPolyEffect.h"
-#include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
@@ -30,6 +21,29 @@ typedef GrReducedClip::InitialState InitialState;
 
 static const int kMaxAnalyticElements = 4;
 
+bool GrClipStackClip::quickContains(const SkRect& rect) const {
+    if (!fStack) {
+        return true;
+    }
+    return fStack->quickContains(rect.makeOffset(SkIntToScalar(fOrigin.x()),
+                                                 SkIntToScalar(fOrigin.y())));
+}
+
+void GrClipStackClip::getConservativeBounds(int width, int height, SkIRect* devResult,
+                                            bool* isIntersectionOfRects) const {
+    if (!fStack) {
+        devResult->setXYWH(0, 0, width, height);
+        if (isIntersectionOfRects) {
+            *isIntersectionOfRects = true;
+        }
+        return;
+    }
+    SkRect devBounds;
+    fStack->getConservativeBounds(-fOrigin.x(), -fOrigin.y(), width, height, &devBounds,
+                                  isIntersectionOfRects);
+    devBounds.roundOut(devResult);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // set up the draw state to enable the aa clipping mask. Besides setting up the
 // stage matrix this also alters the vertex layout
@@ -56,13 +70,13 @@ static sk_sp<GrFragmentProcessor> create_fp_for_mask(GrTexture* result,
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
-bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
-                                            bool hasUserStencilSettings,
-                                            const GrDrawContext* drawContext,
-                                            const SkMatrix& viewMatrix,
-                                            const Element* element,
-                                            GrPathRenderer** prOut,
-                                            bool needsStencil) {
+bool GrClipStackClip::PathNeedsSWRenderer(GrContext* context,
+                                          bool hasUserStencilSettings,
+                                          const GrDrawContext* drawContext,
+                                          const SkMatrix& viewMatrix,
+                                          const Element* element,
+                                          GrPathRenderer** prOut,
+                                          bool needsStencil) {
     if (Element::kRect_Type == element->getType()) {
         // rects can always be drawn directly w/o using the software path
         // TODO: skip rrects once we're drawing them directly.
@@ -116,11 +130,11 @@ bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
-bool GrClipMaskManager::UseSWOnlyPath(GrContext* context,
-                                      bool hasUserStencilSettings,
-                                      const GrDrawContext* drawContext,
-                                      const SkVector& clipToMaskOffset,
-                                      const GrReducedClip::ElementList& elements) {
+bool GrClipStackClip::UseSWOnlyPath(GrContext* context,
+                                    bool hasUserStencilSettings,
+                                    const GrDrawContext* drawContext,
+                                    const SkVector& clipToMaskOffset,
+                                    const GrReducedClip::ElementList& elements) {
     // TODO: generalize this function so that when
     // a clip gets complex enough it can just be done in SW regardless
     // of whether it would invoke the GrSoftwarePathRenderer.
@@ -227,14 +241,13 @@ static bool get_analytic_clip_processor(const GrReducedClip::ElementList& elemen
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
-bool GrClipMaskManager::SetupClipping(GrContext* context,
-                                      GrDrawContext* drawContext,
-                                      const GrClipStackClip& clip,
-                                      const SkRect* origDevBounds,
-                                      bool useHWAA,
-                                      bool hasUserStencilSettings,
-                                      GrAppliedClip* out) {
-    if (!clip.clipStack() || clip.clipStack()->isWideOpen()) {
+bool GrClipStackClip::apply(GrContext* context,
+                            GrDrawContext* drawContext,
+                            const SkRect* origDevBounds,
+                            bool useHWAA,
+                            bool hasUserStencilSettings,
+                            GrAppliedClip* out) const {
+    if (!fStack || fStack->isWideOpen()) {
         return true;
     }
 
@@ -243,15 +256,15 @@ bool GrClipMaskManager::SetupClipping(GrContext* context,
         return false;
     }
 
-    const SkScalar clipX = SkIntToScalar(clip.origin().x()),
-                   clipY = SkIntToScalar(clip.origin().y());
+    const SkScalar clipX = SkIntToScalar(fOrigin.x()),
+                   clipY = SkIntToScalar(fOrigin.y());
 
     GrReducedClip::ElementList elements;
     int32_t genID = 0;
     SkIRect clipSpaceIBounds;
     bool requiresAA = false;
 
-    InitialState initialState = GrReducedClip::ReduceClipStack(*clip.clipStack(),
+    InitialState initialState = GrReducedClip::ReduceClipStack(*fStack,
                                                                devBounds.makeOffset(clipX, clipY),
                                                                &elements,
                                                                &genID,
@@ -262,7 +275,7 @@ bool GrClipMaskManager::SetupClipping(GrContext* context,
             return false;
         } else {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
-            scissorSpaceIBounds.offset(-clip.origin());
+            scissorSpaceIBounds.offset(-fOrigin);
             if (!GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
                 out->makeScissored(scissorSpaceIBounds);
             }
@@ -293,7 +306,7 @@ bool GrClipMaskManager::SetupClipping(GrContext* context,
             get_analytic_clip_processor(elements, disallowAnalyticAA, {-clipX, -clipY}, devBounds,
                                         &clipFP)) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
-            scissorSpaceIBounds.offset(-clip.origin());
+            scissorSpaceIBounds.offset(-fOrigin);
             if (GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
                 out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
             } else {
@@ -338,7 +351,7 @@ bool GrClipMaskManager::SetupClipping(GrContext* context,
             // The mask's top left coord should be pinned to the rounded-out top left corner of
             // clipSpace bounds. We determine the mask's position WRT to the render target here.
             SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
-            rtSpaceMaskBounds.offset(-clip.origin());
+            rtSpaceMaskBounds.offset(-fOrigin);
             out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds),
                              SkRect::Make(rtSpaceMaskBounds));
             return true;
@@ -347,7 +360,7 @@ bool GrClipMaskManager::SetupClipping(GrContext* context,
     }
 
     // use the stencil clip if we can't represent the clip as a rectangle.
-    SkIPoint clipSpaceToStencilSpaceOffset = -clip.origin();
+    SkIPoint clipSpaceToStencilSpaceOffset = -fOrigin;
     CreateStencilClipMask(context,
                           drawContext,
                           genID,
@@ -443,12 +456,12 @@ static void GetClipMaskKey(int32_t clipGenID, const SkIRect& bounds, GrUniqueKey
     builder[2] = SkToU16(bounds.fTop) | (SkToU16(bounds.fBottom) << 16);
 }
 
-sk_sp<GrTexture> GrClipMaskManager::CreateAlphaClipMask(GrContext* context,
-                                                        int32_t elementsGenID,
-                                                        GrReducedClip::InitialState initialState,
-                                                        const GrReducedClip::ElementList& elements,
-                                                        const SkVector& clipToMaskOffset,
-                                                        const SkIRect& clipSpaceIBounds) {
+sk_sp<GrTexture> GrClipStackClip::CreateAlphaClipMask(GrContext* context,
+                                                      int32_t elementsGenID,
+                                                      GrReducedClip::InitialState initialState,
+                                                      const GrReducedClip::ElementList& elements,
+                                                      const SkVector& clipToMaskOffset,
+                                                      const SkIRect& clipSpaceIBounds) {
     GrResourceProvider* resourceProvider = context->resourceProvider();
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
@@ -548,13 +561,13 @@ sk_sp<GrTexture> GrClipMaskManager::CreateAlphaClipMask(GrContext* context,
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
-bool GrClipMaskManager::CreateStencilClipMask(GrContext* context,
-                                              GrDrawContext* drawContext,
-                                              int32_t elementsGenID,
-                                              GrReducedClip::InitialState initialState,
-                                              const GrReducedClip::ElementList& elements,
-                                              const SkIRect& clipSpaceIBounds,
-                                              const SkIPoint& clipSpaceToStencilOffset) {
+bool GrClipStackClip::CreateStencilClipMask(GrContext* context,
+                                            GrDrawContext* drawContext,
+                                            int32_t elementsGenID,
+                                            GrReducedClip::InitialState initialState,
+                                            const GrReducedClip::ElementList& elements,
+                                            const SkIRect& clipSpaceIBounds,
+                                            const SkIPoint& clipSpaceToStencilOffset) {
     SkASSERT(drawContext);
 
     GrStencilAttachment* stencilAttachment = context->resourceProvider()->attachStencilAttachment(
@@ -620,9 +633,10 @@ bool GrClipMaskManager::CreateStencilClipMask(GrContext* context,
                 canDrawArgs.fHasUserStencilSettings = false;
                 canDrawArgs.fIsStencilBufferMSAA = drawContext->isStencilBufferMultisampled();
 
-                pr = context->drawingManager()->getPathRenderer(canDrawArgs, false,
-                                                                GrPathRendererChain::kStencilOnly_DrawType,
-                                                                &stencilSupport);
+                GrDrawingManager* dm = context->drawingManager();
+                pr = dm->getPathRenderer(canDrawArgs, false,
+                                         GrPathRendererChain::kStencilOnly_DrawType,
+                                         &stencilSupport);
                 if (!pr) {
                     return false;
                 }
@@ -731,13 +745,12 @@ bool GrClipMaskManager::CreateStencilClipMask(GrContext* context,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-sk_sp<GrTexture> GrClipMaskManager::CreateSoftwareClipMask(
-                                                    GrTextureProvider* texProvider,
-                                                    int32_t elementsGenID,
-                                                    GrReducedClip::InitialState initialState,
-                                                    const GrReducedClip::ElementList& elements,
-                                                    const SkVector& clipToMaskOffset,
-                                                    const SkIRect& clipSpaceIBounds) {
+sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texProvider,
+                                                         int32_t elementsGenID,
+                                                         GrReducedClip::InitialState initialState,
+                                                         const GrReducedClip::ElementList& elements,
+                                                         const SkVector& clipToMaskOffset,
+                                                         const SkIRect& clipSpaceIBounds) {
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
     if (GrTexture* texture = texProvider->findAndRefTextureByUniqueKey(key)) {
diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipStackClip.h
index 5cf3569072..38f9e2d671 100644
--- a/src/gpu/GrClipMaskManager.h
+++ b/src/gpu/GrClipStackClip.h
@@ -1,50 +1,44 @@
 /*
- * Copyright 2012 Google Inc.
+ * 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 GrClipMaskManager_DEFINED
-#define GrClipMaskManager_DEFINED
+#ifndef GrClipStackClip_DEFINED
+#define GrClipStackClip_DEFINED
+
+#include "GrClip.h"
 
 #include "GrReducedClip.h"
 #include "SkClipStack.h"
-#include "SkTypes.h"
 
-class GrAppliedClip;
-class GrClipStackClip;
-class GrContext;
-class GrDrawContext;
-class GrPathRenderer;
-class GrTexture;
 class GrTextureProvider;
-class GrUniqueKey;
-
+class GrPathRenderer;
 
 /**
- * The clip mask creator handles the generation of the clip mask. If anti
- * aliasing is requested it will (in the future) generate a single channel
- * (8bit) mask. If no anti aliasing is requested it will generate a 1-bit
- * mask in the stencil buffer. In the non anti-aliasing case, if the clip
- * mask can be represented as a rectangle then scissoring is used. In all
- * cases scissoring is used to bound the range of the clip mask.
+ * GrClipStackClip can apply a generic SkClipStack to the draw state. It may need to generate an
+ * 8-bit alpha clip mask and/or modify the stencil buffer during apply().
  */
-// This has to remain a class, for now, so it can be friended (by GrDrawContext & GrContext)
-class GrClipMaskManager {
+class GrClipStackClip final : public GrClip {
 public:
-    /**
-     * Creates a clip mask if necessary as a stencil buffer or alpha texture
-     * and sets the GrGpu's scissor and stencil state. If the return is false
-     * then the draw can be skipped. devBounds is optional but can help optimize
-     * clipping.
-     */
-    static bool SetupClipping(GrContext*,
-                              GrDrawContext*,
-                              const GrClipStackClip&,
-                              const SkRect* devBounds,
-                              bool useHWAA,
-                              bool hasUserStencilSettings,
-                              GrAppliedClip* out);
+    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));
+    }
+
+    bool quickContains(const SkRect&) const final;
+    void getConservativeBounds(int width, int height, SkIRect* devResult,
+                               bool* isIntersectionOfRects) const final;
+    bool apply(GrContext*,
+               GrDrawContext*,
+               const SkRect* devBounds,
+               bool useHWAA,
+               bool hasUserStencilSettings,
+               GrAppliedClip* out) const final;
 
 private:
     static bool PathNeedsSWRenderer(GrContext* context,
@@ -89,6 +83,9 @@ private:
 
     static GrTexture* CreateCachedMask(int width, int height, const GrUniqueKey& key,
                                        bool renderTarget);
+
+    SkIPoint                          fOrigin;
+    SkAutoTUnref<const SkClipStack>   fStack;
 };
 
-#endif // GrClipMaskManager_DEFINED
+#endif // GrClipStackClip_DEFINED
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index bb473cafe4..4ab467ccf4 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -49,7 +49,7 @@ GrDrawTarget::GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider* r
     , fAuditTrail(auditTrail)
     , fFlags(0)
     , fRenderTarget(rt) {
-    // TODO: Stop extracting the context (currently needed by GrClipMaskManager)
+    // TODO: Stop extracting the context (currently needed by GrClip)
     fContext = fGpu->getContext();
 
     fClipBatchToBounds = options.fClipBatchToBounds;
diff --git a/src/gpu/GrDrawTarget.h b/src/gpu/GrDrawTarget.h
index 02a7770134..6149e922cb 100644
--- a/src/gpu/GrDrawTarget.h
+++ b/src/gpu/GrDrawTarget.h
@@ -214,7 +214,7 @@ private:
         SkRect         fClippedBounds;
     };
     SkSTArray<256, RecordedBatch, true>             fRecordedBatches;
-    // The context is only in service of the clip mask manager, remove once CMM doesn't need this.
+    // The context is only in service of the GrClip, remove once it doesn't need this.
     GrContext*                                      fContext;
     GrGpu*                                          fGpu;
     GrResourceProvider*                             fResourceProvider;
diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index 6d1d9b1d46..f2bb34b30c 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -75,7 +75,7 @@ public:
                                              const SkMatrix* matrix);
 
     // This utility routine is used to add a shape's mask to some other draw.
-    // The ClipMaskManager uses it to accumulate clip masks while the
+    // The GrClipStackClip uses it to accumulate clip masks while the
     // GrSoftwarePathRenderer uses it to fulfill a drawPath call.
     // It draws with "texture" as a path mask into "target" using "rect" as
     // geometry and the current drawState. The current drawState is altered to
diff --git a/src/gpu/GrStencilAttachment.h b/src/gpu/GrStencilAttachment.h
index 7573d23d1d..8f41b57e21 100644
--- a/src/gpu/GrStencilAttachment.h
+++ b/src/gpu/GrStencilAttachment.h
@@ -9,8 +9,8 @@
 #ifndef GrStencilAttachment_DEFINED
 #define GrStencilAttachment_DEFINED
 
-#include "GrClip.h"
 #include "GrGpuResource.h"
+#include "SkClipStack.h"
 
 class GrRenderTarget;
 class GrResourceKey;
diff --git a/src/gpu/SkGpuDevice.h b/src/gpu/SkGpuDevice.h
index fbbcc4ed2e..efb674472b 100644
--- a/src/gpu/SkGpuDevice.h
+++ b/src/gpu/SkGpuDevice.h
@@ -15,6 +15,7 @@
 #include "SkPicture.h"
 #include "SkRegion.h"
 #include "SkSurface.h"
+#include "GrClipStackClip.h"
 #include "GrDrawContext.h"
 #include "GrContext.h"
 #include "GrSurfacePriv.h"
diff --git a/tests/ClipBoundsTest.cpp b/tests/ClipBoundsTest.cpp
index 246cf6e60c..ae2c0277d6 100644
--- a/tests/ClipBoundsTest.cpp
+++ b/tests/ClipBoundsTest.cpp
@@ -8,7 +8,7 @@
 #include "Test.h"
 // This is a GR test
 #if SK_SUPPORT_GPU
-#include "GrClipMaskManager.h"
+#include "GrClipStackClip.h"
 #include "GrContext.h"
 
 // Ensure that the 'getConservativeBounds' calls are returning bounds clamped