Replace op== with CombineIfPossible in GrDrawState.

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 332 matching lines @@
 
     if (drawState.isClipState() &&
         NULL != info.getDevBounds() &&
         this->quickInsideClip(*info.getDevBounds())) {
         acr.set(this->drawState());
     }
 
     if (this->needsNewClip()) {
        this->recordClip();
     }
-    if (this->needsNewState()) {
-        this->recordState();
-    }
+    this->recordStateIfNecessary();
 
     DrawRecord* draw;
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(info);
         if (info.instanceCount() > instancesConcated) {
             draw = this->recordDraw(info);
             draw->adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
@@ skipping 51 matching lines @@
     if (fIndices) {
         SkDELETE_ARRAY(fIndices);
     }
 }
 
 void GrInOrderDrawBuffer::onStencilPath(const GrPath* path, SkPath::FillType fill) {
     if (this->needsNewClip()) {
         this->recordClip();
     }
     // Only compare the subset of GrDrawState relevant to path stenciling?
-    if (this->needsNewState()) {
-        this->recordState();
-    }
+    this->recordStateIfNecessary();
     StencilPath* sp = this->recordStencilPath();
     sp->fPath.reset(path);
     path->ref();
     sp->fFill = fill;
 }
 
 void GrInOrderDrawBuffer::onDrawPath(const GrPath* path,
                                      SkPath::FillType fill, const GrDeviceCoordTexture* dstCopy) {
     if (this->needsNewClip()) {
         this->recordClip();
     }
     // TODO: Only compare the subset of GrDrawState relevant to path covering?
-    if (this->needsNewState()) {
-        this->recordState();
-    }
+    this->recordStateIfNecessary();
     DrawPath* cp = this->recordDrawPath();
     cp->fPath.reset(path);
     path->ref();
     cp->fFill = fill;
     if (NULL != dstCopy) {
         cp->fDstCopy = *dstCopy;
     }
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrPathRange* pathRange,
                                       const uint32_t indices[], int count,
                                       const float transforms[], PathTransformType transformsType,
                                       SkPath::FillType fill, const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(NULL != pathRange);
     SkASSERT(NULL != indices);
     SkASSERT(NULL != transforms);
 
     if (this->needsNewClip()) {
         this->recordClip();
     }
-    if (this->needsNewState()) {
-        this->recordState();
-    }
+    this->recordStateIfNecessary();
     DrawPaths* dp = this->recordDrawPaths();
     dp->fPathRange.reset(SkRef(pathRange));
     dp->fIndices = SkNEW_ARRAY(uint32_t, count); // TODO: Accomplish this without a malloc
     memcpy(dp->fIndices, indices, sizeof(uint32_t) * count);
     dp->fCount = count;
 
     const int transformsLength = PathTransformSize(transformsType) * count;
     dp->fTransforms = SkNEW_ARRAY(float, transformsLength);
     memcpy(dp->fTransforms, transforms, sizeof(float) * transformsLength);
     dp->fTransformsType = transformsType;
@@ skipping 434 matching lines @@
         kArray_GeometrySrcType == restoredState.fVertexSrc) {
         poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
     }
     if (kReserved_GeometrySrcType == restoredState.fIndexSrc ||
         kArray_GeometrySrcType == restoredState.fIndexSrc) {
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) *
                                          restoredState.fIndexCount;
     }
 }
 
-bool GrInOrderDrawBuffer::needsNewState() const {
-    return fStates.empty() || fStates.back() != this->getDrawState();
+void GrInOrderDrawBuffer::recordStateIfNecessary() {
+    if (fStates.empty()) {
+        fStates.push_back() = this->getDrawState();
+        this->addToCmdBuffer(kSetState_Cmd);
+        return;
+    }
+    const GrDrawState& curr = this->getDrawState();
+    GrDrawState& prev = fStates.back();
+    switch (GrDrawState::CombineIfPossible(prev, curr)) {
+        case GrDrawState::kIncompatible_CombinedState:
+            fStates.push_back() = this->getDrawState();
+            this->addToCmdBuffer(kSetState_Cmd);
+            break;
+        case GrDrawState::kA_CombinedState:
+        case GrDrawState::kAOrB_CombinedState: // Treat the same as kA.
+            break;
+        case GrDrawState::kB_CombinedState:
+            prev = curr;
+            break;
+    }
 }
 
 bool GrInOrderDrawBuffer::needsNewClip() const {
     if (this->getDrawState().isClipState()) {
        if (fClipSet &&
            (fClips.empty() ||
             fClips.back().fStack != *this->getClip()->fClipStack ||
             fClips.back().fOrigin != this->getClip()->fOrigin)) {
            return true;
        }
@@ skipping 12 matching lines @@
     }
 }
 
 void GrInOrderDrawBuffer::recordClip() {
     fClips.push_back().fStack = *this->getClip()->fClipStack;
     fClips.back().fOrigin = this->getClip()->fOrigin;
     fClipSet = false;
     this->addToCmdBuffer(kSetClip_Cmd);
 }
 
-void GrInOrderDrawBuffer::recordState() {
-    fStates.push_back() = this->getDrawState();
-    this->addToCmdBuffer(kSetState_Cmd);
-}
-
 GrInOrderDrawBuffer::DrawRecord* GrInOrderDrawBuffer::recordDraw(const DrawInfo& info) {
     this->addToCmdBuffer(kDraw_Cmd);
     return &fDraws.push_back(info);
 }
 
 GrInOrderDrawBuffer::StencilPath* GrInOrderDrawBuffer::recordStencilPath() {
     this->addToCmdBuffer(kStencilPath_Cmd);
     return &fStencilPaths.push_back();
 }
 
@@ skipping 15 matching lines @@
 GrInOrderDrawBuffer::CopySurface* GrInOrderDrawBuffer::recordCopySurface() {
     this->addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }