Improve usage of window rectangles

src/gpu/gl/GrGLGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLGpu_DEFINED
 #define GrGLGpu_DEFINED
 
 #include "GrGLContext.h"
 #include "GrGLIRect.h"
 #include "GrGLPathRendering.h"
 #include "GrGLProgram.h"
 #include "GrGLRenderTarget.h"
 #include "GrGLStencilAttachment.h"
 #include "GrGLTexture.h"
 #include "GrGLVertexArray.h"
 #include "GrGpu.h"
 #include "GrTypes.h"
+#include "GrWindowRectsState.h"
 #include "GrXferProcessor.h"
 #include "SkTArray.h"
 #include "SkTypes.h"
 
 class GrGLBuffer;
 class GrPipeline;
 class GrNonInstancedMesh;
 class GrSwizzle;
 
 namespace gr_instanced { class GLInstancedRendering; }
@@ skipping 276 matching lines @@
 
     // flushes the scissor. see the note on flushBoundTextureAndParams about
     // flushing the scissor after that function is called.
     void flushScissor(const GrScissorState&,
                       const GrGLIRect& rtViewport,
                       GrSurfaceOrigin rtOrigin);
 
     // disables the scissor
     void disableScissor();
 
-    void flushWindowRectangles(const GrWindowRectangles&, const GrGLRenderTarget*);
+    void flushWindowRectangles(const GrWindowRectsState&, const GrGLRenderTarget*);
     void disableWindowRectangles();
 
     void initFSAASupport();
 
     // determines valid stencil formats
     void initStencilFormats();
 
     // sets a texture unit to use for texture operations other than binding a texture to a program.
     // ensures that such operations don't negatively interact with tracking bound textures.
     void setScratchTextureUnit();
@@ skipping 89 matching lines @@
         TriState    fEnabled;
         GrGLIRect   fRect;
         void invalidate() {
             fEnabled = kUnknown_TriState;
             fRect.invalidate();
         }
     } fHWScissorSettings;
 
     class {
     public:
-        bool valid() const { return kInvalidOrigin != fOrigin; }
-        void invalidate() { fOrigin = kInvalidOrigin; }
+        bool valid() const { return kInvalidSurfaceOrigin != fRTOrigin; }
+        void invalidate() { fRTOrigin = kInvalidSurfaceOrigin; }
+        bool disabled() const { return this->valid() && fWindowState.disabled(); }
+        void setDisabled() { fRTOrigin = kDefault_GrSurfaceOrigin, fWindowState.setDisabled(); }
 
-        bool disabled() const {
-            return this->valid() && Mode::kExclusive == fWindows.mode() && !fWindows.count();
+        void set(GrSurfaceOrigin rtOrigin, const GrGLIRect& viewport,
+                 const GrWindowRectsState& windowState) {
+            fRTOrigin = rtOrigin;
+            fViewport = viewport;
+            fWindowState = windowState;
         }
-        void setDisabled() { fOrigin = kDefault_GrSurfaceOrigin, fWindows.reset(); }
 
-        bool equal(GrSurfaceOrigin org, const GrGLIRect& viewp,
-                   const GrWindowRectangles& windows) const {
+        bool cheapEqualTo(GrSurfaceOrigin rtOrigin, const GrGLIRect& viewport,
+                          const GrWindowRectsState& windowState) const {
             if (!this->valid()) {
                 return false;
             }
-            if (fWindows.count() && (fOrigin != org || fViewport != viewp)) {
+            if (fWindowState.numWindows() && (fRTOrigin != rtOrigin || fViewport != viewport)) {
                 return false;
             }
-            return fWindows == windows;
-        }
-
-        void set(GrSurfaceOrigin org, const GrGLIRect& viewp, const GrWindowRectangles& windows) {
-            fOrigin = org;
-            fViewport = viewp;
-            fWindows = windows;
+            return fWindowState.cheapEqualTo(windowState);
         }
 
     private:
-        typedef GrWindowRectangles::Mode Mode;
-        enum { kInvalidOrigin = -1 };
+        enum { kInvalidSurfaceOrigin = -1 };
 
-        int                  fOrigin;
+        int                  fRTOrigin;
         GrGLIRect            fViewport;
-        GrWindowRectangles   fWindows;
-    } fHWWindowRects;
+        GrWindowRectsState   fWindowState;
+    } fHWWindowRectsState;
 
     GrGLIRect                   fHWViewport;
 
     /**
      * Tracks vertex attrib array state.
      */
     class HWVertexArrayState {
     public:
         HWVertexArrayState() : fCoreProfileVertexArray(nullptr) { this->invalidate(); }
 
@@ skipping 165 matching lines @@
     bool fPLSHasBeenUsed;
 
     float fHWMinSampleShading;
 
     typedef GrGpu INHERITED;
     friend class GrGLPathRendering; // For accessing setTextureUnit.
     friend class gr_instanced::GLInstancedRendering; // For accessing flushGLState.
 };
 
 #endif