Replace all instances of GrRect with SkRect.

include/gpu/GrContext.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 GrContext_DEFINED
 #define GrContext_DEFINED
 
 #include "GrColor.h"
 #include "GrAARectRenderer.h"
 #include "GrClipData.h"
 #include "SkMatrix.h"
 #include "GrPaint.h"
 #include "GrPathRendererChain.h"
+#include "GrPoint.h"
 #include "GrRenderTarget.h"
 #include "GrRefCnt.h"
 #include "GrTexture.h"
 
 class GrAutoScratchTexture;
 class GrDrawState;
 class GrDrawTarget;
 class GrEffect;
 class GrFontCache;
 class GrGpu;
@@ skipping 334 matching lines @@
     ///////////////////////////////////////////////////////////////////////////
     // Draws
 
     /**
      * Clear the entire or rect of the render target, ignoring any clips.
      * @param rect  the rect to clear or the whole thing if rect is NULL.
      * @param color the color to clear to.
      * @param target if non-NULL, the render target to clear otherwise clear
      *               the current render target
      */
-    void clear(const GrIRect* rect, GrColor color,
+    void clear(const SkIRect* rect, GrColor color,
                GrRenderTarget* target = NULL);
 
     /**
      *  Draw everywhere (respecting the clip) with the paint.
      */
     void drawPaint(const GrPaint& paint);
 
     /**
      *  Draw the rect using a paint.
      *  @param paint        describes how to color pixels.
      *  @param strokeWidth  If strokeWidth < 0, then the rect is filled, else
      *                      the rect is mitered stroked based on strokeWidth. If
      *                      strokeWidth == 0, then the stroke is always a single
      *                      pixel thick.
      *  @param matrix       Optional matrix applied to the rect. Applied before
      *                      context's matrix or the paint's matrix.
      *  The rects coords are used to access the paint (through texture matrix)
      */
     void drawRect(const GrPaint& paint,
-                  const GrRect&,
+                  const SkRect&,
                   SkScalar strokeWidth = -1,
                   const SkMatrix* matrix = NULL);
 
     /**
      * Maps a rect of local coordinates onto the a rect of destination
      * coordinates. Each rect can optionally be transformed. The localRect
      * is stretched over the dstRect. The dstRect is transformed by the
      * context's matrix. Additional optional matrices for both rects can be
      * provided by parameters.
      *
      * @param paint         describes how to color pixels.
      * @param dstRect       the destination rect to draw.
      * @param localRect     rect of local coordinates to be mapped onto dstRect
      * @param dstMatrix     Optional matrix to transform dstRect. Applied before context's matrix.
      * @param localMatrix   Optional matrix to transform localRect.
      */
     void drawRectToRect(const GrPaint& paint,
-                        const GrRect& dstRect,
-                        const GrRect& localRect,
+                        const SkRect& dstRect,
+                        const SkRect& localRect,
                         const SkMatrix* dstMatrix = NULL,
                         const SkMatrix* localMatrix = NULL);
 
     /**
      *  Draw a roundrect using a paint.
      *
      *  @param paint        describes how to color pixels.
      *  @param rrect        the roundrect to draw
      *  @param stroke       the stroke information (width, join, cap)
      */
@@ skipping 36 matching lines @@
                       int indexCount);
 
     /**
      * Draws an oval.
      *
      * @param paint         describes how to color pixels.
      * @param oval          the bounding rect of the oval.
      * @param stroke        the stroke information (width, style)
      */
     void drawOval(const GrPaint& paint,
-                  const GrRect& oval,
+                  const SkRect& oval,
                   const SkStrokeRec& stroke);
 
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
      * Flags that affect flush() behavior.
      */
     enum FlushBits {
         /**
@@ skipping 284 matching lines @@
 
         AutoClip(GrContext* context, InitialClip initialState)
         : fContext(context) {
             GrAssert(kWideOpen_InitialClip == initialState);
             fNewClipData.fClipStack = &fNewClipStack;
 
             fOldClip = context->getClip();
             context->setClip(&fNewClipData);
         }
 
-        AutoClip(GrContext* context, const GrRect& newClipRect)
+        AutoClip(GrContext* context, const SkRect& newClipRect)
         : fContext(context)
         , fNewClipStack(newClipRect) {
             fNewClipData.fClipStack = &fNewClipStack;
 
             fOldClip = fContext->getClip();
             fContext->setClip(&fNewClipData);
         }
 
         ~AutoClip() {
             if (NULL != fContext) {
@@ skipping 217 matching lines @@
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif