Revert "fill rect batch refactor into separate batches"

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 "GrColor.h"
@@ skipping 169 matching lines @@
         }
     }
 }
 
 // Common functions
 class AAFillRectBatchBase {
 public:
     static const int kVertsPerInstance = kVertsPerAAFillRect;
     static const int kIndicesPerInstance = kIndicesPerAAFillRect;
 
-    static const GrIndexBuffer* GetIndexBuffer(GrResourceProvider* rp) {
+    inline static const GrIndexBuffer* GetIndexBuffer(GrResourceProvider* rp) {
         return get_index_buffer(rp);
     }
-
-    template <class Geometry>
-    static void SetBounds(const Geometry& geo, SkRect* outBounds) {
-        *outBounds = geo.fDevRect;
-    }
 };
 
 class AAFillRectBatchNoLocalMatrixImp : public AAFillRectBatchBase {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkRect fDevRect;
         GrColor fColor;
     };
 
-    static const char* Name() { return "AAFillRectBatchNoLocalMatrix"; }
+    inline static const char* Name() { return "AAFillRectBatchNoLocalMatrix"; }
 
-    static bool CanCombine(const Geometry& mine, const Geometry& theirs,
-                           const GrPipelineOptimizations& opts) {
+    inline static bool CanCombine(const Geometry& mine, const Geometry& theirs,
+                                  const GrPipelineOptimizations& opts) {
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
         return !opts.readsLocalCoords() || mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix);
     }
 
-    static const GrGeometryProcessor* CreateGP(const Geometry& geo,
-                                               const GrPipelineOptimizations& opts) {
+    inline static const GrGeometryProcessor* CreateGP(const Geometry& geo,
+                                                      const GrPipelineOptimizations& opts) {
         const GrGeometryProcessor* gp =
                 create_fill_rect_gp(geo.fViewMatrix, opts,
                                     GrDefaultGeoProcFactory::LocalCoords::kUsePosition_Type);
 
         SkASSERT(opts.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         return gp;
     }
 
-    static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
-                          const GrPipelineOptimizations& opts) {
+    inline static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
+                                 const GrPipelineOptimizations& opts) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
                                        geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, opts,
                                        NULL);
     }
 };
 
 class AAFillRectBatchLocalMatrixImp : public AAFillRectBatchBase {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fLocalMatrix;
         SkRect fRect;
         SkRect fDevRect;
         GrColor fColor;
     };
 
-    static const char* Name() { return "AAFillRectBatchLocalMatrix"; }
+    inline static const char* Name() { return "AAFillRectBatchLocalMatrix"; }
 
-    static bool CanCombine(const Geometry& mine, const Geometry& theirs,
-                           const GrPipelineOptimizations&) {
+    inline static bool CanCombine(const Geometry& mine, const Geometry& theirs,
+                                  const GrPipelineOptimizations&) {
         return true;
     }
 
-    static const GrGeometryProcessor* CreateGP(const Geometry& geo,
-                                               const GrPipelineOptimizations& opts) {
+    inline static const GrGeometryProcessor* CreateGP(const Geometry& geo,
+                                                      const GrPipelineOptimizations& opts) {
         const GrGeometryProcessor* gp =
                 create_fill_rect_gp(geo.fViewMatrix, opts,
                                     GrDefaultGeoProcFactory::LocalCoords::kHasExplicit_Type);
 
         SkASSERT(opts.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage));
         return gp;
     }
 
-    static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
-                          const GrPipelineOptimizations& opts) {
+    inline static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
+                                 const GrPipelineOptimizations& opts) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
                                        geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, opts,
                                        &geo.fLocalMatrix);
     }
 };
 
 typedef GrTInstanceBatch<AAFillRectBatchNoLocalMatrixImp> AAFillRectBatchNoLocalMatrix;
 typedef GrTInstanceBatch<AAFillRectBatchLocalMatrixImp> AAFillRectBatchLocalMatrix;
 
 namespace GrAAFillRectBatch {
@@ skipping 47 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAFillRectBatchLocalMatrix) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkMatrix localMatrix = GrTest::TestMatrix(random);
     SkRect rect = GrTest::TestRect(random);
     SkRect devRect = GrTest::TestRect(random);
     return GrAAFillRectBatch::Create(color, viewMatrix, localMatrix, rect, devRect);
 }
 
 #endif