Create separate entry points for the various flavors of drawRect

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 181 matching lines @@
         AutoCheckFlush acf(fContext);
         if (!this->prepareToDraw(rt)) {
             return;
         }
 
         GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
         fDrawTarget->drawBWRect(pipelineBuilder,
                                 paint->getColor(),
                                 SkMatrix::I(),
                                 r,
-                                NULL,
-                                &localMatrix);
+                                localMatrix);
     }
 }
 
 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,
@@ skipping 84 matching lines @@
                                         color, viewMatrix, rect, width, snapToPixelCenters));
 
         // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
         // hairline rects. We jam all the vertices to pixel centers to avoid this, but not when MSAA
         // is enabled because it can cause ugly artifacts.
         pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                  snapToPixelCenters);
         fDrawTarget->drawBatch(pipelineBuilder, batch);
     } else {
         // filled BW rect
-        fDrawTarget->drawSimpleRect(pipelineBuilder, color, viewMatrix, rect);
+        fDrawTarget->drawBWRect(pipelineBuilder, color, viewMatrix, rect);
     }
 }
 
 void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt,
                                         const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkRect& rectToDraw,
-                                        const SkRect& localRect,
-                                        const SkMatrix* localMatrix) {
+                                        const SkRect& localRect) {
     RETURN_IF_ABANDONED
     AutoCheckFlush acf(fContext);
     if (!this->prepareToDraw(rt)) {
+        return;
+    }
+
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    fDrawTarget->drawBWRect(pipelineBuilder,
+                            paint.getColor(),
+                            viewMatrix,
+                            rectToDraw,
+                            localRect);
+}
+
+void GrDrawContext::drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
+                                                 const GrClip& clip,
+                                                 const GrPaint& paint,
+                                                 const SkMatrix& viewMatrix,
+                                                 const SkRect& rectToDraw,
+                                                 const SkMatrix& localMatrix) {
+    RETURN_IF_ABANDONED
+    AutoCheckFlush acf(fContext);
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     fDrawTarget->drawBWRect(pipelineBuilder,
                             paint.getColor(),
                             viewMatrix,
                             rectToDraw,
-                            &localRect,
                             localMatrix);
 }
 
 void GrDrawContext::drawVertices(GrRenderTarget* rt,
                                  const GrClip& clip,
                                  const GrPaint& paint,
                                  const SkMatrix& viewMatrix,
                                  GrPrimitiveType primitiveType,
                                  int vertexCount,
                                  const SkPoint positions[],
@@ skipping 402 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);
 }