Add flag for window rectangles to GrRenderTarget

tests/ProxyTest.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.
  */
 
 // This is a GPU-backend specific test.
 
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
+#include "GrGpu.h"
 #include "GrSurfaceProxy.h"
 #include "GrTextureProxy.h"
 #include "GrRenderTargetProxy.h"
 
 static void check_surface(skiatest::Reporter* reporter,
                           GrSurfaceProxy* proxy,
                           GrSurfaceOrigin origin,
                           int width, int height, 
                           GrPixelConfig config) {
     REPORTER_ASSERT(reporter, proxy->origin() == origin);
@@ skipping 20 matching lines @@
         REPORTER_ASSERT(reporter, rt->width() >= rtProxy->width());
         REPORTER_ASSERT(reporter, rt->height() >= rtProxy->height());    
     }
     REPORTER_ASSERT(reporter, rt->config() == rtProxy->config());
 
     REPORTER_ASSERT(reporter, rt->isUnifiedMultisampled() == rtProxy->isUnifiedMultisampled());
     REPORTER_ASSERT(reporter, rt->isStencilBufferMultisampled() ==
                               rtProxy->isStencilBufferMultisampled());
     REPORTER_ASSERT(reporter, rt->numColorSamples() == rtProxy->numColorSamples());
     REPORTER_ASSERT(reporter, rt->numStencilSamples() == rtProxy->numStencilSamples());
-    REPORTER_ASSERT(reporter, rt->hasMixedSamples() == rtProxy->hasMixedSamples());
+    REPORTER_ASSERT(reporter, rt->isMixedSampled() == rtProxy->isMixedSampled());
+    REPORTER_ASSERT(reporter, rt->renderTargetPriv().flags() == rtProxy->testingOnly_getFlags());
 }
 
 static void check_texture(skiatest::Reporter* reporter,
                           GrTextureProvider* provider,
                           GrTextureProxy* texProxy,
                           SkBackingFit fit) {
     REPORTER_ASSERT(reporter, texProxy->asTextureProxy() == texProxy);
     REPORTER_ASSERT(reporter, texProxy->asRenderTargetProxy() == nullptr); // for now
 
     GrTexture* tex = texProxy->instantiate(provider);
@@ skipping 53 matching lines @@
                         }
                     }
                 }
             }
         }
     }
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
     GrTextureProvider* provider = ctxInfo.grContext()->textureProvider();
+    const GrCaps& caps = *ctxInfo.grContext()->caps();
 
     static const int kWidthHeight = 100;
 
     for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
         for (auto config : { kAlpha_8_GrPixelConfig, kRGBA_8888_GrPixelConfig }) {
             for (auto budgeted : { SkBudgeted::kYes, SkBudgeted::kNo }) {
                 for (auto numSamples: { 0, 4}) {
-                    bool renderable = ctxInfo.grContext()->caps()->isConfigRenderable(
-                                                                config, numSamples > 0);
+                    bool renderable = caps.isConfigRenderable(config, numSamples > 0);
 
                     GrSurfaceDesc desc;
                     desc.fOrigin = origin;
                     desc.fWidth = kWidthHeight;
                     desc.fHeight = kWidthHeight;
                     desc.fConfig = config;
                     desc.fSampleCnt = numSamples;
 
+                    // External on-screen render target.
+                    if (renderable && kOpenGL_GrBackend == ctxInfo.backend()) {
+                        GrBackendRenderTargetDesc backendDesc;
+                        backendDesc.fWidth = kWidthHeight;
+                        backendDesc.fHeight = kWidthHeight;
+                        backendDesc.fConfig = config;
+                        backendDesc.fOrigin = origin;
+                        backendDesc.fSampleCnt = numSamples;
+                        backendDesc.fStencilBits = 8;
+                        backendDesc.fRenderTargetHandle = 0;
+
+                        GrGpu* gpu = ctxInfo.grContext()->getGpu();
+                        sk_sp<GrRenderTarget> defaultFBO(
+                            gpu->wrapBackendRenderTarget(backendDesc, kBorrow_GrWrapOwnership));
+                        SkASSERT(!defaultFBO->renderTargetPriv().supportsWindowRectangles());
+
+                        sk_sp<GrRenderTargetProxy> rtProxy(
+                            GrRenderTargetProxy::Make(caps, defaultFBO));
+                        check_surface(reporter, rtProxy.get(), origin,
+                                      kWidthHeight, kWidthHeight, config);
+                        check_rendertarget(reporter, provider, rtProxy.get(), SkBackingFit::kExact);
+                    }
+
                     sk_sp<GrTexture> tex;
 
+                    // Internal offscreen render target.
                     if (renderable) {
                         desc.fFlags = kRenderTarget_GrSurfaceFlag;
                         tex.reset(provider->createTexture(desc, budgeted));
                         sk_sp<GrRenderTarget> rt(sk_ref_sp(tex->asRenderTarget()));
+                        SkASSERT(caps.maxWindowRectangles() <= 0 ||
+                                rt->renderTargetPriv().supportsWindowRectangles());
 
-                        sk_sp<GrRenderTargetProxy> rtProxy(GrRenderTargetProxy::Make(rt));
+                        sk_sp<GrRenderTargetProxy> rtProxy(GrRenderTargetProxy::Make(caps, rt));
                         check_surface(reporter, rtProxy.get(), origin,
                                       kWidthHeight, kWidthHeight, config);
                         check_rendertarget(reporter, provider, rtProxy.get(), SkBackingFit::kExact);
                     }
 
                     if (!tex) {
                         SkASSERT(kNone_GrSurfaceFlags == desc.fFlags );
                         desc.fSampleCnt = 0;
                         tex.reset(provider->createTexture(desc, budgeted));
                     }
 
                     sk_sp<GrTextureProxy> texProxy(GrTextureProxy::Make(tex));
                     check_surface(reporter, texProxy.get(), origin,
                                   kWidthHeight, kWidthHeight, config);
                     check_texture(reporter, provider, texProxy.get(), SkBackingFit::kExact);
                 }
             }
         }
     }
 }
 
 #endif