Replace all instances of GrRect with SkRect.

include/gpu/GrRenderTarget.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 GrRenderTarget_DEFINED
 #define GrRenderTarget_DEFINED
 
-#include "GrRect.h"
 #include "GrSurface.h"
+#include "SkRect.h"
 
 class GrStencilBuffer;
 class GrTexture;
 
 /**
  * GrRenderTarget represents a 2D buffer of pixels that can be rendered to.
  * A context's render target is set by setRenderTarget(). Render targets are
  * created by a createTexture with the kRenderTarget_TextureFlag flag.
  * Additionally, GrContext provides methods for creating GrRenderTargets
  * that wrap externally created render targets.
@@ skipping 60 matching lines @@
     /**
      * Call to indicate the multisample contents were modified such that the
      * render target needs to be resolved before it can be used as texture. Gr
      * tracks this for its own drawing and thus this only needs to be called
      * when the render target has been modified outside of Gr. This has no
      * effect on wrapped backend render targets.
      *
      * @param rect  a rect bounding the area needing resolve. NULL indicates
      *              the whole RT needs resolving.
      */
-    void flagAsNeedingResolve(const GrIRect* rect = NULL);
+    void flagAsNeedingResolve(const SkIRect* rect = NULL);
 
     /**
      * Call to override the region that needs to be resolved.
      */
-    void overrideResolveRect(const GrIRect rect);
+    void overrideResolveRect(const SkIRect rect);
 
     /**
      * Call to indicate that GrRenderTarget was externally resolved. This may
      * allow Gr to skip a redundant resolve step.
      */
     void flagAsResolved() { fResolveRect.setLargestInverted(); }
 
     /**
      * @return true if the GrRenderTarget requires MSAA resolving
      */
     bool needsResolve() const { return !fResolveRect.isEmpty(); }
 
     /**
      * Returns a rect bounding the region needing resolving.
      */
-    const GrIRect& getResolveRect() const { return fResolveRect; }
+    const SkIRect& getResolveRect() const { return fResolveRect; }
 
     /**
      * If the render target is multisampled this will perform a multisample
      * resolve. Any pending draws to the target are first flushed. This only
      * applies to render targets that are associated with GrTextures. After the
      * function returns the GrTexture will contain the resolved pixels.
      */
     void resolve();
 
     // a MSAA RT may require explicit resolving , it may auto-resolve (e.g. FBO
@@ skipping 31 matching lines @@
     friend class GrTexture;
     // called by ~GrTexture to remove the non-ref'ed back ptr.
     void owningTextureDestroyed() {
         GrAssert(NULL != fTexture);
         fTexture = NULL;
     }
 
     GrStencilBuffer*  fStencilBuffer;
     GrTexture*        fTexture; // not ref'ed
 
-    GrIRect           fResolveRect;
+    SkIRect           fResolveRect;
 
     typedef GrSurface INHERITED;
 };
 
 #endif