Disable GPU acceleration for narrow ovals

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrEffect.h"
@@ skipping 279 matching lines @@
 
     const SkMatrix& vm = context->getMatrix();
 
     // we can draw circles
     if (SkScalarNearlyEqual(oval.width(), oval.height())
         && circle_stays_circle(vm)) {
         drawCircle(target, paint, oval, stroke);
 
     // and axis-aligned ellipses only
     } else if (vm.rectStaysRect()) {
-        drawEllipse(target, paint, oval, stroke);
+        return drawEllipse(target, paint, oval, stroke);
 
     } else {
         return false;
     }
 
     return true;
 }
 
 void GrOvalRenderer::drawCircle(GrDrawTarget* target,
                                 const GrPaint& paint,
@@ skipping 88 matching lines @@
     verts[2].fInnerRadius = innerRadius;
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
     verts[3].fOffset = SkPoint::Make(outerRadius, outerRadius);
     verts[3].fOuterRadius = outerRadius;
     verts[3].fInnerRadius = innerRadius;
 
     target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4, &bounds);
 }
 
-void GrOvalRenderer::drawEllipse(GrDrawTarget* target,
+bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
                                  const GrPaint& paint,
                                  const GrRect& ellipse,
                                  const SkStrokeRec& stroke)
 {
     GrDrawState* drawState = target->drawState();
 #ifdef SK_DEBUG
     {
         // we should have checked for this previously
         bool isAxisAlignedEllipse = drawState->getViewMatrix().rectStaysRect();
         SkASSERT(paint.isAntiAlias() && isAxisAlignedEllipse);
     }
 #endif
 
     const SkMatrix& vm = drawState->getViewMatrix();
     GrPoint center = GrPoint::Make(ellipse.centerX(), ellipse.centerY());
     vm.mapPoints(&center, 1);
     SkRect xformedRect;
     vm.mapRect(&xformedRect, ellipse);
+    SkScalar xRadius = SkScalarHalf(xformedRect.width());
+    SkScalar yRadius = SkScalarHalf(xformedRect.height());
+    if (SkScalarDiv(xRadius, yRadius) > 2 || SkScalarDiv(yRadius, xRadius) > 2) {
+        return false;
+    }
 
     GrDrawState::AutoDeviceCoordDraw adcd(drawState);
     if (!adcd.succeeded()) {
-        return;
+        return false;
     }
 
     // position + edge
     static const GrVertexAttrib kVertexAttribs[] = {
         {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding},
         {kVec2f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding},
         {kVec4f_GrVertexAttribType, 2*sizeof(GrPoint), kEffect_GrVertexAttribBinding}
     };
     drawState->setVertexAttribs(kVertexAttribs, SK_ARRAY_COUNT(kVertexAttribs));
     GrAssert(sizeof(EllipseVertex) == drawState->getVertexSize());
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
-        return;
+        return false;
     }
 
     EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices());
 
     SkStrokeRec::Style style = stroke.getStyle();
     bool isStroked = (SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style);
     enum {
         // the edge effects share this stage with glyph rendering
         // (kGlyphMaskStage in GrTextContext) && SW path rendering
         // (kPathMaskStage in GrSWMaskHelper)
         kEdgeEffectStage = GrPaint::kTotalStages,
     };
 
     GrEffectRef* effect = EllipseEdgeEffect::Create(isStroked);
     static const int kEllipseCenterAttrIndex = 1;
     static const int kEllipseEdgeAttrIndex = 2;
     drawState->setEffect(kEdgeEffectStage, effect,
                          kEllipseCenterAttrIndex, kEllipseEdgeAttrIndex)->unref();
 
-    SkScalar xRadius = SkScalarHalf(xformedRect.width());
-    SkScalar yRadius = SkScalarHalf(xformedRect.height());
     SkScalar innerXRadius = 0.0f;
     SkScalar innerRatio = 1.0f;
 
     if (SkStrokeRec::kFill_Style != style) {
         SkScalar strokeWidth = stroke.getWidth();
 
         // do (potentially) anisotropic mapping
         SkVector scaledStroke;
         scaledStroke.set(strokeWidth, strokeWidth);
         vm.mapVectors(&scaledStroke, 1);
@@ skipping 53 matching lines @@
     verts[2].fOuterOffset = SkPoint::Make(-xRadius, outerRatio*yRadius);
     verts[2].fInnerOffset = SkPoint::Make(-xRadius, innerRatio*yRadius);
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
     verts[3].fOuterXRadius = xRadius;
     verts[3].fInnerXRadius = innerXRadius;
     verts[3].fOuterOffset = SkPoint::Make(xRadius, outerRatio*yRadius);
     verts[3].fInnerOffset = SkPoint::Make(xRadius, innerRatio*yRadius);
 
     target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4, &bounds);
+
+    return true;
 }