DrawingBuffer: Clean up GL state restoration

third_party/WebKit/Source/platform/graphics/gpu/DrawingBufferTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 38 matching lines @@
 
 namespace blink {
 
 class DrawingBufferTest : public Test {
  protected:
   void SetUp() override {
     IntSize initialSize(InitialWidth, InitialHeight);
     std::unique_ptr<GLES2InterfaceForTests> gl =
         wrapUnique(new GLES2InterfaceForTests);
     m_gl = gl.get();
+    SetAndSaveRestoreState(false);
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         wrapUnique(new WebGraphicsContext3DProviderForTests(std::move(gl)));
     m_drawingBuffer = DrawingBufferForTests::create(
-        std::move(provider), initialSize, DrawingBuffer::Preserve);
+        std::move(provider), m_gl, initialSize, DrawingBuffer::Preserve);
     CHECK(m_drawingBuffer);
   }
 
+  // Initialize GL state with unusual values, to verify that they are restored.
+  // The |invert| parameter will reverse all boolean parameters, so that all
+  // values are tested.
+  void SetAndSaveRestoreState(bool invert) {
+    GLboolean scissorEnabled = !invert;
+    GLfloat clearColor[4] = {0.1, 0.2, 0.3, 0.4};
+    GLfloat clearDepth = 0.8;
+    GLint clearStencil = 37;
+    GLboolean colorMask[4] = {invert, !invert, !invert, invert};
+    GLboolean depthMask = invert;
+    GLboolean stencilMask = invert;
+    GLint packAlignment = 7;
+    GLuint activeTexture2DBinding = 0xbeef1;
+    GLuint renderbufferBinding = 0xbeef2;
+    GLuint drawFramebufferBinding = 0xbeef3;
+    GLuint readFramebufferBinding = 0xbeef4;
+    GLuint pixelUnpackBufferBinding = 0xbeef5;
+
+    if (scissorEnabled)
+      m_gl->Enable(GL_SCISSOR_TEST);
+    else
+      m_gl->Disable(GL_SCISSOR_TEST);
+
+    m_gl->ClearColor(clearColor[0], clearColor[1], clearColor[2],
+                     clearColor[3]);
+    m_gl->ClearDepthf(clearDepth);
+    m_gl->ClearStencil(clearStencil);
+    m_gl->ColorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]);
+    m_gl->DepthMask(depthMask);
+    m_gl->StencilMask(stencilMask);
+    m_gl->PixelStorei(GL_PACK_ALIGNMENT, packAlignment);
+    m_gl->BindTexture(GL_TEXTURE_2D, activeTexture2DBinding);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, renderbufferBinding);
+    m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER, drawFramebufferBinding);
+    m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER, readFramebufferBinding);
+    m_gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, pixelUnpackBufferBinding);
+
+    m_gl->SaveState();
+  }
+
+  void VerifyStateWasRestored() { m_gl->VerifyStateHasNotChangedSinceSave(); }
+
   GLES2InterfaceForTests* m_gl;
   RefPtr<DrawingBufferForTests> m_drawingBuffer;
 };
 
 TEST_F(DrawingBufferTest, verifyResizingProperlyAffectsMailboxes) {
+  VerifyStateWasRestored();
   cc::TextureMailbox textureMailbox;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
 
   IntSize initialSize(InitialWidth, InitialHeight);
   IntSize alternateSize(InitialWidth, AlternateHeight);
 
   // Produce one mailbox at size 100x100.
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
+  VerifyStateWasRestored();
   EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
 
   // Resize to 100x50.
-  m_drawingBuffer->reset(alternateSize);
+  m_drawingBuffer->resize(alternateSize);
+  VerifyStateWasRestored();
   releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
+  VerifyStateWasRestored();
 
   // Produce a mailbox at this size.
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
   EXPECT_EQ(alternateSize, m_gl->mostRecentlyProducedSize());
+  VerifyStateWasRestored();
 
   // Reset to initial size.
-  m_drawingBuffer->reset(initialSize);
+  m_drawingBuffer->resize(initialSize);
+  VerifyStateWasRestored();
+  SetAndSaveRestoreState(true);
   releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
+  VerifyStateWasRestored();
 
   // Prepare another mailbox and verify that it's the correct size.
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
   EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
+  VerifyStateWasRestored();
 
   // Prepare one final mailbox and verify that it's the correct size.
   releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
+  VerifyStateWasRestored();
   EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
   releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
   m_drawingBuffer->beginDestruction();
 }
 
 TEST_F(DrawingBufferTest, verifyDestructionCompleteAfterAllMailboxesReleased) {
   bool live = true;
   m_drawingBuffer->m_live = &live;
 
   cc::TextureMailbox textureMailbox1;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback1;
   cc::TextureMailbox textureMailbox2;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback2;
   cc::TextureMailbox textureMailbox3;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback3;
 
   IntSize initialSize(InitialWidth, InitialHeight);
 
   // Produce mailboxes.
   m_drawingBuffer->markContentsChanged();
+  m_drawingBuffer->clearFramebuffers(GL_STENCIL_BUFFER_BIT);
+  VerifyStateWasRestored();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1,
                                                      &releaseCallback1));
   m_drawingBuffer->markContentsChanged();
+  m_drawingBuffer->clearFramebuffers(GL_DEPTH_BUFFER_BIT);
+  VerifyStateWasRestored();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2,
                                                      &releaseCallback2));
   m_drawingBuffer->markContentsChanged();
+  m_drawingBuffer->clearFramebuffers(GL_COLOR_BUFFER_BIT);
+  VerifyStateWasRestored();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3,
                                                      &releaseCallback3));
 
   m_drawingBuffer->markContentsChanged();
   releaseCallback1->Run(gpu::SyncToken(), false /* lostResource */);
 
   m_drawingBuffer->beginDestruction();
   ASSERT_EQ(live, true);
 
   DrawingBufferForTests* rawPointer = m_drawingBuffer.get();
@@ skipping 16 matching lines @@
   cc::TextureMailbox textureMailbox1;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback1;
   cc::TextureMailbox textureMailbox2;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback2;
   cc::TextureMailbox textureMailbox3;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback3;
 
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1,
                                                      &releaseCallback1));
+  VerifyStateWasRestored();
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2,
                                                      &releaseCallback2));
+  VerifyStateWasRestored();
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3,
                                                      &releaseCallback3));
+  VerifyStateWasRestored();
 
   m_drawingBuffer->markContentsChanged();
   releaseCallback1->Run(gpu::SyncToken(), true /* lostResource */);
   EXPECT_EQ(live, true);
 
   m_drawingBuffer->beginDestruction();
   EXPECT_EQ(live, true);
 
   m_drawingBuffer->markContentsChanged();
   releaseCallback2->Run(gpu::SyncToken(), false /* lostResource */);
@@ skipping 94 matching lines @@
   EXPECT_EQ(waitSyncToken, m_gl->mostRecentlyWaitedSyncToken());
 }
 
 class DrawingBufferImageChromiumTest : public DrawingBufferTest {
  protected:
   void SetUp() override {
     IntSize initialSize(InitialWidth, InitialHeight);
     std::unique_ptr<GLES2InterfaceForTests> gl =
         wrapUnique(new GLES2InterfaceForTests);
     m_gl = gl.get();
+    SetAndSaveRestoreState(true);
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         wrapUnique(new WebGraphicsContext3DProviderForTests(std::move(gl)));
     RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(true);
     m_imageId0 = m_gl->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId0)).Times(1);
     m_drawingBuffer = DrawingBufferForTests::create(
-        std::move(provider), initialSize, DrawingBuffer::Preserve);
+        std::move(provider), m_gl, initialSize, DrawingBuffer::Preserve);
     CHECK(m_drawingBuffer);
     testing::Mock::VerifyAndClearExpectations(m_gl);
   }
 
   void TearDown() override {
     RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(false);
   }
 
   GLuint m_imageId0;
 };
 
 TEST_F(DrawingBufferImageChromiumTest, verifyResizingReallocatesImages) {
   cc::TextureMailbox textureMailbox;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
 
   IntSize initialSize(InitialWidth, InitialHeight);
   IntSize alternateSize(InitialWidth, AlternateHeight);
 
   GLuint m_imageId1 = m_gl->nextImageIdToBeCreated();
   EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId1)).Times(1);
   // Produce one mailbox at size 100x100.
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
   EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
   EXPECT_TRUE(textureMailbox.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(m_gl);
+  VerifyStateWasRestored();
 
   GLuint m_imageId2 = m_gl->nextImageIdToBeCreated();
   EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId2)).Times(1);
   EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId0)).Times(1);
   EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId0)).Times(1);
   EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId1)).Times(1);
   EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId1)).Times(1);
   // Resize to 100x50.
-  m_drawingBuffer->reset(alternateSize);
+  m_drawingBuffer->resize(alternateSize);
+  VerifyStateWasRestored();
   releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
+  VerifyStateWasRestored();
   testing::Mock::VerifyAndClearExpectations(m_gl);
 
   GLuint m_imageId3 = m_gl->nextImageIdToBeCreated();
   EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId3)).Times(1);
   // Produce a mailbox at this size.
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
   EXPECT_EQ(alternateSize, m_gl->mostRecentlyProducedSize());
   EXPECT_TRUE(textureMailbox.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(m_gl);
 
   GLuint m_imageId4 = m_gl->nextImageIdToBeCreated();
   EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId4)).Times(1);
   EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId2)).Times(1);
   EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId2)).Times(1);
   EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId3)).Times(1);
   EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId3)).Times(1);
   // Reset to initial size.
-  m_drawingBuffer->reset(initialSize);
+  m_drawingBuffer->resize(initialSize);
+  VerifyStateWasRestored();
   releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
+  VerifyStateWasRestored();
   testing::Mock::VerifyAndClearExpectations(m_gl);
 
   GLuint m_imageId5 = m_gl->nextImageIdToBeCreated();
   EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId5)).Times(1);
   // Prepare another mailbox and verify that it's the correct size.
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox,
                                                      &releaseCallback));
   EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
   EXPECT_TRUE(textureMailbox.is_overlay_candidate());
@@ skipping 26 matching lines @@
 
   // Request a mailbox. An image should already be created. Everything works
   // as expected.
   EXPECT_CALL(*m_gl, BindTexImage2DMock(_)).Times(1);
   IntSize initialSize(InitialWidth, InitialHeight);
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1,
                                                      &releaseCallback1));
   EXPECT_TRUE(textureMailbox1.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(m_gl);
+  VerifyStateWasRestored();
 
   // Force image CHROMIUM creation failure. Request another mailbox. It should
   // still be provided, but this time with allowOverlay = false.
   m_gl->setCreateImageChromiumFail(true);
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2,
                                                      &releaseCallback2));
   EXPECT_FALSE(textureMailbox2.is_overlay_candidate());
+  VerifyStateWasRestored();
 
   // Check that if image CHROMIUM starts working again, mailboxes are
   // correctly created with allowOverlay = true.
   EXPECT_CALL(*m_gl, BindTexImage2DMock(_)).Times(1);
   m_gl->setCreateImageChromiumFail(false);
   m_drawingBuffer->markContentsChanged();
   EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3,
                                                      &releaseCallback3));
   EXPECT_TRUE(textureMailbox3.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(m_gl);
+  VerifyStateWasRestored();
 
   releaseCallback1->Run(gpu::SyncToken(), false /* lostResource */);
   releaseCallback2->Run(gpu::SyncToken(), false /* lostResource */);
   releaseCallback3->Run(gpu::SyncToken(), false /* lostResource */);
 
   EXPECT_CALL(*m_gl, DestroyImageMock(_)).Times(3);
   EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(_)).Times(3);
   m_drawingBuffer->beginDestruction();
   testing::Mock::VerifyAndClearExpectations(m_gl);
 }
@@ skipping 96 matching lines @@
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         wrapUnique(new WebGraphicsContext3DProviderForTests(std::move(gl)));
     DrawingBuffer::PreserveDrawingBuffer preserve = DrawingBuffer::Preserve;
 
     bool premultipliedAlpha = false;
     bool wantAlphaChannel = true;
     bool wantDepthBuffer = cases[i].requestDepth;
     bool wantStencilBuffer = cases[i].requestStencil;
     bool wantAntialiasing = false;
     RefPtr<DrawingBuffer> drawingBuffer = DrawingBuffer::create(
-        std::move(provider), IntSize(10, 10), premultipliedAlpha,
+        std::move(provider), nullptr, IntSize(10, 10), premultipliedAlpha,
         wantAlphaChannel, wantDepthBuffer, wantStencilBuffer, wantAntialiasing,
         preserve, DrawingBuffer::WebGL1, DrawingBuffer::AllowChromiumImage);
 
     // When we request a depth or a stencil buffer, we will get both.
     EXPECT_EQ(cases[i].requestDepth || cases[i].requestStencil,
               drawingBuffer->hasDepthBuffer());
     EXPECT_EQ(cases[i].requestDepth || cases[i].requestStencil,
               drawingBuffer->hasStencilBuffer());
     EXPECT_EQ(cases[i].expectedRenderBuffers,
               trackingGL->numAllocatedRenderBuffer());
     if (cases[i].requestDepth || cases[i].requestStencil) {
       EXPECT_NE(0u, trackingGL->depthStencilAttachment());
       EXPECT_EQ(0u, trackingGL->depthAttachment());
       EXPECT_EQ(0u, trackingGL->stencilAttachment());
     } else {
       EXPECT_EQ(0u, trackingGL->depthStencilAttachment());
       EXPECT_EQ(0u, trackingGL->depthAttachment());
       EXPECT_EQ(0u, trackingGL->stencilAttachment());
     }
 
-    drawingBuffer->reset(IntSize(10, 20));
+    drawingBuffer->resize(IntSize(10, 20));
     EXPECT_EQ(cases[i].requestDepth || cases[i].requestStencil,
               drawingBuffer->hasDepthBuffer());
     EXPECT_EQ(cases[i].requestDepth || cases[i].requestStencil,
               drawingBuffer->hasStencilBuffer());
     EXPECT_EQ(cases[i].expectedRenderBuffers,
               trackingGL->numAllocatedRenderBuffer());
     if (cases[i].requestDepth || cases[i].requestStencil) {
       EXPECT_NE(0u, trackingGL->depthStencilAttachment());
       EXPECT_EQ(0u, trackingGL->depthAttachment());
       EXPECT_EQ(0u, trackingGL->stencilAttachment());
@@ skipping 22 matching lines @@
   m_drawingBuffer->setIsHidden(true);
   releaseCallback->Run(waitSyncToken, false /* lostResource */);
   // m_drawingBuffer deletes mailbox immediately when hidden.
 
   EXPECT_EQ(waitSyncToken, m_gl->mostRecentlyWaitedSyncToken());
 
   m_drawingBuffer->beginDestruction();
 }
 
 }  // namespace blink