Merged GraphicsContext3DPrivate into GraphicsContext3D

Source/WebKit/chromium/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
@@ skipping 12 matching lines @@
  */
 
 #include "config.h"
 
 #include "core/platform/graphics/chromium/Canvas2DLayerManager.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include "FakeWebGraphicsContext3D.h"
 #include "SkDevice.h"
-#include "core/platform/chromium/support/GraphicsContext3DPrivate.h"
+#include "core/platform/graphics/GraphicsContext3D.h"
 #include <public/Platform.h>
 #include <public/WebThread.h>
 
 using namespace WebCore;
 using testing::InSequence;
 using testing::Return;
 using testing::Test;
 
 
 class FakeCanvas2DLayerBridge : public Canvas2DLayerBridge {
@@ skipping 48 matching lines @@
     return adoptPtr(new SkDeferredCanvas(device.get()));
 }
 
 class Canvas2DLayerManagerTest : public Test {
 protected:
     void storageAllocationTrackingTest()
     {
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 10);
         {
-            RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
+            RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
             OwnPtr<SkDeferredCanvas> canvas1 = createCanvas(context.get());
             FakeCanvas2DLayerBridge layer1(context, canvas1.get());
             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);
             {
                 OwnPtr<SkDeferredCanvas> canvas2 = createCanvas(context.get());
                 FakeCanvas2DLayerBridge layer2(context, canvas2.get());
                 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 = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
+        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         OwnPtr<SkDeferredCanvas> canvas = createCanvas(context.get());
         FakeCanvas2DLayerBridge layer(context, canvas.get());
         layer.fakeFreeableBytes(10);
         layer.storageAllocatedForRecordingChanged(8); // under the max
         EXPECT_EQ(0, layer.m_freeMemoryIfPossibleCount);
         layer.storageAllocatedForRecordingChanged(12); // over the max
         EXPECT_EQ(1, layer.m_freeMemoryIfPossibleCount);
         EXPECT_EQ((size_t)3, layer.m_freeableBytes);
         EXPECT_EQ(0, layer.m_flushCount); // eviction succeeded without triggering a flush
         EXPECT_EQ((size_t)5, layer.bytesAllocated());
     }
 
     void flushEvictionTest()
     {
-        RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
+        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         OwnPtr<SkDeferredCanvas> canvas = createCanvas(context.get());
         FakeCanvas2DLayerBridge layer(context, canvas.get());
         layer.fakeFreeableBytes(1); // Not enough freeable bytes, will cause aggressive eviction by flushing
         layer.storageAllocatedForRecordingChanged(8); // under the max
         EXPECT_EQ(0, layer.m_freeMemoryIfPossibleCount);
         layer.storageAllocatedForRecordingChanged(12); // over the max
         EXPECT_EQ(2, layer.m_freeMemoryIfPossibleCount); // Two tries, one before flush, one after flush
         EXPECT_EQ((size_t)0, 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 = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
+        RefPtr<GraphicsContext3D> context = GraphicsContext3D::createGraphicsContextFromWebContext(adoptPtr(new WebKit::FakeWebGraphicsContext3D));
         Canvas2DLayerManager::get().init(10, 10);
         OwnPtr<SkDeferredCanvas> canvas = createCanvas(context.get());
         FakeCanvas2DLayerBridge fakeLayer(context, canvas.get());
         WebKit::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, &fakeLayer, true));
         WebKit::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, fakeLayer.m_flushCount);
 
@@ skipping 48 matching lines @@
     flushEvictionTest();
 }
 
 TEST_F(Canvas2DLayerManagerTest, testDeferredFrame)
 {
     deferredFrameTest();
 }
 
 } // namespace