cc: Remove the software compositing bool from PrepareTextureMailbox

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 263 matching lines @@
     }
 
     GLES2InterfaceForTests* m_gl;
     RefPtr<DrawingBufferForTests> m_drawingBuffer;
 };
 
 TEST_F(DrawingBufferTest, verifyResizingProperlyAffectsMailboxes)
 {
     cc::TextureMailbox textureMailbox;
     std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
-    bool useSharedMemory = false;
 
     IntSize initialSize(initialWidth, initialHeight);
     IntSize alternateSize(initialWidth, alternateHeight);
 
     // Produce one mailbox at size 100x100.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
 
     // Resize to 100x50.
     m_drawingBuffer->reset(IntSize(initialWidth, alternateHeight));
     releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
 
     // Produce a mailbox at this size.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     EXPECT_EQ(alternateSize, m_gl->mostRecentlyProducedSize());
 
     // Reset to initial size.
     m_drawingBuffer->reset(IntSize(initialWidth, initialHeight));
     releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
 
     // Prepare another mailbox and verify that it's the correct size.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
 
     // 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, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     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;
-    bool useSharedMemory = false;
 
     IntSize initialSize(initialWidth, initialHeight);
 
     // Produce mailboxes.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1));
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2));
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3, &releaseCallback3, useSharedMemory));
+    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();
     m_drawingBuffer.clear();
     ASSERT_EQ(live, true);
@@ skipping 11 matching lines @@
 {
     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;
-    bool useSharedMemory = false;
 
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1));
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2));
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3, &releaseCallback3, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3, &releaseCallback3));
 
     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 */);
     EXPECT_EQ(live, true);
 
     DrawingBufferForTests* rawPtr = m_drawingBuffer.get();
     m_drawingBuffer.clear();
     EXPECT_EQ(live, true);
 
     rawPtr->markContentsChanged();
     releaseCallback3->Run(gpu::SyncToken(), true /* lostResource */);
     EXPECT_EQ(live, false);
 }
 
 TEST_F(DrawingBufferTest, verifyOnlyOneRecycledMailboxMustBeKept)
 {
     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;
-    bool useSharedMemory = false;
 
     // Produce mailboxes.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1));
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2));
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3, &releaseCallback3, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3, &releaseCallback3));
 
     // Release mailboxes by specific order; 1, 3, 2.
     m_drawingBuffer->markContentsChanged();
     releaseCallback1->Run(gpu::SyncToken(), false /* lostResource */);
     m_drawingBuffer->markContentsChanged();
     releaseCallback3->Run(gpu::SyncToken(), false /* lostResource */);
     m_drawingBuffer->markContentsChanged();
     releaseCallback2->Run(gpu::SyncToken(), false /* lostResource */);
 
     // The first recycled mailbox must be 2. 1 and 3 were deleted by FIFO order because
     // DrawingBuffer never keeps more than one mailbox.
     cc::TextureMailbox recycledTextureMailbox1;
     std::unique_ptr<cc::SingleReleaseCallback> recycledReleaseCallback1;
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&recycledTextureMailbox1, &recycledReleaseCallback1, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&recycledTextureMailbox1, &recycledReleaseCallback1));
     EXPECT_EQ(textureMailbox2.mailbox(), recycledTextureMailbox1.mailbox());
 
     // The second recycled mailbox must be a new mailbox.
     cc::TextureMailbox recycledTextureMailbox2;
     std::unique_ptr<cc::SingleReleaseCallback> recycledReleaseCallback2;
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&recycledTextureMailbox2, &recycledReleaseCallback2, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&recycledTextureMailbox2, &recycledReleaseCallback2));
     EXPECT_NE(textureMailbox1.mailbox(), recycledTextureMailbox2.mailbox());
     EXPECT_NE(textureMailbox2.mailbox(), recycledTextureMailbox2.mailbox());
     EXPECT_NE(textureMailbox3.mailbox(), recycledTextureMailbox2.mailbox());
 
     recycledReleaseCallback1->Run(gpu::SyncToken(), false /* lostResource */);
     recycledReleaseCallback2->Run(gpu::SyncToken(), false /* lostResource */);
     m_drawingBuffer->beginDestruction();
 }
 
 TEST_F(DrawingBufferTest, verifyInsertAndWaitSyncTokenCorrectly)
 {
     cc::TextureMailbox textureMailbox;
     std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
-    bool useSharedMemory = false;
 
     // Produce mailboxes.
     m_drawingBuffer->markContentsChanged();
     EXPECT_EQ(gpu::SyncToken(), m_gl->mostRecentlyWaitedSyncToken());
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     // PrepareTextureMailbox() does not wait for any sync point.
     EXPECT_EQ(gpu::SyncToken(), m_gl->mostRecentlyWaitedSyncToken());
 
     gpu::SyncToken waitSyncToken;
     m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), waitSyncToken.GetData());
     releaseCallback->Run(waitSyncToken, false /* lostResource */);
     // m_drawingBuffer will wait for the sync point when recycling.
     EXPECT_EQ(gpu::SyncToken(), m_gl->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     // m_drawingBuffer waits for the sync point when recycling in PrepareTextureMailbox().
     EXPECT_EQ(waitSyncToken, m_gl->mostRecentlyWaitedSyncToken());
 
     m_drawingBuffer->beginDestruction();
     m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), waitSyncToken.GetData());
     releaseCallback->Run(waitSyncToken, false /* lostResource */);
     // m_drawingBuffer waits for the sync point because the destruction is in progress.
     EXPECT_EQ(waitSyncToken, m_gl->mostRecentlyWaitedSyncToken());
 }
 
@@ skipping 18 matching lines @@
         RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(false);
     }
 
     GLuint m_imageId0;
 };
 
 TEST_F(DrawingBufferImageChromiumTest, verifyResizingReallocatesImages)
 {
     cc::TextureMailbox textureMailbox;
     std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
-    bool useSharedMemory = false;
 
     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, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
     EXPECT_TRUE(textureMailbox.is_overlay_candidate());
     testing::Mock::VerifyAndClearExpectations(m_gl);
 
     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);
     // Resize to 100x50.
     m_drawingBuffer->reset(IntSize(initialWidth, alternateHeight));
     releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
     testing::Mock::VerifyAndClearExpectations(m_gl);
 
     GLuint m_imageId3 = m_gl->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId3)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId1)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId1)).Times(1);
     // Produce a mailbox at this size.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    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);
     // Reset to initial size.
     m_drawingBuffer->reset(IntSize(initialWidth, initialHeight));
     releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
     testing::Mock::VerifyAndClearExpectations(m_gl);
 
     GLuint m_imageId5 = m_gl->nextImageIdToBeCreated();
     EXPECT_CALL(*m_gl, BindTexImage2DMock(m_imageId5)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId3)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId3)).Times(1);
     // Prepare another mailbox and verify that it's the correct size.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
     EXPECT_TRUE(textureMailbox.is_overlay_candidate());
     testing::Mock::VerifyAndClearExpectations(m_gl);
 
     // 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, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
     EXPECT_EQ(initialSize, m_gl->mostRecentlyProducedSize());
     EXPECT_TRUE(textureMailbox.is_overlay_candidate());
     releaseCallback->Run(gpu::SyncToken(), false /* lostResource */);
 
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId5)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId5)).Times(1);
     EXPECT_CALL(*m_gl, DestroyImageMock(m_imageId4)).Times(1);
     EXPECT_CALL(*m_gl, ReleaseTexImage2DMock(m_imageId4)).Times(1);
     m_drawingBuffer->beginDestruction();
     testing::Mock::VerifyAndClearExpectations(m_gl);
 }
 
 TEST_F(DrawingBufferImageChromiumTest, allocationFailure)
 {
     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;
-    bool useSharedMemory = false;
 
     // 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, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox1, &releaseCallback1));
     EXPECT_TRUE(textureMailbox1.is_overlay_candidate());
     testing::Mock::VerifyAndClearExpectations(m_gl);
 
     // 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, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox2, &releaseCallback2));
     EXPECT_FALSE(textureMailbox2.is_overlay_candidate());
 
     // 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, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox3, &releaseCallback3));
     EXPECT_TRUE(textureMailbox3.is_overlay_candidate());
     testing::Mock::VerifyAndClearExpectations(m_gl);
 
     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();
@@ skipping 138 matching lines @@
         }
 
         drawingBuffer->beginDestruction();
     }
 }
 
 TEST_F(DrawingBufferTest, verifySetIsHiddenProperlyAffectsMailboxes)
 {
     cc::TextureMailbox textureMailbox;
     std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
-    bool useSharedMemory = false;
 
     // Produce mailboxes.
     m_drawingBuffer->markContentsChanged();
-    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+    EXPECT_TRUE(m_drawingBuffer->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
 
     gpu::SyncToken waitSyncToken;
     m_gl->GenSyncTokenCHROMIUM(m_gl->InsertFenceSyncCHROMIUM(), waitSyncToken.GetData());
     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