Avoid creating full screen clear batches when there is already one in the queue.

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 13 matching lines @@
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
 //#define ENABLE_MDB 1
 
 class GrAuditTrail;
 class GrBatch;
+class GrClearBatch;
 class GrClip;
 class GrCaps;
 class GrPath;
 class GrDrawPathBatchBase;
 class GrPipelineBuilder;
 
 class GrDrawTarget final : public SkRefCnt {
 public:
     /** Options for GrDrawTarget behavior. */
     struct Options {
         Options ()
             : fClipBatchToBounds(false)
             , fDrawBatchBounds(false)
             , fMaxBatchLookback(-1)
             , fMaxBatchLookahead(-1) {}
         bool fClipBatchToBounds;
         bool fDrawBatchBounds;
         int  fMaxBatchLookback;
         int  fMaxBatchLookahead;
     };
 
     GrDrawTarget(GrRenderTarget*, GrGpu*, GrResourceProvider*, GrAuditTrail*, const Options&);
 
     ~GrDrawTarget() override;
 
     void makeClosed() {
+        fLastFullClearBatch = nullptr;
         // We only close drawTargets When MDB is enabled. When MDB is disabled there is only
         // ever one drawTarget and all calls will be funnelled into it.
 #ifdef ENABLE_MDB
         this->setFlag(kClosed_Flag);
 #endif
         this->forwardCombine();
     }
 
     bool isClosed() const { return this->isSetFlag(kClosed_Flag); }
 
@@ skipping 117 matching lines @@
             return dt->isSetFlag(GrDrawTarget::kTempMark_Flag);
         }
         static int NumDependencies(const GrDrawTarget* dt) {
             return dt->fDependencies.count();
         }
         static GrDrawTarget* Dependency(GrDrawTarget* dt, int index) {
             return dt->fDependencies[index];
         }
     };
 
-    void recordBatch(GrBatch*, const SkRect& clippedBounds);
+    // Returns the batch that the input batch was combined with or the input batch if it wasn't
+    // combined.
+    GrBatch* recordBatch(GrBatch*, const SkRect& clippedBounds);
     void forwardCombine();
 
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  GrRenderTarget*,
                                  const GrClip&,
                                  const GrPipelineOptimizations& optimizations,
                                  GrXferProcessor::DstTexture*,
                                  const SkRect& batchBounds);
 
     void addDependency(GrDrawTarget* dependedOn);
 
     // Used only by drawContextPriv.
     void clearStencilClip(const SkIRect&, bool insideClip, GrRenderTarget*);
 
     struct RecordedBatch {
         sk_sp<GrBatch> fBatch;
         SkRect         fClippedBounds;
     };
     SkSTArray<256, RecordedBatch, true>             fRecordedBatches;
+    GrClearBatch*                                   fLastFullClearBatch;
     // The context is only in service of the GrClip, remove once it doesn't need this.
     GrContext*                                      fContext;
     GrGpu*                                          fGpu;
     GrResourceProvider*                             fResourceProvider;
     GrAuditTrail*                                   fAuditTrail;
 
     SkDEBUGCODE(int                                 fDebugID;)
     uint32_t                                        fFlags;
 
     // 'this' drawTarget relies on the output of the drawTargets in 'fDependencies'
     SkTDArray<GrDrawTarget*>                        fDependencies;
     GrRenderTarget*                                 fRenderTarget;
 
     bool                                            fClipBatchToBounds;
     bool                                            fDrawBatchBounds;
     int                                             fMaxBatchLookback;
     int                                             fMaxBatchLookahead;
 
     SkAutoTDelete<gr_instanced::InstancedRendering> fInstancedRendering;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif