Make DrawingBuffer and Canvas2DLayerBridge be cc::TextureLayerClients.

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridgeTest.cpp

 /*
  * Copyright (C) 2011 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/Canvas2DLayerBridge.h"
 
-#include "SkSurface.h"
+#include "cc/resources/single_release_callback.h"
+#include "cc/resources/texture_mailbox.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/capabilities.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/test/FakeGLES2Interface.h"
 #include "platform/graphics/test/FakeWebGraphicsContext3DProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebExternalBitmap.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "public/platform/functional/WebFunction.h"
 #include "skia/ext/texture_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
+
 #include <memory>
 
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::InSequence;
 using testing::Return;
 using testing::Test;
 using testing::_;
 
 namespace blink {
@@ skipping 25 matching lines @@
         m_layerBridge = layerBridge;
     }
 
     Canvas2DLayerBridge* operator->() { return m_layerBridge.get(); }
     Canvas2DLayerBridge* get() { return m_layerBridge.get(); }
 
 private:
     RefPtr<Canvas2DLayerBridge> m_layerBridge;
 };
 
-class NullWebExternalBitmap : public WebExternalBitmap {
-public:
-    WebSize size() override
-    {
-        return WebSize();
-    }
-
-    void setSize(WebSize) override
-    {
-    }
-
-    uint8_t* pixels() override
-    {
-        return nullptr;
-    }
-};
-
 } // anonymous namespace
 
 class Canvas2DLayerBridgeTest : public Test {
 public:
     PassRefPtr<Canvas2DLayerBridge> makeBridge(std::unique_ptr<FakeWebGraphicsContext3DProvider> provider, const IntSize& size, Canvas2DLayerBridge::AccelerationMode accelerationMode)
     {
         return adoptRef(new Canvas2DLayerBridge(std::move(provider), size, 0, NonOpaque, accelerationMode));
     }
 
 protected:
@@ skipping 67 matching lines @@
         bridge->canvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), paint);
         EXPECT_EQ(genID, bridge->getOrCreateSurface()->generationID());
         // This results in the internal surface being torn down in response to the context loss.
         EXPECT_FALSE(bridge->checkSurfaceValid());
         EXPECT_EQ(nullptr, bridge->getOrCreateSurface());
         // The following passes by not crashing
         bridge->canvas()->drawRect(SkRect::MakeXYWH(0, 0, 1, 1), paint);
         bridge->flush();
     }
 
-    void prepareMailboxWithBitmapTest()
+    void prepareMailboxSoftwareTest()
     {
         FakeGLES2Interface gl;
         std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider = wrapUnique(new FakeWebGraphicsContext3DProvider(&gl));
         Canvas2DLayerBridgePtr bridge(adoptRef(new Canvas2DLayerBridge(std::move(contextProvider), IntSize(300, 150), 0, NonOpaque, Canvas2DLayerBridge::ForceAccelerationForTesting)));
-        bridge->m_lastImageId = 1;
 
-        NullWebExternalBitmap bitmap;
-        bridge->prepareMailbox(0, &bitmap);
-        EXPECT_EQ(0u, bridge->m_lastImageId);
+        cc::TextureMailbox textureMailbox;
+        std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+        bool useSharedMemory = true;
+        EXPECT_FALSE(bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
     }
 
     void prepareMailboxAndLoseResourceTest()
     {
-        bool lostResource = true;
-
         // Prepare a mailbox, then report the resource as lost.
         // This test passes by not crashing and not triggering assertions.
         {
             FakeGLES2Interface gl;
             std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider = wrapUnique(new FakeWebGraphicsContext3DProvider(&gl));
             Canvas2DLayerBridgePtr bridge(adoptRef(new Canvas2DLayerBridge(std::move(contextProvider), IntSize(300, 150), 0, NonOpaque, Canvas2DLayerBridge::ForceAccelerationForTesting)));
-            WebExternalTextureMailbox mailbox;
-            bridge->prepareMailbox(&mailbox, 0);
-            bridge->mailboxReleased(mailbox, lostResource);
+
+            cc::TextureMailbox textureMailbox;
+            std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+            bool useSharedMemory = false;
+            EXPECT_TRUE(bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
+
+            bool lostResource = true;
+            releaseCallback->Run(gpu::SyncToken(), lostResource);
         }
 
         // Retry with mailbox released while bridge destruction is in progress.
         {
             FakeGLES2Interface gl;
             std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider = wrapUnique(new FakeWebGraphicsContext3DProvider(&gl));
-            WebExternalTextureMailbox mailbox;
-            Canvas2DLayerBridge* rawBridge;
+
+            cc::TextureMailbox textureMailbox;
+            std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+            bool useSharedMemory = false;
+
             {
                 Canvas2DLayerBridgePtr bridge(adoptRef(new Canvas2DLayerBridge(std::move(contextProvider), IntSize(300, 150), 0, NonOpaque, Canvas2DLayerBridge::ForceAccelerationForTesting)));
-                bridge->prepareMailbox(&mailbox, 0);
-                rawBridge = bridge.get();
-            } // bridge goes out of scope, but object is kept alive by self references.
+                bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory);
+                // |bridge| goes out of scope and would normally be destroyed, but object is kept alive by self references.
+            }
+
             // Before fixing crbug.com/411864, the following line you cause a memory use after free
             // that sometimes causes a crash in normal builds and crashes consistently with ASAN.
-            rawBridge->mailboxReleased(mailbox, lostResource); // This should self-destruct the bridge.
+            // This should cause the bridge to be destroyed.
+            bool lostResource = true;
+            releaseCallback->Run(gpu::SyncToken(), lostResource);
         }
     }
 
     void accelerationHintTest()
     {
         {
             FakeGLES2Interface gl;
             std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider = wrapUnique(new FakeWebGraphicsContext3DProvider(&gl));
             Canvas2DLayerBridgePtr bridge(adoptRef(new Canvas2DLayerBridge(std::move(contextProvider), IntSize(300, 300), 0, NonOpaque, Canvas2DLayerBridge::EnableAcceleration)));
             SkPaint paint;
@@ skipping 19 matching lines @@
 TEST_F(Canvas2DLayerBridgeTest, FullLifecycleSingleThreaded)
 {
     fullLifecycleTest();
 }
 
 TEST_F(Canvas2DLayerBridgeTest, NoDrawOnContextLost)
 {
     noDrawOnContextLostTest();
 }
 
-TEST_F(Canvas2DLayerBridgeTest, PrepareMailboxWithBitmap)
+TEST_F(Canvas2DLayerBridgeTest, PrepareMailboxSoftware)
 {
-    prepareMailboxWithBitmapTest();
+    prepareMailboxSoftwareTest();
 }
 
 TEST_F(Canvas2DLayerBridgeTest, PrepareMailboxAndLoseResource)
 {
     prepareMailboxAndLoseResourceTest();
 }
 
 TEST_F(Canvas2DLayerBridgeTest, AccelerationHint)
 {
     accelerationHintTest();
@@ skipping 709 matching lines @@
     // Test entering hibernation
     std::unique_ptr<WaitableEvent> hibernationStartedEvent = wrapUnique(new WaitableEvent());
     EXPECT_CALL(*mockLoggerPtr, reportHibernationEvent(Canvas2DLayerBridge::HibernationScheduled));
     EXPECT_CALL(*mockLoggerPtr, didStartHibernating())
         .WillOnce(testing::Invoke(hibernationStartedEvent.get(), &WaitableEvent::signal));
     postSetIsHiddenTask(BLINK_FROM_HERE, testThread.get(), bridge.get(), true);
     hibernationStartedEvent->wait();
     ::testing::Mock::VerifyAndClearExpectations(mockLoggerPtr);
 
     // Test prepareMailbox while hibernating
-    WebExternalTextureMailbox mailbox;
-    EXPECT_FALSE(bridge->prepareMailbox(&mailbox, 0));
+    cc::TextureMailbox textureMailbox;
+    std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+    bool useSharedMemory = false;
+    EXPECT_FALSE(bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
     EXPECT_TRUE(bridge->checkSurfaceValid());
 
     // Tear down the bridge on the thread so that 'bridge' can go out of scope
     // without crashing due to thread checks
     EXPECT_CALL(*mockLoggerPtr, reportHibernationEvent(Canvas2DLayerBridge::HibernationEndedWithTeardown));
     postAndWaitDestroyBridgeTask(BLINK_FROM_HERE, testThread.get(), &bridge);
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
 TEST_F(Canvas2DLayerBridgeTest, PrepareMailboxWhileBackgroundRendering)
@@ skipping 25 matching lines @@
 
     // Rendering in the background -> temp switch to SW
     EXPECT_CALL(*mockLoggerPtr, reportHibernationEvent(Canvas2DLayerBridge::HibernationEndedWithSwitchToBackgroundRendering));
     postAndWaitRenderingTask(BLINK_FROM_HERE, testThread.get(), bridge.get());
     ::testing::Mock::VerifyAndClearExpectations(mockLoggerPtr);
     EXPECT_FALSE(bridge->isAccelerated());
     EXPECT_FALSE(bridge->isHibernating());
     EXPECT_TRUE(bridge->checkSurfaceValid());
 
     // Test prepareMailbox while background rendering
-    WebExternalTextureMailbox mailbox;
-    EXPECT_FALSE(bridge->prepareMailbox(&mailbox, 0));
+    cc::TextureMailbox textureMailbox;
+    std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+    bool useSharedMemory = false;
+    EXPECT_FALSE(bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback, useSharedMemory));
     EXPECT_TRUE(bridge->checkSurfaceValid());
 
     // Tear down the bridge on the thread so that 'bridge' can go out of scope
     // without crashing due to thread checks
     postAndWaitDestroyBridgeTask(BLINK_FROM_HERE, testThread.get(), &bridge);
 }
 
 } // namespace blink