broken bots war

src/gpu/batches/GrAAFillRectBatch.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 "GrAAFillRectBatch.h"
 
 #include "GrBatch.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrResourceKey.h"
 #include "GrResourceProvider.h"
 #include "GrTypes.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
+static const int kNumAAFillRectsInIndexBuffer = 256;
+static const int kVertsPerAAFillRect = 8;
+static const int kIndicesPerAAFillRect = 30;
+
+const GrIndexBuffer* get_index_buffer(GrResourceProvider* resourceProvider) {
+    GR_DEFINE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
+
+    static const uint16_t gFillAARectIdx[] = {
+        0, 1, 5, 5, 4, 0,
+        1, 2, 6, 6, 5, 1,
+        2, 3, 7, 7, 6, 2,
+        3, 0, 4, 4, 7, 3,
+        4, 5, 6, 6, 7, 4,
+    };
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFillAARectIdx) == kIndicesPerAAFillRect);
+    return resourceProvider->findOrCreateInstancedIndexBuffer(gFillAARectIdx,
+        kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
+        gAAFillRectIndexBufferKey);
+}
+
 /*
  * AAFillRectBatch is templated to optionally allow the insertion of an additional
  * attribute for explicit local coordinates.
  * To use this template, an implementation must define the following static functions:
  *     A Geometry struct
  *
  *     bool CanCombineLocalCoords(const SkMatrix& mine, const SkMatrix& theirs,
  *                                bool usesLocalCoords)
  *
  *     GrDefaultGeoProcFactory::LocalCoords::Type LocalCoordsType()
@@ skipping 52 matching lines @@
             return;
         }
 
         batchTarget->initDraw(gp, this->pipeline());
 
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(Base::StrideCheck(vertexStride, canTweakAlphaForCoverage,
                                    this->usesLocalCoords()));
         int instanceCount = fGeoData.count();
 
-        SkAutoTUnref<const GrIndexBuffer> indexBuffer(this->getIndexBuffer(
+        SkAutoTUnref<const GrIndexBuffer> indexBuffer(get_index_buffer(
             batchTarget->resourceProvider()));
         InstancedHelper helper;
         void* vertices = helper.init(batchTarget, kTriangles_GrPrimitiveType, vertexStride,
                                      indexBuffer, kVertsPerAAFillRect, kIndicesPerAAFillRect,
                                      instanceCount);
         if (!vertices || !indexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
@@ skipping 20 matching lines @@
 
 
 private:
     AAFillRectBatch() {
         this->initClassID<AAFillRectBatch<Base>>();
 
         // Push back an initial geometry
         fGeoData.push_back();
     }
 
-    static const int kNumAAFillRectsInIndexBuffer = 256;
-    static const int kVertsPerAAFillRect = 8;
-    static const int kIndicesPerAAFillRect = 30;
-
-    const GrIndexBuffer* getIndexBuffer(GrResourceProvider* resourceProvider) {
-        GR_DEFINE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
-
-        static const uint16_t gFillAARectIdx[] = {
-            0, 1, 5, 5, 4, 0,
-            1, 2, 6, 6, 5, 1,
-            2, 3, 7, 7, 6, 2,
-            3, 0, 4, 4, 7, 3,
-            4, 5, 6, 6, 7, 4,
-        };
-        GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFillAARectIdx) == kIndicesPerAAFillRect);
-        return resourceProvider->findOrCreateInstancedIndexBuffer(gFillAARectIdx,
-            kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
-            gAAFillRectIndexBufferKey);
-    }
-
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
                                 caps)) {
@@ skipping 127 matching lines @@
         /*if (coverageIgnored) {
             coverageType = Coverage::kNone_Type;
         } else*/ if (tweakAlphaForCoverage) {
             coverageType = Coverage::kSolid_Type;
         } else {
             coverageType = Coverage::kAttribute_Type;
         }
         Coverage coverage(coverageType);
 
         // We assume the caller has inverted the viewmatrix
-        LocalCoords localCoords(usesLocalCoords ? localCoordsType : LocalCoords::kUnused_Type);
         if (LocalCoords::kHasExplicit_Type == localCoordsType) {
+            LocalCoords localCoords(localCoordsType);
             return GrDefaultGeoProcFactory::Create(color, coverage, localCoords, SkMatrix::I());
         } else {
+            LocalCoords localCoords(usesLocalCoords ? localCoordsType : LocalCoords::kUnused_Type);
             return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
         }
     }
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fCanTweakAlphaForCoverage;
@@ skipping 49 matching lines @@
         return true;
     }
 
     inline static GrDefaultGeoProcFactory::LocalCoords::Type LocalCoordsType() {
         return GrDefaultGeoProcFactory::LocalCoords::kHasExplicit_Type;
     }
 
     inline static bool StrideCheck(size_t vertexStride, bool canTweakAlphaForCoverage,
                                    bool usesLocalCoords) {
         // Whomever created us should not have done so if there are no local coords
-        SkASSERT(usesLocalCoords);
         return canTweakAlphaForCoverage ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage);
     }
 
     inline static void FillInAttributes(intptr_t vertices, size_t vertexStride,
                                         SkPoint* fan0Pos, const Geometry& args) {
         SkMatrix invViewMatrix;
         if (!args.fViewMatrix.invert(&invViewMatrix)) {
             SkASSERT(false);
@@ skipping 66 matching lines @@
     geo.fColor = GrRandomColor(random);
     geo.fViewMatrix = GrTest::TestMatrix(random);
     geo.fLocalMatrix = GrTest::TestMatrix(random);
     geo.fRect = GrTest::TestRect(random);
     geo.fDevRect = GrTest::TestRect(random);
     batch->init();
     return batch;
 }
 
 #endif