cc: Unify namespaces for all test files

cc/layer_tree_host_impl_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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 #include "cc/video_layer_impl.h"
 #include "media/base/media.h"
 #include "media/base/video_frame.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 #include <public/WebVideoFrame.h>
 #include <public/WebVideoFrameProvider.h>
 
-using namespace LayerTestCommon;
-using namespace WebKit;
-using namespace WebKitTests;
-
 using media::VideoFrame;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::_;
 
 namespace cc {
 namespace {
 
@@ skipping 1544 matching lines @@
 
     // The scale should not have been applied to the scroll delta.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
 class BlendStateTrackerContext: public FakeWebGraphicsContext3D {
 public:
     BlendStateTrackerContext() : m_blend(false) { }
 
-    virtual void enable(WGC3Denum cap)
+    virtual void enable(WebKit::WGC3Denum cap)
     {
         if (cap == GL_BLEND)
             m_blend = true;
     }
 
-    virtual void disable(WGC3Denum cap)
+    virtual void disable(WebKit::WGC3Denum cap)
     {
         if (cap == GL_BLEND)
             m_blend = false;
     }
 
     bool blend() const { return m_blend; }
 
 private:
     bool m_blend;
 };
@@ skipping 277 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
         EXPECT_EQ(0u, numGutterQuads);
         EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
 
-        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
+        LayerTestCommon::verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     // Empty visible content area (fullscreen gutter rect)
     {
         gfx::Rect layerRect(0, 0, 0, 0);
         child->setPosition(layerRect.origin());
         child->setBounds(layerRect.size());
         child->setContentBounds(layerRect.size());
         child->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
         child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
         EXPECT_EQ(1u, numGutterQuads);
         EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
 
-        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
+        LayerTestCommon::verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     // Content area in middle of clip rect (four surrounding gutter rects)
     {
         gfx::Rect layerRect(500, 500, 200, 200);
         child->setPosition(layerRect.origin());
         child->setBounds(layerRect.size());
         child->setContentBounds(layerRect.size());
         child->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
         child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
         EXPECT_EQ(4u, numGutterQuads);
         EXPECT_EQ(5u, frame.renderPasses[0]->quad_list.size());
 
-        verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
+        LayerTestCommon::verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
         m_hostImpl->didDrawAllLayers(frame);
     }
 
 }
 
 
 class ReshapeTrackerContext: public FakeWebGraphicsContext3D {
 public:
     ReshapeTrackerContext() : m_reshapeCalled(false) { }
 
@@ skipping 38 matching lines @@
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 class PartialSwapTrackerContext : public FakeWebGraphicsContext3D {
 public:
     virtual void postSubBufferCHROMIUM(int x, int y, int width, int height)
     {
         m_partialSwapRect = gfx::Rect(x, y, width, height);
     }
 
-    virtual WebString getString(WGC3Denum name)
+    virtual WebKit::WebString getString(WebKit::WGC3Denum name)
     {
         if (name == GL_EXTENSIONS)
-            return WebString("GL_CHROMIUM_post_sub_buffer GL_CHROMIUM_set_visibility");
+            return WebKit::WebString("GL_CHROMIUM_post_sub_buffer GL_CHROMIUM_set_visibility");
 
-        return WebString();
+        return WebKit::WebString();
     }
 
     gfx::Rect partialSwapRect() const { return m_partialSwapRect; }
 
 private:
     gfx::Rect m_partialSwapRect;
 };
 
 // Make sure damage tracking propagates all the way to the graphics context,
 // where it should request to swap only the subBuffer that is damaged.
@@ skipping 89 matching lines @@
     m_hostImpl->setRootLayer(root.Pass());
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     EXPECT_EQ(1u, frame.renderSurfaceLayerList->size());
     EXPECT_EQ(1u, frame.renderPasses.size());
     m_hostImpl->didDrawAllLayers(frame);
 }
 
-} // namespace
-
 class FakeLayerWithQuads : public LayerImpl {
 public:
     static scoped_ptr<LayerImpl> create(LayerTreeImpl* treeImpl, int id) { return scoped_ptr<LayerImpl>(new FakeLayerWithQuads(treeImpl, id)); }
 
     virtual void appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData) OVERRIDE
     {
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
         SkColor gray = SkColorSetRGB(100, 100, 100);
         gfx::Rect quadRect(gfx::Point(0, 0), contentBounds());
         scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::Create();
         myQuad->SetNew(sharedQuadState, quadRect, gray);
         quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
 private:
     FakeLayerWithQuads(LayerTreeImpl* treeImpl, int id)
         : LayerImpl(treeImpl, id)
     {
     }
 };
 
-namespace {
-
 class MockContext : public FakeWebGraphicsContext3D {
 public:
-    MOCK_METHOD1(useProgram, void(WebGLId program));
-    MOCK_METHOD5(uniform4f, void(WGC3Dint location, WGC3Dfloat x, WGC3Dfloat y, WGC3Dfloat z, WGC3Dfloat w));
-    MOCK_METHOD4(uniformMatrix4fv, void(WGC3Dint location, WGC3Dsizei count, WGC3Dboolean transpose, const WGC3Dfloat* value));
-    MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));
-    MOCK_METHOD1(getString, WebString(WGC3Denum name));
-    MOCK_METHOD0(getRequestableExtensionsCHROMIUM, WebString());
-    MOCK_METHOD1(enable, void(WGC3Denum cap));
-    MOCK_METHOD1(disable, void(WGC3Denum cap));
-    MOCK_METHOD4(scissor, void(WGC3Dint x, WGC3Dint y, WGC3Dsizei width, WGC3Dsizei height));
+    MOCK_METHOD1(useProgram, void(WebKit::WebGLId program));
+    MOCK_METHOD5(uniform4f, void(WebKit::WGC3Dint location, WebKit::WGC3Dfloat x, WebKit::WGC3Dfloat y, WebKit::WGC3Dfloat z, WebKit::WGC3Dfloat w));
+    MOCK_METHOD4(uniformMatrix4fv, void(WebKit::WGC3Dint location, WebKit::WGC3Dsizei count, WebKit::WGC3Dboolean transpose, const WebKit::WGC3Dfloat* value));
+    MOCK_METHOD4(drawElements, void(WebKit::WGC3Denum mode, WebKit::WGC3Dsizei count, WebKit::WGC3Denum type, WebKit::WGC3Dintptr offset));
+    MOCK_METHOD1(getString, WebKit::WebString(WebKit::WGC3Denum name));
+    MOCK_METHOD0(getRequestableExtensionsCHROMIUM, WebKit::WebString());
+    MOCK_METHOD1(enable, void(WebKit::WGC3Denum cap));
+    MOCK_METHOD1(disable, void(WebKit::WGC3Denum cap));
+    MOCK_METHOD4(scissor, void(WebKit::WGC3Dint x, WebKit::WGC3Dint y, WebKit::WGC3Dsizei width, WebKit::WGC3Dsizei height));
 };
 
 class MockContextHarness {
 private:
     MockContext* m_context;
 public:
     MockContextHarness(MockContext* context)
         : m_context(context)
     {
         // Catch "uninteresting" calls
         EXPECT_CALL(*m_context, useProgram(_))
             .Times(0);
 
         EXPECT_CALL(*m_context, drawElements(_, _, _, _))
             .Times(0);
 
         // These are not asserted
         EXPECT_CALL(*m_context, uniformMatrix4fv(_, _, _, _))
             .WillRepeatedly(Return());
 
         EXPECT_CALL(*m_context, uniform4f(_, _, _, _, _))
             .WillRepeatedly(Return());
 
         // Any other strings are empty
         EXPECT_CALL(*m_context, getString(_))
-            .WillRepeatedly(Return(WebString()));
+            .WillRepeatedly(Return(WebKit::WebString()));
 
         // Support for partial swap, if needed
         EXPECT_CALL(*m_context, getString(GL_EXTENSIONS))
-            .WillRepeatedly(Return(WebString("GL_CHROMIUM_post_sub_buffer")));
+            .WillRepeatedly(Return(WebKit::WebString("GL_CHROMIUM_post_sub_buffer")));
 
         EXPECT_CALL(*m_context, getRequestableExtensionsCHROMIUM())
-            .WillRepeatedly(Return(WebString("GL_CHROMIUM_post_sub_buffer")));
+            .WillRepeatedly(Return(WebKit::WebString("GL_CHROMIUM_post_sub_buffer")));
 
         // Any un-sanctioned calls to enable() are OK
         EXPECT_CALL(*m_context, enable(_))
             .WillRepeatedly(Return());
 
         // Any un-sanctioned calls to disable() are OK
         EXPECT_CALL(*m_context, disable(_))
             .WillRepeatedly(Return());
     }
 
@@ skipping 28 matching lines @@
         EXPECT_CALL(*m_context, enable(GL_SCISSOR_TEST))
             .Times(0);
 
         EXPECT_CALL(*m_context, scissor(_, _, _, _))
             .Times(0);
     }
 };
 
 TEST_P(LayerTreeHostImplTest, noPartialSwap)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
+    scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
     MockContext* mockContext = static_cast<MockContext*>(outputSurface->Context3D());
     MockContextHarness harness(mockContext);
 
     // Run test case
     createLayerTreeHost(false, outputSurface.Pass());
     setupRootLayerImpl(FakeLayerWithQuads::create(m_hostImpl->activeTree(), 1));
 
     // without partial swap, and no clipping, no scissor is set.
     harness.mustDrawSolidQuad();
     harness.mustSetNoScissor();
@@ skipping 48 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 class PartialSwapContext : public FakeWebGraphicsContext3D {
 public:
-    WebString getString(WGC3Denum name)
+    WebKit::WebString getString(WebKit::WGC3Denum name)
     {
         if (name == GL_EXTENSIONS)
-            return WebString("GL_CHROMIUM_post_sub_buffer");
-        return WebString();
+            return WebKit::WebString("GL_CHROMIUM_post_sub_buffer");
+        return WebKit::WebString();
     }
 
-    WebString getRequestableExtensionsCHROMIUM()
+    WebKit::WebString getRequestableExtensionsCHROMIUM()
     {
-        return WebString("GL_CHROMIUM_post_sub_buffer");
+        return WebKit::WebString("GL_CHROMIUM_post_sub_buffer");
     }
 
     // Unlimited texture size.
-    virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value)
+    virtual void getIntegerv(WebKit::WGC3Denum pname, WebKit::WGC3Dint* value)
     {
         if (pname == GL_MAX_TEXTURE_SIZE)
             *value = 8192;
     }
 };
 
 static scoped_ptr<LayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, LayerTreeHostImplClient* client, Proxy* proxy)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
@@ skipping 195 matching lines @@
         EXPECT_EQ(0, m_hostImpl->resourceProvider());
         EXPECT_TRUE(m_hostImpl->initializeRenderer(createOutputSurface()));
     }
 
     EXPECT_TRUE(m_hostImpl->initializeRenderer(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(kMakeCurrentSuccessesNeededForSuccessfulInitialization))).PassAs<OutputSurface>()));
     EXPECT_TRUE(m_hostImpl->outputSurface());
     EXPECT_TRUE(m_hostImpl->renderer());
     EXPECT_TRUE(m_hostImpl->resourceProvider());
 }
 
-// Fake WebGraphicsContext3D that will cause a failure if trying to use a
+// Fake WebKit::WebGraphicsContext3D that will cause a failure if trying to use a
 // resource that wasn't created by it (resources created by
 // FakeWebGraphicsContext3D have an id of 1).
 class StrictWebGraphicsContext3D : public FakeWebGraphicsContext3D {
 public:
     StrictWebGraphicsContext3D()
         : FakeWebGraphicsContext3D()
     {
         m_nextTextureId = 8; // Start allocating texture ids larger than any other resource IDs so we can tell if someone's mixing up their resource types.
     }
 
-    virtual WebGLId createBuffer() { return 2; }
-    virtual WebGLId createFramebuffer() { return 3; }
-    virtual WebGLId createProgram() { return 4; }
-    virtual WebGLId createRenderbuffer() { return 5; }
-    virtual WebGLId createShader(WGC3Denum) { return 6; }
+    virtual WebKit::WebGLId createBuffer() { return 2; }
+    virtual WebKit::WebGLId createFramebuffer() { return 3; }
+    virtual WebKit::WebGLId createProgram() { return 4; }
+    virtual WebKit::WebGLId createRenderbuffer() { return 5; }
+    virtual WebKit::WebGLId createShader(WebKit::WGC3Denum) { return 6; }
 
-    static const WebGLId kExternalTextureId = 7;
+    static const WebKit::WebGLId kExternalTextureId = 7;
 
-    virtual void deleteBuffer(WebGLId id)
+    virtual void deleteBuffer(WebKit::WebGLId id)
     {
         if (id != 2)
             ADD_FAILURE() << "Trying to delete buffer id " << id;
     }
 
-    virtual void deleteFramebuffer(WebGLId id)
+    virtual void deleteFramebuffer(WebKit::WebGLId id)
     {
         if (id != 3)
             ADD_FAILURE() << "Trying to delete framebuffer id " << id;
     }
 
-    virtual void deleteProgram(WebGLId id)
+    virtual void deleteProgram(WebKit::WebGLId id)
     {
         if (id != 4)
             ADD_FAILURE() << "Trying to delete program id " << id;
     }
 
-    virtual void deleteRenderbuffer(WebGLId id)
+    virtual void deleteRenderbuffer(WebKit::WebGLId id)
     {
         if (id != 5)
             ADD_FAILURE() << "Trying to delete renderbuffer id " << id;
     }
 
-    virtual void deleteShader(WebGLId id)
+    virtual void deleteShader(WebKit::WebGLId id)
     {
         if (id != 6)
             ADD_FAILURE() << "Trying to delete shader id " << id;
     }
 
-    virtual WebGLId createTexture()
+    virtual WebKit::WebGLId createTexture()
     {
         unsigned textureId = FakeWebGraphicsContext3D::createTexture();
         m_allocatedTextureIds.insert(textureId);
         return textureId;
     }
-    virtual void deleteTexture(WebGLId id)
+    virtual void deleteTexture(WebKit::WebGLId id)
     {
         if (id == kExternalTextureId)
             ADD_FAILURE() << "Trying to delete external texture";
         if (!ContainsKey(m_allocatedTextureIds, id))
             ADD_FAILURE() << "Trying to delete texture id " << id;
         m_allocatedTextureIds.erase(id);
     }
 
-    virtual void bindBuffer(WGC3Denum, WebGLId id)
+    virtual void bindBuffer(WebKit::WGC3Denum, WebKit::WebGLId id)
     {
         if (id != 2 && id)
             ADD_FAILURE() << "Trying to bind buffer id " << id;
     }
 
-    virtual void bindFramebuffer(WGC3Denum, WebGLId id)
+    virtual void bindFramebuffer(WebKit::WGC3Denum, WebKit::WebGLId id)
     {
         if (id != 3 && id)
             ADD_FAILURE() << "Trying to bind framebuffer id " << id;
     }
 
-    virtual void useProgram(WebGLId id)
+    virtual void useProgram(WebKit::WebGLId id)
     {
         if (id != 4)
             ADD_FAILURE() << "Trying to use program id " << id;
     }
 
-    virtual void bindRenderbuffer(WGC3Denum, WebGLId id)
+    virtual void bindRenderbuffer(WebKit::WGC3Denum, WebKit::WebGLId id)
     {
         if (id != 5 && id)
             ADD_FAILURE() << "Trying to bind renderbuffer id " << id;
     }
 
-    virtual void attachShader(WebGLId program, WebGLId shader)
+    virtual void attachShader(WebKit::WebGLId program, WebKit::WebGLId shader)
     {
         if ((program != 4) || (shader != 6))
             ADD_FAILURE() << "Trying to attach shader id " << shader << " to program id " << program;
     }
 
-    virtual void bindTexture(WGC3Denum, WebGLId id)
+    virtual void bindTexture(WebKit::WGC3Denum, WebKit::WebGLId id)
     {
         if (id && id != kExternalTextureId && !ContainsKey(m_allocatedTextureIds, id))
             ADD_FAILURE() << "Trying to bind texture id " << id;
     }
 
 private:
     base::hash_set<unsigned> m_allocatedTextureIds;
 };
 
-// Fake WebVideoFrame wrapper of media::VideoFrame.
-class FakeVideoFrame: public WebVideoFrame {
+// Fake WebKit::WebVideoFrame wrapper of media::VideoFrame.
+class FakeVideoFrame: public WebKit::WebVideoFrame {
 public:
     explicit FakeVideoFrame(const scoped_refptr<VideoFrame>& frame) : m_frame(frame) { }
     virtual ~FakeVideoFrame() { }
 
     virtual Format format() const { NOTREACHED(); return FormatInvalid; }
     virtual unsigned width() const { NOTREACHED(); return 0; }
     virtual unsigned height() const { NOTREACHED(); return 0; }
     virtual unsigned planes() const { NOTREACHED(); return 0; }
     virtual int stride(unsigned plane) const { NOTREACHED(); return 0; }
     virtual const void* data(unsigned plane) const { NOTREACHED(); return NULL; }
     virtual unsigned textureId() const { NOTREACHED(); return 0; }
     virtual unsigned textureTarget() const { NOTREACHED(); return 0; }
     virtual WebKit::WebRect visibleRect() const { NOTREACHED(); return WebKit::WebRect(0, 0, 0, 0); }
     virtual WebKit::WebSize textureSize() const { NOTREACHED(); return WebKit::WebSize(4, 4); }
 
-    static VideoFrame* toVideoFrame(WebVideoFrame* web_video_frame) {
+    static VideoFrame* toVideoFrame(WebKit::WebVideoFrame* web_video_frame) {
         FakeVideoFrame* wrapped_frame =
             static_cast<FakeVideoFrame*>(web_video_frame);
         if (wrapped_frame)
             return wrapped_frame->m_frame.get();
         return NULL;
     }
 
 private:
     scoped_refptr<VideoFrame> m_frame;
 };
 
 // Fake video frame provider that always provides the same FakeVideoFrame.
-class FakeVideoFrameProvider: public WebVideoFrameProvider {
+class FakeVideoFrameProvider: public WebKit::WebVideoFrameProvider {
 public:
     FakeVideoFrameProvider() : m_frame(0), m_client(0) { }
     virtual ~FakeVideoFrameProvider()
     {
         if (m_client)
             m_client->stopUsingProvider();
     }
 
     virtual void setVideoFrameProviderClient(Client* client) { m_client = client; }
-    virtual WebVideoFrame* getCurrentFrame() { return m_frame; }
-    virtual void putCurrentFrame(WebVideoFrame*) { }
+    virtual WebKit::WebVideoFrame* getCurrentFrame() { return m_frame; }
+    virtual void putCurrentFrame(WebKit::WebVideoFrame*) { }
 
-    void setFrame(WebVideoFrame* frame) { m_frame = frame; }
+    void setFrame(WebKit::WebVideoFrame* frame) { m_frame = frame; }
 
 private:
-    WebVideoFrame* m_frame;
+    WebKit::WebVideoFrame* m_frame;
     Client* m_client;
 };
 
 class StrictWebGraphicsContext3DWithIOSurface : public StrictWebGraphicsContext3D {
 public:
-    virtual WebString getString(WGC3Denum name) OVERRIDE
+    virtual WebKit::WebString getString(WebKit::WGC3Denum name) OVERRIDE
     {
         if (name == GL_EXTENSIONS)
-            return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
+            return WebKit::WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
 
-        return WebString();
+        return WebKit::WebString();
     }
 };
 
 class FakeWebGraphicsContext3DWithIOSurface : public FakeWebGraphicsContext3D {
 public:
-    virtual WebString getString(WGC3Denum name) OVERRIDE
+    virtual WebKit::WebString getString(WebKit::WGC3Denum name) OVERRIDE
     {
         if (name == GL_EXTENSIONS)
-            return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
+            return WebKit::WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
 
-        return WebString();
+        return WebKit::WebString();
     }
 };
 
 class FakeWebScrollbarThemeGeometryNonEmpty : public FakeWebScrollbarThemeGeometry {
-    virtual WebRect trackRect(WebScrollbar*) OVERRIDE { return WebRect(0, 0, 10, 10); }
-    virtual WebRect thumbRect(WebScrollbar*) OVERRIDE { return WebRect(0, 5, 5, 2); }
-    virtual void splitTrack(WebScrollbar*, const WebRect& track, WebRect& startTrack, WebRect& thumb, WebRect& endTrack) OVERRIDE
+    virtual WebKit::WebRect trackRect(WebKit::WebScrollbar*) OVERRIDE { return WebKit::WebRect(0, 0, 10, 10); }
+    virtual WebKit::WebRect thumbRect(WebKit::WebScrollbar*) OVERRIDE { return WebKit::WebRect(0, 5, 5, 2); }
+    virtual void splitTrack(WebKit::WebScrollbar*, const WebKit::WebRect& track, WebKit::WebRect& startTrack, WebKit::WebRect& thumb, WebKit::WebRect& endTrack) OVERRIDE
     {
-        thumb = WebRect(0, 5, 5, 2);
-        startTrack = WebRect(0, 5, 0, 5);
-        endTrack = WebRect(0, 0, 0, 5);
+        thumb = WebKit::WebRect(0, 5, 5, 2);
+        startTrack = WebKit::WebRect(0, 5, 0, 5);
+        endTrack = WebKit::WebRect(0, 0, 0, 5);
     }
 };
 
 class FakeScrollbarLayerImpl : public ScrollbarLayerImpl {
 public:
     static scoped_ptr<FakeScrollbarLayerImpl> create(LayerTreeImpl* treeImpl, int id)
     {
         return make_scoped_ptr(new FakeScrollbarLayerImpl(treeImpl, id));
     }
 
@@ skipping 165 matching lines @@
     m_hostImpl->setRootLayer(rootLayer.Pass());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     unsigned numResources = m_hostImpl->resourceProvider()->numResources();
 
-    // Lose the WebGraphicsContext3D, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
+    // Lose the WebKit::WebGraphicsContext3D, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
     // that will warn if any resource from the previous context gets used.
     m_hostImpl->initializeRenderer(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new StrictWebGraphicsContext3DWithIOSurface)).PassAs<OutputSurface>());
 
     // Create dummy resources so that looking up an old resource will get an
     // invalid texture id mapping.
     for (unsigned i = 0; i < numResources; ++i)
         m_hostImpl->resourceProvider()->createResourceFromExternalTexture(StrictWebGraphicsContext3D::kExternalTextureId);
 
-    // The WebVideoFrameProvider is expected to recreate its textures after a
+    // The WebKit::WebVideoFrameProvider is expected to recreate its textures after a
     // lost output surface (or not serve a frame).
     hwProvider.setFrame(0);
     providerScaled.setFrame(0);
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     FakeVideoFrame hwVideoFrame2(
         VideoFrame::WrapNativeTexture(
             m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture(),
             GL_TEXTURE_2D,
             gfx::Size(4, 4), gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4), base::TimeDelta(),
             VideoFrame::ReadPixelsCB(), base::Closure()));
     hwProvider.setFrame(&hwVideoFrame2);
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 }
 
-// Fake WebGraphicsContext3D that tracks the number of textures in use.
+// Fake WebKit::WebGraphicsContext3D that tracks the number of textures in use.
 class TrackingWebGraphicsContext3D : public FakeWebGraphicsContext3D {
 public:
     TrackingWebGraphicsContext3D()
         : FakeWebGraphicsContext3D()
         , m_numTextures(0)
     { }
 
-    virtual WebGLId createTexture() OVERRIDE
+    virtual WebKit::WebGLId createTexture() OVERRIDE
     {
-        WebGLId id = FakeWebGraphicsContext3D::createTexture();
+        WebKit::WebGLId id = FakeWebGraphicsContext3D::createTexture();
 
         m_textures[id] = true;
         ++m_numTextures;
         return id;
     }
 
-    virtual void deleteTexture(WebGLId id) OVERRIDE
+    virtual void deleteTexture(WebKit::WebGLId id) OVERRIDE
     {
         if (m_textures.find(id) == m_textures.end())
             return;
 
         m_textures[id] = false;
         --m_numTextures;
     }
 
-    virtual WebString getString(WGC3Denum name) OVERRIDE
+    virtual WebKit::WebString getString(WebKit::WGC3Denum name) OVERRIDE
     {
         if (name == GL_EXTENSIONS)
-            return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
+            return WebKit::WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
 
-        return WebString();
+        return WebKit::WebString();
     }
 
     unsigned numTextures() const { return m_numTextures; }
 
 private:
-    base::hash_map<WebGLId, bool> m_textures;
+    base::hash_map<WebKit::WebGLId, bool> m_textures;
     unsigned m_numTextures;
 };
 
 TEST_P(LayerTreeHostImplTest, layersFreeTextures)
 {
     scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(m_hostImpl->activeTree(), 1));
     rootLayer->setBounds(gfx::Size(10, 10));
     rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
     scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(m_hostImpl->activeTree(), 2);
@@ skipping 50 matching lines @@
     EXPECT_GT(trackingWebGraphicsContext3D->numTextures(), 0u);
 
     // Kill the layer tree.
     m_hostImpl->setRootLayer(LayerImpl::create(m_hostImpl->activeTree(), 100));
     // There should be no textures left in use after.
     EXPECT_EQ(0u, trackingWebGraphicsContext3D->numTextures());
 }
 
 class MockDrawQuadsToFillScreenContext : public FakeWebGraphicsContext3D {
 public:
-    MOCK_METHOD1(useProgram, void(WebGLId program));
-    MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));
+    MOCK_METHOD1(useProgram, void(WebKit::WebGLId program));
+    MOCK_METHOD4(drawElements, void(WebKit::WGC3Denum mode, WebKit::WGC3Dsizei count, WebKit::WGC3Denum type, WebKit::WGC3Dintptr offset));
 };
 
 TEST_P(LayerTreeHostImplTest, hasTransparentBackground)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockDrawQuadsToFillScreenContext)).PassAs<OutputSurface>();
     MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(outputSurface->Context3D());
 
     // Run test case
     createLayerTreeHost(false, outputSurface.Pass());
     setupRootLayerImpl(LayerImpl::create(m_hostImpl->activeTree(), 1));
@@ skipping 1812 matching lines @@
 {
     pinchZoomPanViewportAndScrollBoundaryTest(2);
 }
 
 class LayerTreeHostImplTestWithDelegatingRenderer : public LayerTreeHostImplTest {
 protected:
     virtual scoped_ptr<OutputSurface> createOutputSurface()
     {
         // Creates an output surface with a parent to use a delegating renderer.
         WebKit::WebGraphicsContext3D::Attributes attrs;
-        return FakeOutputSurface::CreateDelegating3d(WebKit::CompositorFakeWebGraphicsContext3D::create(attrs).PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
+        return FakeOutputSurface::CreateDelegating3d(CompositorFakeWebGraphicsContext3D::create(attrs).PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
     }
 
     void drawFrameAndTestDamage(const gfx::RectF& expectedDamage) {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         // Verify the damage rect for the root render pass.
         const RenderPass* rootRenderPass = frame.renderPasses.back();
         EXPECT_RECT_EQ(expectedDamage, rootRenderPass->damage_rect);
@@ skipping 18 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc