Revert of stop dropping AA when rect stays rect

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextContext.h"
 #include "GrBatchTest.h"
@@ skipping 186 matching lines @@
         GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
         fDrawTarget->drawBWRect(pipelineBuilder,
                                 paint->getColor(),
                                 SkMatrix::I(),
                                 r,
                                 NULL,
                                 &localMatrix);
     }
 }
 
+static inline bool is_irect(const SkRect& r) {
+  return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&
+         SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
+}
+
+static bool apply_aa_to_rect(GrDrawTarget* target,
+                             GrPipelineBuilder* pipelineBuilder,
+                             SkRect* devBoundRect,
+                             const SkRect& rect,
+                             SkScalar strokeWidth,
+                             const SkMatrix& combinedMatrix,
+                             GrColor color) {
+    if (pipelineBuilder->getRenderTarget()->isUnifiedMultisampled() ||
+        !combinedMatrix.preservesAxisAlignment()) {
+        return false;
+    }
+
+    combinedMatrix.mapRect(devBoundRect, rect);
+    if (!combinedMatrix.rectStaysRect()) {
+        return true;
+    }
+
+    if (strokeWidth < 0) {
+        return !is_irect(*devBoundRect);
+    }
+
+    return true;
+}
+
 static inline bool rect_contains_inclusive(const SkRect& rect, const SkPoint& point) {
     return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
            point.fY >= rect.fTop && point.fY <= rect.fBottom;
 }
 
 void GrDrawContext::drawRect(GrRenderTarget* rt,
                              const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
@@ skipping 44 matching lines @@
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
                     fDrawTarget->clear(NULL, clearColor, true, rt);
                     return;
                 }
             }
         }
     }
 
     GrColor color = paint.getColor();
+    SkRect devBoundRect;
     bool needAA = paint.isAntiAlias() &&
                   !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
+    bool doAA = needAA && apply_aa_to_rect(fDrawTarget, &pipelineBuilder, &devBoundRect, rect,
+                                           width, viewMatrix, color);
 
-    // The fill path can handle rotation but not skew
-    // The stroke path needs the rect to remain axis aligned (no rotation or skew)
-    // None of our draw rect calls can handle perspective yet
-    SkASSERT(!viewMatrix.hasPerspective());
-    bool canApplyAA = width >=0 ? viewMatrix.rectStaysRect() : viewMatrix.preservesRightAngles();
-
-    if (needAA && canApplyAA) {
-        SkRect devBoundRect;
-        viewMatrix.mapRect(&devBoundRect, rect);
+    if (doAA) {
         SkAutoTUnref<GrDrawBatch> batch;
         if (width >= 0) {
             batch.reset(GrRectBatchFactory::CreateStrokeAA(color, viewMatrix, rect, devBoundRect,
                                                            *strokeInfo));
         } else {
             batch.reset(GrRectBatchFactory::CreateFillAA(color, viewMatrix, rect, devBoundRect));
         }
         fDrawTarget->drawBatch(pipelineBuilder, batch);
         return;
     }
@@ skipping 450 matching lines @@
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     fDrawTarget->drawBatch(*pipelineBuilder, batch);
 }