Re-add isIRect test for AA rect drawing

src/gpu/GrContext.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 "GrContext.h"
@@ skipping 662 matching lines @@
     verts[2].set(rect.fRight - rad, rect.fTop + rad);
     verts[3].set(rect.fRight + rad, rect.fTop - rad);
     verts[4].set(rect.fRight - rad, rect.fBottom - rad);
     verts[5].set(rect.fRight + rad, rect.fBottom + rad);
     verts[6].set(rect.fLeft + rad, rect.fBottom - rad);
     verts[7].set(rect.fLeft - rad, rect.fBottom + rad);
     verts[8] = verts[0];
     verts[9] = verts[1];
 }
 
+static bool isIRect(const GrRect& r) {
+    return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&    
+           SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);   
+}
+
 static bool apply_aa_to_rect(GrDrawTarget* target,
                              const GrRect& rect,
                              SkScalar strokeWidth,
                              const SkMatrix* matrix,
                              SkMatrix* combinedMatrix,
+                             GrRect* devRect,
                              bool* useVertexCoverage) {
     // we use a simple coverage ramp to do aa on axis-aligned rects
     // we check if the rect will be axis-aligned, and the rect won't land on
     // integer coords.
 
     // we are keeping around the "tweak the alpha" trick because
     // it is our only hope for the fixed-pipe implementation.
     // In a shader implementation we can give a separate coverage input
     // TODO: remove this ugliness when we drop the fixed-pipe impl
     *useVertexCoverage = false;
@@ skipping 49 matching lines @@
 #endif
             GrAssert(combinedMatrix->preservesAxisAlignment());
 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
         } else {
             GrAssert(combinedMatrix->preservesRightAngles());
         }
 #endif
 #endif
     }
 
-    if (0 == rect.width() || 0 == rect.height()) {
-        return false;
+    combinedMatrix->mapRect(devRect, rect);
+
+    if (strokeWidth < 0) {
+        return !isIRect(*devRect);
+    } else {
+        return true;
     }
-
-    return true;
 }
 
 void GrContext::drawRect(const GrPaint& paint,
                          const GrRect& rect,
                          SkScalar width,
                          const SkMatrix* matrix) {
     SK_TRACE_EVENT0("GrContext::drawRect");
 
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW);
     GrDrawState::AutoStageDisable atr(fDrawState);
 
+    GrRect devRect;
     SkMatrix combinedMatrix;
     bool useVertexCoverage;
     bool needAA = paint.isAntiAlias() &&
                   !this->getRenderTarget()->isMultisampled();
     bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix,
-                                           &combinedMatrix,
+                                           &combinedMatrix, &devRect,
                                            &useVertexCoverage);
     if (doAA) {
         GrDrawState::AutoDeviceCoordDraw adcd(target->drawState());
         if (!adcd.succeeded()) {
             return;
         }
         if (width >= 0) {
             GrVec strokeSize;
             if (width > 0) {
                 strokeSize.set(width, width);
                 combinedMatrix.mapVectors(&strokeSize, 1);
                 strokeSize.setAbs(strokeSize);
             } else {
                 strokeSize.set(SK_Scalar1, SK_Scalar1);
             }
             fAARectRenderer->strokeAARect(this->getGpu(), target,
-                                          rect, combinedMatrix,
+                                          rect, combinedMatrix, devRect,
                                           strokeSize, useVertexCoverage);
         } else {
             // filled AA rect
             fAARectRenderer->fillAARect(this->getGpu(), target,
-                                        rect, combinedMatrix,
+                                        rect, combinedMatrix, devRect,
                                         useVertexCoverage);
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
@@ skipping 980 matching lines @@
         return srcTexture;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
 }
 #endif