Moving GraphicsContext and dependencies from core to platform.

Source/web/tests/Canvas2DLayerManagerTest.cpp

 /*
  * Copyright (C) 2012 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 "config.h"
 
-#include "core/platform/graphics/Canvas2DLayerManager.h"
+#include "platform/graphics/Canvas2DLayerManager.h"
 
 #include "SkDevice.h"
 #include "SkSurface.h"
-#include "core/platform/graphics/GraphicsContext3D.h"
-#include "core/platform/testing/FakeWebGraphicsContext3D.h"
+#include "platform/graphics/GraphicsContext3D.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
+#include "web/tests/MockWebGraphicsContext3D.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using namespace WebCore;
 using testing::InSequence;
 using testing::Return;
 using testing::Test;
 
 
@@ skipping 54 matching lines @@
     return static_cast<FakeCanvas2DLayerBridge*>(layer.get());
 }
 
 class Canvas2DLayerManagerTest : public Test {
 protected:
     void storageAllocationTrackingTest()
     {
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 10);
         {
-            RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::FakeWebGraphicsContext3D));
+            RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::MockWebGraphicsContext3D));
             RefPtr<SkDeferredCanvas> canvas1(createCanvas(context.get()));
             Canvas2DLayerBridgePtr layer1(adoptRef(new FakeCanvas2DLayerBridge(context, canvas1.release())));
             EXPECT_EQ((size_t)0, manager.m_bytesAllocated);
             layer1->storageAllocatedForRecordingChanged(1);
             EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
             // Test allocation increase
             layer1->storageAllocatedForRecordingChanged(2);
             EXPECT_EQ((size_t)2, manager.m_bytesAllocated);
             // Test allocation decrease
             layer1->storageAllocatedForRecordingChanged(1);
             EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
             {
                 RefPtr<SkDeferredCanvas> canvas2(createCanvas(context.get()));
                 Canvas2DLayerBridgePtr layer2(adoptRef(new FakeCanvas2DLayerBridge(context, canvas2.release())));
                 EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
                 // verify multi-layer allocation tracking
                 layer2->storageAllocatedForRecordingChanged(2);
                 EXPECT_EQ((size_t)3, manager.m_bytesAllocated);
             }
             // Verify tracking after destruction
             EXPECT_EQ((size_t)1, manager.m_bytesAllocated);
         }
     }
 
     void evictionTest()
     {
-        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::FakeWebGraphicsContext3D));
+        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::MockWebGraphicsContext3D));
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         RefPtr<SkDeferredCanvas> canvas(createCanvas(context.get()));
         Canvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(context, canvas.release())));
         fake(layer)->fakeFreeableBytes(10);
         layer->storageAllocatedForRecordingChanged(8); // under the max
         EXPECT_EQ(0, fake(layer)->m_freeMemoryIfPossibleCount);
         layer->storageAllocatedForRecordingChanged(12); // over the max
         EXPECT_EQ(1, fake(layer)->m_freeMemoryIfPossibleCount);
         EXPECT_EQ((size_t)3, fake(layer)->m_freeableBytes);
         EXPECT_EQ(0, fake(layer)->m_flushCount); // eviction succeeded without triggering a flush
         EXPECT_EQ((size_t)5, layer->bytesAllocated());
     }
 
     void flushEvictionTest()
     {
-        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::FakeWebGraphicsContext3D));
+        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::MockWebGraphicsContext3D));
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         RefPtr<SkDeferredCanvas> canvas(createCanvas(context.get()));
         Canvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(context, canvas.release())));
         fake(layer)->fakeFreeableBytes(1); // Not enough freeable bytes, will cause aggressive eviction by flushing
         layer->storageAllocatedForRecordingChanged(8); // under the max
         EXPECT_EQ(0, fake(layer)->m_freeMemoryIfPossibleCount);
         layer->storageAllocatedForRecordingChanged(12); // over the max
         EXPECT_EQ(2, fake(layer)->m_freeMemoryIfPossibleCount); // Two tries, one before flush, one after flush
         EXPECT_EQ((size_t)0, fake(layer)->m_freeableBytes);
@@ skipping 30 matching lines @@
             m_test->doDeferredFrameTestTask(m_layer, m_skipCommands);
         }
     private:
         Canvas2DLayerManagerTest* m_test;
         FakeCanvas2DLayerBridge* m_layer;
         bool m_skipCommands;
     };
 
     void deferredFrameTest()
     {
-        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::FakeWebGraphicsContext3D));
+        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new blink::MockWebGraphicsContext3D));
         Canvas2DLayerManager::get().init(10, 10);
         RefPtr<SkDeferredCanvas> canvas(createCanvas(context.get()));
         Canvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(context, canvas.release())));
         blink::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, fake(layer), true));
         blink::Platform::current()->currentThread()->enterRunLoop();
         // Verify that didProcessTask was called upon completion
         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
         // Verify that no flush was performed because frame is fresh
         EXPECT_EQ(0, fake(layer)->m_flushCount);
 
@@ skipping 38 matching lines @@
     flushEvictionTest();
 }
 
 TEST_F(Canvas2DLayerManagerTest, testDeferredFrame)
 {
     deferredFrameTest();
 }
 
 } // namespace