Don't batch large instanced rects with other shapes

src/gpu/instanced/InstancedRendering.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "InstancedRendering.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 166 matching lines @@
         viewMatrix.mapRect(&batch->fBounds, bounds);
 
         batch->fInfo.fNonSquare = true;
     }
 
     instance.fColor = color;
 
     const float* rectAsFloats = localRect.asScalars(); // Ensure SkScalar == float.
     memcpy(&instance.fLocalRect, rectAsFloats, 4 * sizeof(float));
 
+    batch->fPixelLoad = batch->fBounds.height() * batch->fBounds.width();
     return batch;
 }
 
 inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
                                                     const GrInstancedPipelineInfo& info,
                                                     bool* useHWAA, AntialiasMode* antialiasMode) {
     SkASSERT(!info.fColorDisabled || info.fDrawingShapeToStencil);
     SkASSERT(!info.fIsMixedSampled || info.fIsMultisampled);
 
     if (!info.fIsMultisampled || fGpu->caps()->multisampleDisableSupport()) {
@@ skipping 162 matching lines @@
     fInstancedRendering->fTrackedBatches.addToTail(this);
     fIsTracked = true;
 }
 
 bool InstancedRendering::Batch::onCombineIfPossible(GrBatch* other, const GrCaps& caps) {
     Batch* that = static_cast<Batch*>(other);
     SkASSERT(fInstancedRendering == that->fInstancedRendering);
     SkASSERT(fTailDraw);
     SkASSERT(that->fTailDraw);
 
-    if (!fInfo.canJoin(that->fInfo) ||
+    if (!BatchInfo::CanCombine(fInfo, that->fInfo) ||
         !GrPipeline::CanCombine(*this->pipeline(), this->bounds(),
                                 *that->pipeline(), that->bounds(), caps)) {
         return false;
     }
 
+    BatchInfo combinedInfo = fInfo | that->fInfo;
+    if (!combinedInfo.isSimpleRects()) {
+        // This threshold was chosen with the "shapes_mixed" bench on a MacBook with Intel graphics.
+        // There seems to be a wide range where it doesn't matter if we combine or not. What matters
+        // is that the itty bitty rects combine with other shapes and the giant ones don't.
+        constexpr SkScalar kMaxPixelsToGeneralizeRects = 256 * 256;
+        if (fInfo.isSimpleRects() && fPixelLoad > kMaxPixelsToGeneralizeRects) {
+            return false;
+        }
+        if (that->fInfo.isSimpleRects() && that->fPixelLoad > kMaxPixelsToGeneralizeRects) {
+            return false;
+        }
+    }
+
     fBounds.join(that->fBounds);
-    fInfo.join(that->fInfo);
+    fInfo = combinedInfo;
+    fPixelLoad += that->fPixelLoad;
 
     // Adopt the other batch's draws.
     fNumDraws += that->fNumDraws;
     fNumChangesInGeometry += that->fNumChangesInGeometry;
     if (fTailDraw->fGeometry != that->fHeadDraw->fGeometry) {
         ++fNumChangesInGeometry;
     }
     fTailDraw->fNext = that->fHeadDraw;
     fTailDraw = that->fTailDraw;
 
@@ skipping 78 matching lines @@
 }
 
 void InstancedRendering::resetGpuResources(ResetType resetType) {
     fVertexBuffer.reset();
     fIndexBuffer.reset();
     fParamsBuffer.reset();
     this->onResetGpuResources(resetType);
 }
 
 }