src/third_party/WebKit/Source/platform/graphics/Canvas2DLayerManagerTest.cpp

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1.  Redistributions of source code must retain the above copyright
   8  *     notice, this list of conditions and the following disclaimer.
   9  * 2.  Redistributions in binary form must reproduce the above copyright
  10  *     notice, this list of conditions and the following disclaimer in the
  11  *     documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "config.h"
  26
  27 #include "platform/graphics/Canvas2DLayerManager.h"
  28
  29 #include "SkDevice.h"
  30 #include "SkSurface.h"
  31 #include "platform/graphics/test/MockWebGraphicsContext3D.h"
  32 #include "public/platform/Platform.h"
  33 #include "public/platform/WebGraphicsContext3DProvider.h"
  34 #include "public/platform/WebThread.h"
  35
  36 #include <gmock/gmock.h>
  37 #include <gtest/gtest.h>
  38
  39 using namespace blink;
  40 using testing::InSequence;
  41 using testing::Return;
  42 using testing::Test;
  43
  44 namespace {
  45
  46 class MockWebGraphicsContext3DProvider : public WebGraphicsContext3DProvider {
  47 public:
  48     MockWebGraphicsContext3DProvider(WebGraphicsContext3D* context3d)
  49         : m_context3d(context3d) { }
  50
  51     WebGraphicsContext3D* context3d()
  52     {
  53         return m_context3d;
  54     }
  55
  56     GrContext* grContext()
  57     {
  58         return 0;
  59     }
  60
  61 private:
  62     WebGraphicsContext3D* m_context3d;
  63 };
  64
  65 class FakeCanvas2DLayerBridge : public Canvas2DLayerBridge {
  66 public:
  67     FakeCanvas2DLayerBridge(WebGraphicsContext3D* context, PassOwnPtr<SkDeferredCanvas> canvas, PassRefPtr<SkSurface> surface)
  68         : Canvas2DLayerBridge(adoptPtr(new MockWebGraphicsContext3DProvider(context)), canvas, surface, 0, NonOpaque)
  69         , m_freeableBytes(0)
  70         , m_freeMemoryIfPossibleCount(0)
  71         , m_flushCount(0)
  72     {
  73     }
  74
  75     virtual size_t storageAllocatedForRecording() OVERRIDE
  76     {
  77         // Because the fake layer has no canvas to query, just
  78         // return status quo. Allocation changes that would normally be
  79         // initiated by the canvas can be faked by invoking
  80         // storageAllocatedForRecordingChanged directly from the test code.
  81         return m_bytesAllocated;
  82     }
  83
  84     void fakeFreeableBytes(size_t size)
  85     {
  86         m_freeableBytes = size;
  87     }
  88
  89     virtual size_t freeMemoryIfPossible(size_t size) OVERRIDE
  90     {
  91         m_freeMemoryIfPossibleCount++;
  92         size_t bytesFreed = size < m_freeableBytes ? size : m_freeableBytes;
  93         m_freeableBytes -= bytesFreed;
  94         if (bytesFreed)
  95             storageAllocatedForRecordingChanged(m_bytesAllocated - bytesFreed);
  96         return bytesFreed;
  97     }
  98
  99     virtual void flush() OVERRIDE
 100     {
 101         flushedDrawCommands();
 102         m_freeableBytes = bytesAllocated();
 103         m_flushCount++;
 104     }
 105
 106 public:
 107     size_t m_freeableBytes;
 108     int m_freeMemoryIfPossibleCount;
 109     int m_flushCount;
 110 };
 111
 112 class FakeCanvas2DLayerBridgePtr {
 113 public:
 114     FakeCanvas2DLayerBridgePtr(PassRefPtr<FakeCanvas2DLayerBridge> layerBridge)
 115         : m_layerBridge(layerBridge) { }
 116
 117     ~FakeCanvas2DLayerBridgePtr()
 118     {
 119         m_layerBridge->beginDestruction();
 120     }
 121
 122     FakeCanvas2DLayerBridge* operator->() { return m_layerBridge.get(); }
 123     FakeCanvas2DLayerBridge* get() { return m_layerBridge.get(); }
 124
 125 private:
 126     RefPtr<FakeCanvas2DLayerBridge> m_layerBridge;
 127 };
 128
 129 } // unnamed namespace
 130
 131 class Canvas2DLayerManagerTest : public Test {
 132 protected:
 133     void storageAllocationTrackingTest()
 134     {
 135         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
 136         manager.init(10, 10);
 137         {
 138             OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
 139             RefPtr<SkSurface> surface1 = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 140             OwnPtr<SkDeferredCanvas> canvas1 = adoptPtr(SkDeferredCanvas::Create(surface1.get()));
 141             FakeCanvas2DLayerBridgePtr layer1(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas1.release(), surface1.release())));
 142             EXPECT_EQ((size_t)0, manager.m_bytesAllocated);
 143             layer1->storageAllocatedForRecordingChanged(1);
 144             EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
 145             // Test allocation increase
 146             layer1->storageAllocatedForRecordingChanged(2);
 147             EXPECT_EQ((size_t)2, manager.m_bytesAllocated);
 148             // Test allocation decrease
 149             layer1->storageAllocatedForRecordingChanged(1);
 150             EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
 151             {
 152                 RefPtr<SkSurface> surface2 = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 153                 OwnPtr<SkDeferredCanvas> canvas2 = adoptPtr(SkDeferredCanvas::Create(surface2.get()));
 154                 FakeCanvas2DLayerBridgePtr layer2(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas2.release(), surface2.release())));
 155                 EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
 156                 // verify multi-layer allocation tracking
 157                 layer2->storageAllocatedForRecordingChanged(2);
 158                 EXPECT_EQ((size_t)3, manager.m_bytesAllocated);
 159             }
 160             // Verify tracking after destruction
 161             EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
 162         }
 163     }
 164
 165     void evictionTest()
 166     {
 167         OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
 168         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
 169         manager.init(10, 5);
 170         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 171         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
 172         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
 173         layer->fakeFreeableBytes(10);
 174         layer->storageAllocatedForRecordingChanged(8); // under the max
 175         EXPECT_EQ(0, layer->m_freeMemoryIfPossibleCount);
 176         layer->storageAllocatedForRecordingChanged(12); // over the max
 177         EXPECT_EQ(1, layer->m_freeMemoryIfPossibleCount);
 178         EXPECT_EQ((size_t)3, layer->m_freeableBytes);
 179         EXPECT_EQ(0, layer->m_flushCount); // eviction succeeded without triggering a flush
 180         EXPECT_EQ((size_t)5, layer->bytesAllocated());
 181     }
 182
 183     void hiddenCanvasTest()
 184     {
 185         OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
 186         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
 187         manager.init(20, 5);
 188         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 189         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
 190         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
 191         layer->fakeFreeableBytes(5);
 192         layer->storageAllocatedForRecordingChanged(10);
 193         EXPECT_EQ(0, layer->m_freeMemoryIfPossibleCount);
 194         EXPECT_EQ(0, layer->m_flushCount);
 195         EXPECT_EQ((size_t)10, layer->bytesAllocated());
 196         layer->setIsHidden(true);
 197         EXPECT_EQ(1, layer->m_freeMemoryIfPossibleCount);
 198         EXPECT_EQ((size_t)0, layer->m_freeableBytes);
 199         EXPECT_EQ((size_t)0, layer->bytesAllocated());
 200         EXPECT_EQ(1, layer->m_flushCount);
 201     }
 202
 203     void addRemoveLayerTest()
 204     {
 205         OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
 206         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
 207         manager.init(10, 5);
 208         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 209         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
 210         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
 211         EXPECT_FALSE(manager.isInList(layer.get()));
 212         layer->storageAllocatedForRecordingChanged(5);
 213         EXPECT_TRUE(manager.isInList(layer.get()));
 214         layer->storageAllocatedForRecordingChanged(0);
 215         EXPECT_FALSE(manager.isInList(layer.get()));
 216     }
 217
 218     void flushEvictionTest()
 219     {
 220         OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
 221         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
 222         manager.init(10, 5);
 223         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 224         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
 225         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
 226         layer->fakeFreeableBytes(1); // Not enough freeable bytes, will cause aggressive eviction by flushing
 227         layer->storageAllocatedForRecordingChanged(8); // under the max
 228         EXPECT_EQ(0, layer->m_freeMemoryIfPossibleCount);
 229         layer->storageAllocatedForRecordingChanged(12); // over the max
 230         EXPECT_EQ(2, layer->m_freeMemoryIfPossibleCount); // Two tries, one before flush, one after flush
 231         EXPECT_EQ((size_t)5, layer->m_freeableBytes);
 232         EXPECT_EQ(1, layer->m_flushCount); // flush was attempted
 233         EXPECT_EQ((size_t)5, layer->bytesAllocated());
 234         EXPECT_TRUE(manager.isInList(layer.get()));
 235     }
 236
 237     void doDeferredFrameTestTask(FakeCanvas2DLayerBridge* layer, bool skipCommands)
 238     {
 239         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
 240         layer->finalizeFrame();
 241         layer->storageAllocatedForRecordingChanged(1);
 242         EXPECT_TRUE(Canvas2DLayerManager::get().m_taskObserverActive);
 243         if (skipCommands) {
 244             layer->finalizeFrame();
 245             layer->skippedPendingDrawCommands();
 246         }
 247         Platform::current()->currentThread()->exitRunLoop();
 248     }
 249
 250     class DeferredFrameTestTask : public WebThread::Task {
 251     public:
 252         DeferredFrameTestTask(Canvas2DLayerManagerTest* test, FakeCanvas2DLayerBridge* layer, bool skipCommands)
 253         {
 254             m_test = test;
 255             m_layer = layer;
 256             m_skipCommands = skipCommands;
 257         }
 258
 259         virtual void run() OVERRIDE
 260         {
 261             m_test->doDeferredFrameTestTask(m_layer, m_skipCommands);
 262         }
 263     private:
 264         Canvas2DLayerManagerTest* m_test;
 265         FakeCanvas2DLayerBridge* m_layer;
 266         bool m_skipCommands;
 267     };
 268
 269     void deferredFrameTest()
 270     {
 271         OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
 272         Canvas2DLayerManager::get().init(10, 10);
 273         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
 274         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
 275         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
 276         Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
 277         Platform::current()->currentThread()->enterRunLoop();
 278         // Verify that didProcessTask was called upon completion
 279         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
 280         // Verify that no flush was performed because frame is fresh
 281         EXPECT_EQ(0, layer->m_flushCount);
 282
 283         // Verify that no flushes are triggered as long as frame are fresh
 284         Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
 285         Platform::current()->currentThread()->enterRunLoop();
 286         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
 287         EXPECT_EQ(0, layer->m_flushCount);
 288
 289         Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
 290         Platform::current()->currentThread()->enterRunLoop();
 291         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
 292         EXPECT_EQ(0, layer->m_flushCount);
 293
 294         // Verify that a flush is triggered when queue is accumulating a multi-frame backlog.
 295         Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), false));
 296         Platform::current()->currentThread()->enterRunLoop();
 297         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
 298         EXPECT_EQ(1, layer->m_flushCount);
 299
 300         Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), false));
 301         Platform::current()->currentThread()->enterRunLoop();
 302         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
 303         EXPECT_EQ(2, layer->m_flushCount);
 304     }
 305 };
 306
 307 namespace {
 308
 309 TEST_F(Canvas2DLayerManagerTest, testStorageAllocationTracking)
 310 {
 311     storageAllocationTrackingTest();
 312 }
 313
 314 TEST_F(Canvas2DLayerManagerTest, testEviction)
 315 {
 316     evictionTest();
 317 }
 318
 319 TEST_F(Canvas2DLayerManagerTest, testFlushEviction)
 320 {
 321     flushEvictionTest();
 322 }
 323
 324 TEST_F(Canvas2DLayerManagerTest, testDeferredFrame)
 325 {
 326     deferredFrameTest();
 327 }
 328
 329 TEST_F(Canvas2DLayerManagerTest, testHiddenCanvas)
 330 {
 331     hiddenCanvasTest();
 332 }
 333
 334 TEST_F(Canvas2DLayerManagerTest, testAddRemoveLayer)
 335 {
 336     addRemoveLayerTest();
 337 }
 338
 339 } // unnamed namespace
 340