Cleanup namespace usage in platform/graphics/[G-S]*

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"
@@ skipping 23 matching lines @@
     { }
 
     virtual ~FakeImageBufferClient() { }
 
     // ImageBufferClient implementation
     virtual void notifySurfaceInvalid() { }
     virtual bool isDirty() { return m_isDirty; };
     virtual void didFinalizeFrame()
     {
         if (m_isDirty) {
-            blink::Platform::current()->currentThread()->removeTaskObserver(this);
+            Platform::current()->currentThread()->removeTaskObserver(this);
             m_isDirty = false;
         }
         ++m_frameCount;
     }
 
     // TaskObserver implementation
     virtual void willProcessTask() OVERRIDE { ASSERT_NOT_REACHED(); }
     virtual void didProcessTask() OVERRIDE
     {
         ASSERT_TRUE(m_isDirty);
         m_imageBuffer->finalizeFrame();
         ASSERT_FALSE(m_isDirty);
     }
 
     void fakeDraw()
     {
         if (m_isDirty)
             return;
         m_isDirty = true;
-        blink::Platform::current()->currentThread()->addTaskObserver(this);
+        Platform::current()->currentThread()->addTaskObserver(this);
     }
 
     int frameCount() { return m_frameCount; }
 
 private:
     bool m_isDirty;
     ImageBuffer* m_imageBuffer;
     int m_frameCount;
 };
 
@@ skipping 131 matching lines @@
 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
 // the single task.
 class AutoInstallCurrentThreadPlatformMock {
 public:
     AutoInstallCurrentThreadPlatformMock()
     {
-        m_oldPlatform = blink::Platform::current();
-        blink::Platform::initialize(&m_mockPlatform);
+        m_oldPlatform = Platform::current();
+        Platform::initialize(&m_mockPlatform);
     }
 
     ~AutoInstallCurrentThreadPlatformMock()
     {
-        blink::Platform::initialize(m_oldPlatform);
+        Platform::initialize(m_oldPlatform);
     }
 
 private:
     class CurrentThreadMock : public WebThread {
     public:
         CurrentThreadMock() : m_taskObserver(0), m_task(0) { }
 
         virtual ~CurrentThreadMock()
         {
             EXPECT_EQ((Task*)0, m_task);
@@ skipping 34 matching lines @@
                 m_taskObserver->didProcessTask();
         }
 
         virtual void exitRunLoop() OVERRIDE { ASSERT_NOT_REACHED(); }
 
     private:
         TaskObserver* m_taskObserver;
         Task* m_task;
     };
 
-    class CurrentThreadPlatformMock : public blink::Platform {
+    class CurrentThreadPlatformMock : public Platform {
     public:
         CurrentThreadPlatformMock() { }
         virtual void cryptographicallyRandomValues(unsigned char* buffer, size_t length) { ASSERT_NOT_REACHED(); }
         virtual WebThread* currentThread() OVERRIDE { return &m_currentThread; }
     private:
         CurrentThreadMock m_currentThread;
     };
 
     CurrentThreadPlatformMock m_mockPlatform;
-    blink::Platform* m_oldPlatform;
+    Platform* m_oldPlatform;
 };
 
 
 #define DEFINE_TEST_TASK_WRAPPER_CLASS(TEST_METHOD)                                               \
-class TestWrapperTask_ ## TEST_METHOD : public blink::WebThread::Task {                           \
+class TestWrapperTask_ ## TEST_METHOD : public WebThread::Task {                           \
     public:                                                                                       \
         TestWrapperTask_ ## TEST_METHOD(RecordingImageBufferSurfaceTest* test) : m_test(test) { } \
         virtual void run() OVERRIDE { m_test->TEST_METHOD(); }                                    \
     private:                                                                                      \
         RecordingImageBufferSurfaceTest* m_test;                                                  \
 };
 
 #define CALL_TEST_TASK_WRAPPER(TEST_METHOD)                                                               \
     {                                                                                                     \
         AutoInstallCurrentThreadPlatformMock ctpm;                                                        \
-        blink::Platform::current()->currentThread()->postTask(new TestWrapperTask_ ## TEST_METHOD(this)); \
-        blink::Platform::current()->currentThread()->enterRunLoop();                                      \
+        Platform::current()->currentThread()->postTask(new TestWrapperTask_ ## TEST_METHOD(this)); \
+        Platform::current()->currentThread()->enterRunLoop();                                      \
     }
 
 TEST_F(RecordingImageBufferSurfaceTest, testEmptyPicture)
 {
     testEmptyPicture();
 }
 
 TEST_F(RecordingImageBufferSurfaceTest, testNoFallbackWithClear)
 {
     testNoFallbackWithClear();
@@ skipping 31 matching lines @@
 }
 
 DEFINE_TEST_TASK_WRAPPER_CLASS(testClearRect)
 TEST_F(RecordingImageBufferSurfaceTest, testClearRect)
 {
     CALL_TEST_TASK_WRAPPER(testClearRect);
     expectDisplayListEnabled(true);
 }
 
 } // namespace