Implement difference clip rects with window rectangles

src/gpu/gl/GrGLCaps.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLCaps.h"
 
@@ skipping 444 matching lines @@
     // We only have a use for raster multisample if there is coverage modulation from mixed samples.
     if (fUsesMixedSamples && ctxInfo.hasExtension("GL_EXT_raster_multisample")) {
         GR_GL_GetIntegerv(gli, GR_GL_MAX_RASTER_SAMPLES, &fMaxRasterSamples);
         // This is to guard against platforms that may not support as many samples for
         // glRasterSamples as they do for framebuffers.
         fMaxStencilSampleCount = SkTMin(fMaxStencilSampleCount, fMaxRasterSamples);
     }
     fMaxColorSampleCount = fMaxStencilSampleCount;
 
     if (ctxInfo.hasExtension("GL_EXT_window_rectangles")) {
         GR_GL_GetIntegerv(gli, GR_GL_MAX_WINDOW_RECTANGLES, &fMaxWindowRectangles);

[Mark Kilgard, 2016/08/17 17:59:17]

I actually think protecting yourself from a large number of window rectangles is
a good idea.  We've had code get burned when something like the number of
texture units goes up a bunch (Skia is an example of this...).

On NVIDIA GPUs, 8 window rectangles are "free" (meaning as fast as not having
them when they do no discarding), but if an implementation supported many more,
it's likely to have some kind of cost to cycle more than a fixed number.

OpenVG has a minimum limit of like 32 or something.  It's unlikely that many
window rectangles can all be "free".

I recommend you cap at 8.  If an implementation has a higher limit, you'd be
well-served to evaluate the performance of that higher limit rather than just
accept it.  Chrome updates fast enough that moving to a higher limit on future
hardware will be fast.

-        // Protect ourselves against tracking huge amounts of window rectangle state.
-        fMaxWindowRectangles = SkTMin(31, fMaxWindowRectangles);
     }
 
     if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer() ||
         kPowerVRRogue_GrGLRenderer == ctxInfo.renderer() ||
         kAdreno3xx_GrGLRenderer == ctxInfo.renderer()) {
         fUseDrawInsteadOfClear = true;
     }
 
     if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer()) {
         fUseDrawInsteadOfPartialRenderTargetWrite = true;
@@ skipping 1462 matching lines @@
 void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) {
     if (options.fEnableInstancedRendering) {
         fInstancedSupport = gr_instanced::GLInstancedRendering::CheckSupport(*this);
 #ifndef SK_BUILD_FOR_MAC
         // OS X doesn't seem to write correctly to floating point textures when using
         // glDraw*Indirect, regardless of the underlying GPU.
         fAvoidInstancedDrawsToFPTargets = true;
 #endif
     }
 }