Rename non-aa rect methods on GrDrawContext in anticipation of making them support aa

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 1366 matching lines @@
 
     if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
         return;
     }
 
     if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
         // We don't have local coords in this case and have previously set the transform
         // matrices directly on the texture processor.
         fDrawContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
     } else {
-        fDrawContext->drawNonAARectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
+        fDrawContext->fillRectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
     }
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 int width, int height,
                                 const SkImageFilter* filter,
                                 const SkImageFilter::Context& ctx,
                                 SkBitmap* result, SkIPoint* offset) {
     SkASSERT(filter);
 
@@ skipping 61 matching lines @@
         GrSimpleTextureEffect::Create(texture, SkMatrix::I()));
     if (alphaOnly) {
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
     } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
     if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
         return;
     }
 
-    fDrawContext->drawNonAARectToRect(fClip,
-                                      grPaint,
-                                      SkMatrix::I(),
-                                      SkRect::MakeXYWH(SkIntToScalar(left),
-                                                       SkIntToScalar(top),
-                                                       SkIntToScalar(w),
-                                                       SkIntToScalar(h)),
-                                      SkRect::MakeXYWH(0,
-                                                       0,
-                                                       SK_Scalar1 * w / texture->width(),
-                                                       SK_Scalar1 * h / texture->height()));
+    fDrawContext->fillRectToRect(fClip,
+                                 grPaint,
+                                 SkMatrix::I(),
+                                 SkRect::MakeXYWH(SkIntToScalar(left),
+                                                  SkIntToScalar(top),
+                                                  SkIntToScalar(w),
+                                                  SkIntToScalar(h)),
+                                 SkRect::MakeXYWH(0,
+                                                  0,
+                                                  SK_Scalar1 * w / texture->width(),
+                                                  SK_Scalar1 * h / texture->height()));
 }
 
 void SkGpuDevice::drawBitmapRect(const SkDraw& origDraw, const SkBitmap& bitmap,
                                  const SkRect* src, const SkRect& dst,
                                  const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
     SkMatrix    matrix;
     SkRect      bitmapBounds, tmpSrc;
 
     bitmapBounds.set(0, 0,
                      SkIntToScalar(bitmap.width()),
@@ skipping 99 matching lines @@
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
                                       SkIntToScalar(h));
 
     // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
     // scratch texture).
     SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
                                     SK_Scalar1 * h / devTex->height());
 
-    fDrawContext->drawNonAARectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
+    fDrawContext->fillRectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
 }
 
 bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
     return filter->canFilterImageGPU();
 }
 
 bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                               const SkImageFilter::Context& ctx,
                               SkBitmap* result, SkIPoint* offset) {
     // want explicitly our impl, so guard against a subclass of us overriding it
@@ skipping 415 matching lines @@
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkGpuDevice::NewImageFilterCache();
 }
 
 #endif