Fix Canvas2DLayerBridge IOSurface leak.

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 "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
+#include "cc/test/test_gpu_memory_buffer_manager.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/WebTaskRunner.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/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "skia/ext/texture_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/Source/platform/testing/TestingPlatformSupport.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;
@@ skipping 26 matching lines @@
     m_layerBridge = layerBridge;
   }
 
   Canvas2DLayerBridge* operator->() { return m_layerBridge.get(); }
   Canvas2DLayerBridge* get() { return m_layerBridge.get(); }
 
  private:
   RefPtr<Canvas2DLayerBridge> m_layerBridge;
 };
 
+class FakeGLES2InterfaceWithImageSupport : public FakeGLES2Interface {
+ public:
+  GLuint CreateImageCHROMIUM(ClientBuffer, GLsizei, GLsizei, GLenum) override {
+    return ++m_createImageCount;
+  }
+  void DestroyImageCHROMIUM(GLuint) override { ++m_destroyImageCount; }
+
+  GLuint createImageCount() { return m_createImageCount; }
+  GLuint destroyImageCount() { return m_destroyImageCount; }
+
+ private:
+  GLuint m_createImageCount = 0;
+  GLuint m_destroyImageCount = 0;
+};
+
+class FakePlatformSupport : public TestingPlatformSupport {
+  gpu::GpuMemoryBufferManager* getGpuMemoryBufferManager() override {
+    return &m_testGpuMemoryBufferManager;
+  }
+
+ private:
+  cc::TestGpuMemoryBufferManager m_testGpuMemoryBufferManager;
+};
+
 }  // anonymous namespace
 
 class Canvas2DLayerBridgeTest : public Test {
  public:
   PassRefPtr<Canvas2DLayerBridge> makeBridge(
       std::unique_ptr<FakeWebGraphicsContext3DProvider> provider,
       const IntSize& size,
       Canvas2DLayerBridge::AccelerationMode accelerationMode) {
     RefPtr<Canvas2DLayerBridge> bridge = adoptRef(
         new Canvas2DLayerBridge(std::move(provider), size, 0, NonOpaque,
@@ skipping 1111 matching lines @@
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
   EXPECT_FALSE(
       bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback));
   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);
 }
 
+#if USE_IOSURFACE_FOR_2D_CANVAS
+TEST_F(Canvas2DLayerBridgeTest, DeleteIOSurfaceAfterTeardown)
+#else
+TEST_F(Canvas2DLayerBridgeTest, DISABLED_DeleteIOSurfaceAfterTeardown)
+#endif
+{
+  FakeGLES2InterfaceWithImageSupport gl;
+  FakePlatformSupport testingPlatformSupport;
+  std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider =
+      wrapUnique(new FakeWebGraphicsContext3DProvider(&gl));
+
+  cc::TextureMailbox textureMailbox;
+  std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
+
+  {
+    Canvas2DLayerBridgePtr bridge(adoptRef(new Canvas2DLayerBridge(
+        std::move(contextProvider), IntSize(300, 150), 0, NonOpaque,
+        Canvas2DLayerBridge::ForceAccelerationForTesting, nullptr,
+        kN32_SkColorType)));
+    bridge->PrepareTextureMailbox(&textureMailbox, &releaseCallback);
+  }
+
+  bool lostResource = false;
+  releaseCallback->Run(gpu::SyncToken(), lostResource);
+
+  EXPECT_EQ(1u, gl.createImageCount());
+  EXPECT_EQ(1u, gl.destroyImageCount());
+}
+
 }  // namespace blink