Change cc files from namespace WebCore to cc

cc/CCTextureUpdateControllerTest.cpp

 // Copyright 2012 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 "CCTextureUpdateController.h"
 
 #include "CCSchedulerTestCommon.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
 #include "CCTiledLayerTestCommon.h"
 #include "FakeWebCompositorOutputSurface.h"
 #include "FakeWebGraphicsContext3D.h"
 #include "WebCompositorInitializer.h"
 #include <gtest/gtest.h>
 #include <public/WebThread.h>
 #include <wtf/RefPtr.h>
 
-using namespace WebCore;
+using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
 using testing::Test;
 
 
 namespace {
 
 const int kFlushPeriodFull = 4;
 const int kFlushPeriodPartial = kFlushPeriodFull;
 
@@ skipping 22 matching lines @@
     bool m_supportShallowFlush;
 };
 
 
 class TextureUploaderForUploadTest : public FakeTextureUploader {
 public:
     TextureUploaderForUploadTest(CCTextureUpdateControllerTest *test) : m_test(test) { }
 
     virtual void beginUploads() OVERRIDE;
     virtual void endUploads() OVERRIDE;
-    virtual void uploadTexture(WebCore::CCResourceProvider*, Parameters) OVERRIDE;
+    virtual void uploadTexture(cc::CCResourceProvider*, Parameters) OVERRIDE;
 
 private:
     CCTextureUpdateControllerTest* m_test;
 };
 
 class TextureForUploadTest : public LayerTextureUpdater::Texture {
 public:
     TextureForUploadTest() : LayerTextureUpdater::Texture(adoptPtr<CCPrioritizedTexture>(0)) { }
     virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) { }
 };
@@ skipping 153 matching lines @@
 void TextureUploaderForUploadTest::beginUploads()
 {
     m_test->onBeginUploads();
 }
 
 void TextureUploaderForUploadTest::endUploads()
 {
     m_test->onEndUploads();
 }
 
-void TextureUploaderForUploadTest::uploadTexture(WebCore::CCResourceProvider*, Parameters)
+void TextureUploaderForUploadTest::uploadTexture(cc::CCResourceProvider*, Parameters)
 {
     m_test->onUpload();
 }
 
 
 // ZERO UPLOADS TESTS
 TEST_F(CCTextureUpdateControllerTest, ZeroUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(0);
@@ skipping 264 matching lines @@
 
     EXPECT_EQ(3, m_numBeginUploads);
     EXPECT_EQ(3, m_numEndUploads);
     EXPECT_LE(m_numPreviousUploads, kMaxUploadsPerUpdate);
     // Be lenient on the exact number of flushes here as well.
 
     // Final sanity checks
     EXPECT_EQ(kFullUploads + kPartialUploads, m_numTotalUploads);
 }
 
-class FakeCCTextureUpdateControllerClient : public WebCore::CCTextureUpdateControllerClient {
+class FakeCCTextureUpdateControllerClient : public cc::CCTextureUpdateControllerClient {
 public:
     FakeCCTextureUpdateControllerClient() { reset(); }
     void reset() { m_completedCalled = false; }
     bool completedCalled() const { return m_completedCalled; }
 
     virtual void updateTexturesCompleted() OVERRIDE { m_completedCalled = true; }
 
 protected:
     bool m_completedCalled;
 };
 
-class FakeCCTextureUpdateController : public WebCore::CCTextureUpdateController {
+class FakeCCTextureUpdateController : public cc::CCTextureUpdateController {
 public:
-    static PassOwnPtr<FakeCCTextureUpdateController> create(WebCore::CCTextureUpdateControllerClient* client, WebCore::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+    static PassOwnPtr<FakeCCTextureUpdateController> create(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
     {
         return adoptPtr(new FakeCCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader));
     }
 
     void setMonotonicTimeNow(double time) { m_monotonicTimeNow = time; }
     virtual double monotonicTimeNow() const OVERRIDE { return m_monotonicTimeNow; }
     void setUpdateMoreTexturesTime(double time) { m_updateMoreTexturesTime = time; }
     virtual double updateMoreTexturesTime() const OVERRIDE { return m_updateMoreTexturesTime; }
     void setUpdateMoreTexturesSize(size_t size) { m_updateMoreTexturesSize = size; }
     virtual size_t updateMoreTexturesSize() const OVERRIDE { return m_updateMoreTexturesSize; }
 
 protected:
-    FakeCCTextureUpdateController(WebCore::CCTextureUpdateControllerClient* client, WebCore::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
-        : WebCore::CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader)
+    FakeCCTextureUpdateController(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+        : cc::CCTextureUpdateController(client, thread, queue, resourceProvider, copier, uploader)
         , m_monotonicTimeNow(0)
         , m_updateMoreTexturesTime(0)
         , m_updateMoreTexturesSize(0) { }
 
     double m_monotonicTimeNow;
     double m_updateMoreTexturesTime;
     size_t m_updateMoreTexturesSize;
 };
 
 static void runPendingTask(FakeCCThread* thread, FakeCCTextureUpdateController* controller)
@@ skipping 116 matching lines @@
     }
 
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.completedCalled());
     EXPECT_EQ(2, m_numBeginUploads);
     EXPECT_EQ(2, m_numEndUploads);
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
 } // namespace