Cleanup namespace usage in platform/graphics/[filters/* to skia/*] and platform/graphics/[B-D]*

Source/platform/graphics/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 25 matching lines @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using namespace blink;
 using testing::InSequence;
 using testing::Return;
 using testing::Test;
 
 namespace {
 
-class MockWebGraphicsContext3DProvider : public blink::WebGraphicsContext3DProvider {
+class MockWebGraphicsContext3DProvider : public WebGraphicsContext3DProvider {
 public:
-    MockWebGraphicsContext3DProvider(blink::WebGraphicsContext3D* context3d)
+    MockWebGraphicsContext3DProvider(WebGraphicsContext3D* context3d)
         : m_context3d(context3d) { }
 
-    blink::WebGraphicsContext3D* context3d()
+    WebGraphicsContext3D* context3d()
     {
         return m_context3d;
     }
 
     GrContext* grContext()
     {
         return 0;
     }
 
 private:
-    blink::WebGraphicsContext3D* m_context3d;
+    WebGraphicsContext3D* m_context3d;
 };
 
 class FakeCanvas2DLayerBridge : public Canvas2DLayerBridge {
 public:
-    FakeCanvas2DLayerBridge(blink::WebGraphicsContext3D* context, PassOwnPtr<SkDeferredCanvas> canvas, PassRefPtr<SkSurface> surface)
+    FakeCanvas2DLayerBridge(WebGraphicsContext3D* context, PassOwnPtr<SkDeferredCanvas> canvas, PassRefPtr<SkSurface> surface)
         : Canvas2DLayerBridge(adoptPtr(new MockWebGraphicsContext3DProvider(context)), canvas, surface, 0, NonOpaque)
         , m_freeableBytes(0)
         , m_freeMemoryIfPossibleCount(0)
         , m_flushCount(0)
     {
     }
 
     virtual size_t storageAllocatedForRecording() OVERRIDE
     {
         // Because the fake layer has no canvas to query, just
@@ skipping 50 matching lines @@
 
 } // unnamed namespace
 
 class Canvas2DLayerManagerTest : public Test {
 protected:
     void storageAllocationTrackingTest()
     {
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 10);
         {
-            OwnPtr<blink::MockWebGraphicsContext3D> webContext = adoptPtr(new blink::MockWebGraphicsContext3D);
+            OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
             RefPtr<SkSurface> surface1 = adoptRef(SkSurface::NewRasterPMColor(1, 1));
             OwnPtr<SkDeferredCanvas> canvas1 = adoptPtr(SkDeferredCanvas::Create(surface1.get()));
             FakeCanvas2DLayerBridgePtr layer1(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas1.release(), surface1.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<SkSurface> surface2 = adoptRef(SkSurface::NewRasterPMColor(1, 1));
                 OwnPtr<SkDeferredCanvas> canvas2 = adoptPtr(SkDeferredCanvas::Create(surface2.get()));
                 FakeCanvas2DLayerBridgePtr layer2(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas2.release(), surface2.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()
     {
-        OwnPtr<blink::MockWebGraphicsContext3D> webContext = adoptPtr(new blink::MockWebGraphicsContext3D);
+        OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
         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 hiddenCanvasTest()
     {
-        OwnPtr<blink::MockWebGraphicsContext3D> webContext = adoptPtr(new blink::MockWebGraphicsContext3D);
+        OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(20, 5);
         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
         layer->fakeFreeableBytes(5);
         layer->storageAllocatedForRecordingChanged(10);
         EXPECT_EQ(0, layer->m_freeMemoryIfPossibleCount);
         EXPECT_EQ(0, layer->m_flushCount);
         EXPECT_EQ((size_t)10, layer->bytesAllocated());
         layer->setIsHidden(true);
         EXPECT_EQ(1, layer->m_freeMemoryIfPossibleCount);
         EXPECT_EQ((size_t)0, layer->m_freeableBytes);
         EXPECT_EQ((size_t)0, layer->bytesAllocated());
         EXPECT_EQ(1, layer->m_flushCount);
     }
 
     void addRemoveLayerTest()
     {
-        OwnPtr<blink::MockWebGraphicsContext3D> webContext = adoptPtr(new blink::MockWebGraphicsContext3D);
+        OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
         EXPECT_FALSE(manager.isInList(layer.get()));
         layer->storageAllocatedForRecordingChanged(5);
         EXPECT_TRUE(manager.isInList(layer.get()));
         layer->storageAllocatedForRecordingChanged(0);
         EXPECT_FALSE(manager.isInList(layer.get()));
     }
 
     void flushEvictionTest()
     {
-        OwnPtr<blink::MockWebGraphicsContext3D> webContext = adoptPtr(new blink::MockWebGraphicsContext3D);
+        OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
         Canvas2DLayerManager& manager = Canvas2DLayerManager::get();
         manager.init(10, 5);
         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
         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)5, layer->m_freeableBytes);
         EXPECT_EQ(1, layer->m_flushCount); // flush was attempted
         EXPECT_EQ((size_t)5, layer->bytesAllocated());
         EXPECT_TRUE(manager.isInList(layer.get()));
     }
 
     void doDeferredFrameTestTask(FakeCanvas2DLayerBridge* layer, bool skipCommands)
     {
         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
         layer->finalizeFrame();
         layer->storageAllocatedForRecordingChanged(1);
         EXPECT_TRUE(Canvas2DLayerManager::get().m_taskObserverActive);
         if (skipCommands) {
             layer->finalizeFrame();
             layer->skippedPendingDrawCommands();
         }
-        blink::Platform::current()->currentThread()->exitRunLoop();
+        Platform::current()->currentThread()->exitRunLoop();
     }
 
-    class DeferredFrameTestTask : public blink::WebThread::Task {
+    class DeferredFrameTestTask : public WebThread::Task {
     public:
         DeferredFrameTestTask(Canvas2DLayerManagerTest* test, FakeCanvas2DLayerBridge* layer, bool skipCommands)
         {
             m_test = test;
             m_layer = layer;
             m_skipCommands = skipCommands;
         }
 
         virtual void run() OVERRIDE
         {
             m_test->doDeferredFrameTestTask(m_layer, m_skipCommands);
         }
     private:
         Canvas2DLayerManagerTest* m_test;
         FakeCanvas2DLayerBridge* m_layer;
         bool m_skipCommands;
     };
 
     void deferredFrameTest()
     {
-        OwnPtr<blink::MockWebGraphicsContext3D> webContext = adoptPtr(new blink::MockWebGraphicsContext3D);
+        OwnPtr<MockWebGraphicsContext3D> webContext = adoptPtr(new MockWebGraphicsContext3D);
         Canvas2DLayerManager::get().init(10, 10);
         RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterPMColor(1, 1));
         OwnPtr<SkDeferredCanvas> canvas = adoptPtr(SkDeferredCanvas::Create(surface.get()));
         FakeCanvas2DLayerBridgePtr layer(adoptRef(new FakeCanvas2DLayerBridge(webContext.get(), canvas.release(), surface.release())));
-        blink::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
-        blink::Platform::current()->currentThread()->enterRunLoop();
+        Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
+        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, layer->m_flushCount);
 
         // Verify that no flushes are triggered as long as frame are fresh
-        blink::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
-        blink::Platform::current()->currentThread()->enterRunLoop();
+        Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
+        Platform::current()->currentThread()->enterRunLoop();
         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
         EXPECT_EQ(0, layer->m_flushCount);
 
-        blink::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
-        blink::Platform::current()->currentThread()->enterRunLoop();
+        Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), true));
+        Platform::current()->currentThread()->enterRunLoop();
         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
         EXPECT_EQ(0, layer->m_flushCount);
 
         // Verify that a flush is triggered when queue is accumulating a multi-frame backlog.
-        blink::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), false));
-        blink::Platform::current()->currentThread()->enterRunLoop();
+        Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), false));
+        Platform::current()->currentThread()->enterRunLoop();
         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
         EXPECT_EQ(1, layer->m_flushCount);
 
-        blink::Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), false));
-        blink::Platform::current()->currentThread()->enterRunLoop();
+        Platform::current()->currentThread()->postTask(new DeferredFrameTestTask(this, layer.get(), false));
+        Platform::current()->currentThread()->enterRunLoop();
         EXPECT_FALSE(Canvas2DLayerManager::get().m_taskObserverActive);
         EXPECT_EQ(2, layer->m_flushCount);
     }
 };
 
 namespace {
 
 TEST_F(Canvas2DLayerManagerTest, testStorageAllocationTracking)
 {
     storageAllocationTrackingTest();
@@ skipping 19 matching lines @@
     hiddenCanvasTest();
 }
 
 TEST_F(Canvas2DLayerManagerTest, testAddRemoveLayer)
 {
     addRemoveLayerTest();
 }
 
 } // unnamed namespace