Making display list canvases fall back to gpu-accelerated when appropriate

Source/platform/graphics/RecordingImageBufferSurfaceTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/ImageBufferClient.h"
+#include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ skipping 44 matching lines @@
     }
 
     int frameCount() { return m_frameCount; }
 
 private:
     bool m_isDirty;
     ImageBuffer* m_imageBuffer;
     int m_frameCount;
 };
 
+class MockSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
+public:
+    MockSurfaceFactory() : m_createSurfaceCount(0) { }
+
+    virtual PassOwnPtr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode opacityMode)
+    {
+        m_createSurfaceCount++;
+        return adoptPtr(new UnacceleratedImageBufferSurface(size, opacityMode));
+    }
+
+    virtual ~MockSurfaceFactory() { }
+
+    int createSurfaceCount() { return m_createSurfaceCount; }
+
+private:
+    int m_createSurfaceCount;
+};
+
 } // unnamed namespace
 
 class RecordingImageBufferSurfaceTest : public Test {
 protected:
     RecordingImageBufferSurfaceTest()
     {
-        OwnPtr<RecordingImageBufferSurface> testSurface = adoptPtr(new RecordingImageBufferSurface(IntSize(10, 10)));
+        OwnPtr<MockSurfaceFactory> surfaceFactory = adoptPtr(new MockSurfaceFactory());
+        m_surfaceFactory = surfaceFactory.get();
+        OwnPtr<RecordingImageBufferSurface> testSurface = adoptPtr(new RecordingImageBufferSurface(IntSize(10, 10), surfaceFactory.release()));
         m_testSurface = testSurface.get();
         // We create an ImageBuffer in order for the testSurface to be
         // properly initialized with a GraphicsContext
         m_imageBuffer = ImageBuffer::create(testSurface.release());
         EXPECT_FALSE(!m_imageBuffer);
         m_fakeImageBufferClient = adoptPtr(new FakeImageBufferClient(m_imageBuffer.get()));
         m_imageBuffer->setClient(m_fakeImageBufferClient.get());
     }
 
 public:
@@ skipping 25 matching lines @@
         EXPECT_EQ(2, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(true);
     }
 
     void testAnimatedWithoutClear()
     {
         m_testSurface->initializeCurrentFrame();
         m_fakeImageBufferClient->fakeDraw();
         m_testSurface->getPicture();
         EXPECT_EQ(1, m_fakeImageBufferClient->frameCount());
+        EXPECT_EQ(0, m_surfaceFactory->createSurfaceCount());
         expectDisplayListEnabled(true); // first frame has an implicit clear
         m_fakeImageBufferClient->fakeDraw();
         m_testSurface->getPicture();
         EXPECT_EQ(2, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(false);
     }
 
     void testFrameFinalizedByTaskObserver1()
     {
         m_testSurface->initializeCurrentFrame();
@@ skipping 10 matching lines @@
         m_fakeImageBufferClient->fakeDraw();
         EXPECT_EQ(2, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(true);
         // Display list will be disabled only after exiting the runLoop
     }
     void testFrameFinalizedByTaskObserver2()
     {
         EXPECT_EQ(3, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(false);
         m_testSurface->getPicture();
-        EXPECT_EQ(4, m_fakeImageBufferClient->frameCount());
+        EXPECT_EQ(3, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(false);
         m_fakeImageBufferClient->fakeDraw();
-        EXPECT_EQ(4, m_fakeImageBufferClient->frameCount());
+        EXPECT_EQ(3, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(false);
     }
 
     void testAnimatedWithClear()
     {
         m_testSurface->initializeCurrentFrame();
         m_testSurface->getPicture();
         m_testSurface->didClearCanvas();
         m_fakeImageBufferClient->fakeDraw();
         EXPECT_EQ(1, m_fakeImageBufferClient->frameCount());
@@ skipping 17 matching lines @@
         m_fakeImageBufferClient->fakeDraw();
         EXPECT_EQ(1, m_fakeImageBufferClient->frameCount());
         m_testSurface->getPicture();
         EXPECT_EQ(2, m_fakeImageBufferClient->frameCount());
         expectDisplayListEnabled(true);
     }
 
     void expectDisplayListEnabled(bool displayListEnabled)
     {
         EXPECT_EQ(displayListEnabled, (bool)m_testSurface->m_currentFrame.get());
-        EXPECT_EQ(!displayListEnabled, (bool)m_testSurface->m_rasterCanvas.get());
+        EXPECT_EQ(!displayListEnabled, (bool)m_testSurface->m_fallbackSurface.get());
+        int expectedSurfaceCreationCount = displayListEnabled ? 0 : 1;
+        EXPECT_EQ(expectedSurfaceCreationCount, m_surfaceFactory->createSurfaceCount());
     }
 
 private:
+    MockSurfaceFactory* m_surfaceFactory;
     RecordingImageBufferSurface* m_testSurface;
     OwnPtr<FakeImageBufferClient> m_fakeImageBufferClient;
     OwnPtr<ImageBuffer> m_imageBuffer;
 };
 
 namespace {
 
 // The following test helper class installs a mock platform that provides a mock WebThread
 // for the current thread. The Mock thread is capable of queuing a single non-delayed task
 // and registering a single task observer. The run loop exits immediately after running
@@ skipping 140 matching lines @@
 }
 
 DEFINE_TEST_TASK_WRAPPER_CLASS(testClearRect)
 TEST_F(RecordingImageBufferSurfaceTest, testClearRect)
 {
     CALL_TEST_TASK_WRAPPER(testClearRect);
     expectDisplayListEnabled(true);
 }
 
 } // namespace