State management cleanup

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 31 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 using testing::Test;
 using testing::_;
 
 namespace blink {
 
-class DrawingBufferTest : public Test {
+class DrawingBufferTest : public Test, public DrawingBufferStateTracker {
  protected:
   void SetUp() override {
     IntSize initialSize(InitialWidth, InitialHeight);
     std::unique_ptr<GLES2InterfaceForTests> gl =
         wrapUnique(new GLES2InterfaceForTests);
     m_gl = gl.get();
+    InitializeRestoreState();
+    SetRestoreState();
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         wrapUnique(new WebGraphicsContext3DProviderForTests(std::move(gl)));
     m_drawingBuffer = DrawingBufferForTests::create(
-        std::move(provider), initialSize, DrawingBuffer::Preserve);
+        std::move(provider), this, initialSize, DrawingBuffer::Preserve);
     CHECK(m_drawingBuffer);
   }
 
+  void GetDrawingBufferRestoreState(
+      DrawingBufferRestoreState* restoreState) override {
+    *restoreState = m_restoreState;
+  }
+
+  void InitializeRestoreState() {
+    m_restoreState.scissorEnabled = true;
+    m_restoreState.clearColor[0] = 0.5;
+    m_restoreState.clearColor[3] = 0.8;
+    m_restoreState.clearDepth = 0.8;
+    m_restoreState.clearStencil = 37;
+    m_restoreState.colorMask[1] = GL_TRUE;
+    m_restoreState.colorMask[2] = GL_TRUE;
+    m_restoreState.depthMask = GL_FALSE;
+    m_restoreState.stencilMask = GL_FALSE;
+    m_restoreState.packAlignment = 7;
+    m_restoreState.activeTexture2DBinding = 0xbeef1;
+    m_restoreState.renderbufferBinding = 0xbeef2;
+    m_restoreState.drawFramebufferBinding = 0xbeef3;
+    m_restoreState.readFramebufferBinding = 0xbeef4;
+    m_restoreState.pixelUnpackBufferBinding = 0xbeef5;
+  }
+
+  void SetRestoreState() {
+    if (m_restoreState.scissorEnabled)
+      m_gl->Enable(GL_SCISSOR_TEST);
+    else
+      m_gl->Disable(GL_SCISSOR_TEST);
+
+    m_gl->ClearColor(m_restoreState.clearColor[0], m_restoreState.clearColor[1],
+                     m_restoreState.clearColor[2],
+                     m_restoreState.clearColor[3]);
+    m_gl->ClearDepthf(m_restoreState.clearDepth);
+    m_gl->ClearStencil(m_restoreState.clearStencil);
+    m_gl->ColorMask(m_restoreState.colorMask[0], m_restoreState.colorMask[1],
+                    m_restoreState.colorMask[2], m_restoreState.colorMask[3]);
+    m_gl->DepthMask(m_restoreState.depthMask);
+    m_gl->StencilMask(m_restoreState.stencilMask);
+    m_gl->PixelStorei(GL_PACK_ALIGNMENT, m_restoreState.packAlignment);
+    m_gl->BindTexture(GL_TEXTURE_2D, m_restoreState.activeTexture2DBinding);
+    m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_restoreState.renderbufferBinding);
+    m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER,
+                          m_restoreState.drawFramebufferBinding);
+    m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER,
+                          m_restoreState.readFramebufferBinding);
+    m_gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
+                     m_restoreState.pixelUnpackBufferBinding);
+  }
+  void VerifyStateWasRestored() {
+    DrawingBufferRestoreState actual = m_gl->getActualRestoreState();
+    for (size_t i = 0; i < 4; ++i) {
+      EXPECT_EQ(actual.clearColor[0], m_restoreState.clearColor[0]);
+      EXPECT_EQ(actual.colorMask[0], m_restoreState.colorMask[0]);
+    }
+    EXPECT_EQ(actual.clearDepth, m_restoreState.clearDepth);
+    EXPECT_EQ(actual.clearStencil, m_restoreState.clearStencil);
+    EXPECT_EQ(actual.depthMask, m_restoreState.depthMask);
+    EXPECT_EQ(actual.stencilMask, m_restoreState.stencilMask);
+    EXPECT_EQ(actual.packAlignment, m_restoreState.packAlignment);
+    EXPECT_EQ(actual.activeTexture2DBinding,
+              m_restoreState.activeTexture2DBinding);
+    EXPECT_EQ(actual.renderbufferBinding, m_restoreState.renderbufferBinding);
+    EXPECT_EQ(actual.drawFramebufferBinding,
+              m_restoreState.drawFramebufferBinding);
+    EXPECT_EQ(actual.readFramebufferBinding,
+              m_restoreState.readFramebufferBinding);
+    EXPECT_EQ(actual.pixelUnpackBufferBinding,
+              m_restoreState.pixelUnpackBufferBinding);
+  }
+
   GLES2InterfaceForTests* m_gl;
   RefPtr<DrawingBufferForTests> m_drawingBuffer;
+  DrawingBufferRestoreState m_restoreState;
 };
 
 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();
   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();
+    InitializeRestoreState();
+    SetRestoreState();
     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), this, 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