cc: Unify namespaces for all test files

cc/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/layer_tree_host.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/layer_impl.h"
@@ skipping 12 matching lines @@
 #include "cc/timing_function.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 #include <public/WebLayerScrollClient.h>
 #include <public/WebSize.h>
 
-using namespace WebKit;
-using namespace WebKitTests;
-
 namespace cc {
 namespace {
 
 class LayerTreeHostTest : public ThreadedTest { };
 
 // Shortlived layerTreeHosts shouldn't die.
 class LayerTreeHostTestShortlived1 : public LayerTreeHostTest {
 public:
     LayerTreeHostTestShortlived1() { }
 
@@ skipping 1805 matching lines @@
         child->setMasksToBounds(true);
 
         // If the child layer has a filter that changes alpha values, and is below child2, then child2 should contribute to occlusion on everything,
         // and child shouldn't contribute to the rootLayer
         setTestLayerPropertiesForTesting(rootLayer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(200, 200), true);
         setTestLayerPropertiesForTesting(child.get(), rootLayer.get(), childTransform, gfx::PointF(0, 0), gfx::PointF(30, 30), gfx::Size(500, 500), true);
         setTestLayerPropertiesForTesting(grandChild.get(), child.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 10), gfx::Size(500, 500), true);
         setTestLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 70), gfx::Size(500, 500), true);
 
         {
-            WebFilterOperations filters;
-            filters.append(WebFilterOperation::createOpacityFilter(0.5));
+            WebKit::WebFilterOperations filters;
+            filters.append(WebKit::WebFilterOperation::createOpacityFilter(0.5));
             child->setFilters(filters);
         }
 
         m_layerTreeHost->setRootLayer(rootLayer);
         m_layerTreeHost->setViewportSize(rootLayer->bounds(), rootLayer->bounds());
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
         ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         m_layerTreeHost->commitComplete();
 
         EXPECT_EQ(gfx::Rect().ToString(), child2->occludedScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect(10, 70, 190, 130).ToString(), grandChild->occludedScreenSpace().ToString());
         EXPECT_EQ(UnionRegions(gfx::Rect(30, 40, 170, 30), gfx::Rect(10, 70, 190, 130)).ToString(), child->occludedScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect(10, 70, 190, 130).ToString(), rootLayer->occludedScreenSpace().ToString());
 
         // If the child layer has a filter that moves pixels/changes alpha, and is below child2, then child should not inherit occlusion from outside its subtree,
         // and should not contribute to the rootLayer
         setTestLayerPropertiesForTesting(rootLayer.get(), 0, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(200, 200), true);
         setTestLayerPropertiesForTesting(child.get(), rootLayer.get(), childTransform, gfx::PointF(0, 0), gfx::PointF(30, 30), gfx::Size(500, 500), true);
         setTestLayerPropertiesForTesting(grandChild.get(), child.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 10), gfx::Size(500, 500), true);
         setTestLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(10, 70), gfx::Size(500, 500), true);
 
         {
-            WebFilterOperations filters;
-            filters.append(WebFilterOperation::createBlurFilter(10));
+            WebKit::WebFilterOperations filters;
+            filters.append(WebKit::WebFilterOperation::createBlurFilter(10));
             child->setFilters(filters);
         }
 
         m_layerTreeHost->setRootLayer(rootLayer);
         m_layerTreeHost->setViewportSize(rootLayer->bounds(), rootLayer->bounds());
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         m_layerTreeHost->commitComplete();
 
         EXPECT_EQ(gfx::Rect().ToString(), child2->occludedScreenSpace().ToString());
         EXPECT_EQ(gfx::Rect().ToString(), grandChild->occludedScreenSpace().ToString());
@@ skipping 278 matching lines @@
     }
 
     virtual void afterTest() OVERRIDE { }
 
 private:
     bool m_addedAnimation;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLayerAddedWithAnimation)
 
-class LayerTreeHostTestScrollChildLayer : public LayerTreeHostTest, public WebLayerScrollClient {
+class LayerTreeHostTestScrollChildLayer : public LayerTreeHostTest, public WebKit::WebLayerScrollClient {
 public:
     LayerTreeHostTestScrollChildLayer(float deviceScaleFactor)
         : m_deviceScaleFactor(deviceScaleFactor)
         , m_initialScroll(10, 20)
         , m_secondScroll(40, 5)
         , m_scrollAmount(2, -1)
         , m_rootScrolls(0)
     {
     }
 
@@ skipping 720 matching lines @@
 
 private:
     FakeContentLayerClient m_client;
     scoped_refptr<EvictionTestLayer> m_layer;
     LayerTreeHostImpl* m_implForEvictTextures;
     int m_numCommits;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLostContextAfterEvictTextures)
 
-class CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext : public WebKit::CompositorFakeWebGraphicsContext3D {
+class CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext : public CompositorFakeWebGraphicsContext3D {
 public:
     static scoped_ptr<CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext> create(Attributes attrs)
     {
         return make_scoped_ptr(new CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext(attrs));
     }
 
     virtual void setContextLostCallback(WebGraphicsContextLostCallback* callback) { m_contextLostCallback = callback; }
     virtual bool isContextLost() { return m_isContextLost; }
 
-    virtual void beginQueryEXT(WGC3Denum, WebGLId) { }
-    virtual void endQueryEXT(WGC3Denum)
+    virtual void beginQueryEXT(WebKit::WGC3Denum, WebKit::WebGLId) { }
+    virtual void endQueryEXT(WebKit::WGC3Denum)
     {
         // Lose context.
         if (!m_isContextLost) {
             m_contextLostCallback->onContextLost();
             m_isContextLost = true;
         }
     }
-    virtual void getQueryObjectuivEXT(WebGLId, WGC3Denum pname, WGC3Duint* params)
+    virtual void getQueryObjectuivEXT(WebKit::WebGLId, WebKit::WGC3Denum pname, WebKit::WGC3Duint* params)
     {
         // Context is lost. We need to behave as if result is available.
         if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
             *params = 1;
     }
 
 private:
     explicit CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext(Attributes attrs)
         : CompositorFakeWebGraphicsContext3D(attrs)
         , m_contextLostCallback(0)
@@ skipping 431 matching lines @@
     LayerTreeSettings settings;
     settings.maxPartialTextureUpdates = 4;
 
     scoped_ptr<LayerTreeHost> host = LayerTreeHost::create(&client, settings, scoped_ptr<Thread>());
     EXPECT_TRUE(host->initializeRendererIfNeeded());
     EXPECT_EQ(0u, host->settings().maxPartialTextureUpdates);
 }
 
 }  // namespace
 }  // namespace cc