Replace all instances of GrRect with SkRect.

src/gpu/GrGpu.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 GrGpu_DEFINED
 #define GrGpu_DEFINED
 
 #include "GrDrawTarget.h"
-#include "GrRect.h"
 #include "GrRefCnt.h"
 #include "GrClipMaskManager.h"
-
 #include "SkPath.h"
 
 class GrContext;
 class GrIndexBufferAllocPool;
 class GrPath;
 class GrPathRenderer;
 class GrPathRendererChain;
 class GrResource;
 class GrStencilBuffer;
 class GrVertexBufferAllocPool;
 
 class GrGpu : public GrDrawTarget {
-
 public:
 
     /**
      * Additional blend coefficients for dual source blending, not exposed
      * through GrPaint/GrContext.
      */
     enum ExtendedBlendCoeffs {
         // source 2 refers to second output color when
         // using dual source blending.
         kS2C_GrBlendCoeff = kPublicGrBlendCoeffCount,
@@ skipping 221 matching lines @@
     void insertResource(GrResource* resource);
 
     /**
      * Remove resource from list of resources. Should only be called by
      * GrResource.
      * @param resource  the resource to remove.
      */
     void removeResource(GrResource* resource);
 
     // GrDrawTarget overrides
-    virtual void clear(const GrIRect* rect,
+    virtual void clear(const SkIRect* rect,
                        GrColor color,
                        GrRenderTarget* renderTarget = NULL) SK_OVERRIDE;
 
     virtual void purgeResources() SK_OVERRIDE {
         // The clip mask manager can rebuild all its clip masks so just
         // get rid of them all.
         fClipMaskManager.releaseResources();
     }
 
     // After the client interacts directly with the 3D context state the GrGpu
@@ skipping 20 matching lines @@
         GrAssert(kGrPixelConfigCnt > config);
         return fConfigRenderSupport[config];
     }
 
     /**
      * These methods are called by the clip manager's setupClipping function
      * which (called as part of GrGpu's implementation of onDraw and
      * onStencilPath member functions.) The GrGpu subclass should flush the
      * stencil state to the 3D API in its implementation of flushGraphicsState.
      */
-    void enableScissor(const GrIRect& rect) {
+    void enableScissor(const SkIRect& rect) {
         fScissorState.fEnabled = true;
         fScissorState.fRect = rect;
     }
     void disableScissor() { fScissorState.fEnabled = false; }
 
     /**
      * Like the scissor methods above this is called by setupClipping and
      * should be flushed by the GrGpu subclass in flushGraphicsState. These
      * stencil settings should be used in place of those on the GrDrawState.
      * They have been adjusted to account for any interactions between the
      * GrDrawState's stencil settings and stencil clipping.
      */
     void setStencilSettings(const GrStencilSettings& settings) {
         fStencilSettings = settings;
     }
     void disableStencil() { fStencilSettings.setDisabled(); }
 
     // GrGpu subclass sets clip bit in the stencil buffer. The subclass is
     // free to clear the remaining bits to zero if masked clears are more
     // expensive than clearing all bits.
-    virtual void clearStencilClip(const GrIRect& rect, bool insideClip) = 0;
+    virtual void clearStencilClip(const SkIRect& rect, bool insideClip) = 0;
 
     enum PrivateDrawStateStateBits {
         kFirstBit = (GrDrawState::kLastPublicStateBit << 1),
 
         kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify
                                                  // stencil bits used for
                                                  // clipping.
     };
 
 protected:
@@ skipping 46 matching lines @@
         const GrIndexBuffer*  fPoolIndexBuffer;
         int                   fPoolStartIndex;
     };
     const GeometryPoolState& getGeomPoolState() {
         return fGeomPoolStateStack.back();
     }
 
     // The state of the scissor is controlled by the clip manager
     struct ScissorState {
         bool    fEnabled;
-        GrIRect fRect;
+        SkIRect fRect;
     } fScissorState;
 
     // The final stencil settings to use as determined by the clip manager.
     GrStencilSettings fStencilSettings;
 
     // Derived classes need access to this so they can fill it out in their
     // constructors
     bool    fConfigRenderSupport[kGrPixelConfigCnt];
 
     // Helpers for setting up geometry state
@@ skipping 23 matching lines @@
                                        const void* srcData,
                                        size_t rowBytes) = 0;
     virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) = 0;
     virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) = 0;
     virtual GrVertexBuffer* onCreateVertexBuffer(uint32_t size, bool dynamic) = 0;
     virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size, bool dynamic) = 0;
     virtual GrPath* onCreatePath(const SkPath& path) = 0;
 
     // overridden by backend-specific derived class to perform the clear and
     // clearRect. NULL rect means clear whole target.
-    virtual void onClear(const GrIRect* rect, GrColor color) = 0;
+    virtual void onClear(const SkIRect* rect, GrColor color) = 0;
 
     // overridden by backend-specific derived class to perform the draw call.
     virtual void onGpuDraw(const DrawInfo&) = 0;
     // when GrDrawTarget::stencilPath is called the draw state's current stencil
     // settings are ignored. Instead the GrGpu decides the stencil rules
     // necessary to stencil the path. These are still subject to filtering by
     // the clip mask manager.
     virtual void setStencilPathSettings(const GrPath&,
                                         SkPath::FillType,
                                         GrStencilSettings* settings) = 0;
@@ skipping 79 matching lines @@
     // these are mutable so they can be created on-demand
     mutable GrIndexBuffer*                                              fQuadIndexBuffer;
     // Used to abandon/release all resources created by this GrGpu. TODO: Move this
     // functionality to GrResourceCache.
     ResourceList                                                        fResourceList;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif