Replace uses of GrAssert by SkASSERT.

src/gpu/GrPathRenderer.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 GrPathRenderer_DEFINED
@@ skipping 66 matching lines @@
      * This function is to get the stencil support for a particular path. The path's fill must
      * not be an inverse type.
      *
      * @param target    target that the path will be rendered to
      * @param path      the path that will be drawn
      * @param stroke    the stroke information (width, join, cap).
      */
     StencilSupport getStencilSupport(const SkPath& path,
                                      const SkStrokeRec& stroke,
                                      const GrDrawTarget* target) const {
-        GrAssert(!path.isInverseFillType());
+        SkASSERT(!path.isInverseFillType());
         return this->onGetStencilSupport(path, stroke, target);
     }
 
     /**
      * Returns true if this path renderer is able to render the path. Returning false allows the
      * caller to fallback to another path renderer This function is called when searching for a path
      * renderer capable of rendering a path.
      *
      * @param path       The path to draw
      * @param stroke     The stroke information (width, join, cap)
@@ skipping 12 matching lines @@
      *
      * @param path                  the path to draw.
      * @param stroke                the stroke information (width, join, cap)
      * @param target                target that the path will be rendered to
      * @param antiAlias             true if anti-aliasing is required.
      */
     bool drawPath(const SkPath& path,
                   const SkStrokeRec& stroke,
                   GrDrawTarget* target,
                   bool antiAlias) {
-        GrAssert(!path.isEmpty());
-        GrAssert(this->canDrawPath(path, stroke, target, antiAlias));
-        GrAssert(target->drawState()->getStencil().isDisabled() ||
+        SkASSERT(!path.isEmpty());
+        SkASSERT(this->canDrawPath(path, stroke, target, antiAlias));
+        SkASSERT(target->drawState()->getStencil().isDisabled() ||
                  kNoRestriction_StencilSupport == this->getStencilSupport(path, stroke, target));
         return this->onDrawPath(path, stroke, target, antiAlias);
     }
 
     /**
      * Draws the path to the stencil buffer. Assume the writable stencil bits are already
      * initialized to zero. The pixels inside the path will have non-zero stencil values afterwards.
      *
      * @param path                  the path to draw.
      * @param stroke                the stroke information (width, join, cap)
      * @param target                target that the path will be rendered to
      */
     void stencilPath(const SkPath& path, const SkStrokeRec& stroke, GrDrawTarget* target) {
-        GrAssert(!path.isEmpty());
-        GrAssert(kNoSupport_StencilSupport != this->getStencilSupport(path, stroke, target));
+        SkASSERT(!path.isEmpty());
+        SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(path, stroke, target));
         this->onStencilPath(path, stroke, target);
     }
 
 protected:
     /**
      * Subclass overrides if it has any limitations of stenciling support.
      */
     virtual StencilSupport onGetStencilSupport(const SkPath&,
                                                const SkStrokeRec&,
                                                const GrDrawTarget*) const {
@@ skipping 42 matching lines @@
                                  SkRect* bounds) {
         GetPathDevBounds(path, device->width(), device->height(), matrix, bounds);
     }
 
 private:
 
     typedef GrRefCnt INHERITED;
 };
 
 #endif