cc: Rename cc classes and members to match filenames

BUG=155413

Review URL: https://codereview.chromium.org/11189043

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@163052 0039d316-1c4b-4281-b951-d872f2087c98

30 files changed, 153 insertions, 153 deletions

diff --git a/webkit/compositor_bindings/ccthread_impl.cc b/webkit/compositor_bindings/ccthread_impl.cc
index bbda140..2df53518 100644
--- a/webkit/compositor_bindings/ccthread_impl.cc
+++ b/webkit/compositor_bindings/ccthread_impl.cc
@@ -9,8 +9,8 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebThread.h"
 
-using cc::CCThread;
-using cc::CCCompletionEvent;
+using cc::Thread;
+using cc::CompletionEvent;
 
 namespace WebKit {
 
@@ -22,7 +22,7 @@ namespace WebKit {
 // PassOwnPtrs.
 class GetThreadIDTask : public WebThread::Task {
 public:
-    GetThreadIDTask(base::PlatformThreadId* result, CCCompletionEvent* completion)
+    GetThreadIDTask(base::PlatformThreadId* result, CompletionEvent* completion)
          : m_completion(completion)
          , m_result(result) { }
 
@@ -35,16 +35,16 @@ public:
     }
 
 private:
-    CCCompletionEvent* m_completion;
+    CompletionEvent* m_completion;
     base::PlatformThreadId* m_result;
 };
 
-// General adapter from a CCThread::Task to a WebThread::Task.
-class CCThreadTaskAdapter : public WebThread::Task {
+// General adapter from a Thread::Task to a WebThread::Task.
+class ThreadTaskAdapter : public WebThread::Task {
 public:
-    explicit CCThreadTaskAdapter(PassOwnPtr<CCThread::Task> task) : m_task(task) { }
+    explicit ThreadTaskAdapter(PassOwnPtr<Thread::Task> task) : m_task(task) { }
 
-    virtual ~CCThreadTaskAdapter() { }
+    virtual ~ThreadTaskAdapter() { }
 
     virtual void run()
     {
@@ -52,31 +52,31 @@ public:
     }
 
 private:
-    OwnPtr<CCThread::Task> m_task;
+    OwnPtr<Thread::Task> m_task;
 };
 
-scoped_ptr<CCThread> CCThreadImpl::createForCurrentThread()
+scoped_ptr<Thread> CCThreadImpl::createForCurrentThread()
 {
-    return scoped_ptr<CCThread>(new CCThreadImpl(Platform::current()->currentThread(), true)).Pass();
+    return scoped_ptr<Thread>(new CCThreadImpl(Platform::current()->currentThread(), true)).Pass();
 }
 
-scoped_ptr<CCThread> CCThreadImpl::createForDifferentThread(WebThread* thread)
+scoped_ptr<Thread> CCThreadImpl::createForDifferentThread(WebThread* thread)
 {
-    return scoped_ptr<CCThread>(new CCThreadImpl(thread, false)).Pass();
+    return scoped_ptr<Thread>(new CCThreadImpl(thread, false)).Pass();
 }
 
 CCThreadImpl::~CCThreadImpl()
 {
 }
 
-void CCThreadImpl::postTask(PassOwnPtr<CCThread::Task> task)
+void CCThreadImpl::postTask(PassOwnPtr<Thread::Task> task)
 {
-    m_thread->postTask(new CCThreadTaskAdapter(task));
+    m_thread->postTask(new ThreadTaskAdapter(task));
 }
 
-void CCThreadImpl::postDelayedTask(PassOwnPtr<CCThread::Task> task, long long delayMs)
+void CCThreadImpl::postDelayedTask(PassOwnPtr<Thread::Task> task, long long delayMs)
 {
-    m_thread->postDelayedTask(new CCThreadTaskAdapter(task), delayMs);
+    m_thread->postDelayedTask(new ThreadTaskAdapter(task), delayMs);
 }
 
 base::PlatformThreadId CCThreadImpl::threadID() const
@@ -94,7 +94,7 @@ CCThreadImpl::CCThreadImpl(WebThread* thread, bool currentThread)
 
     // Get the threadId for the newly-created thread by running a task
     // on that thread, blocking on the result.
-    CCCompletionEvent completion;
+    CompletionEvent completion;
     m_thread->postTask(new GetThreadIDTask(&m_threadID, &completion));
     completion.wait();
 }
diff --git a/webkit/compositor_bindings/ccthread_impl.h b/webkit/compositor_bindings/ccthread_impl.h
index bd598a9..259ca4a 100644
--- a/webkit/compositor_bindings/ccthread_impl.h
+++ b/webkit/compositor_bindings/ccthread_impl.h
@@ -15,18 +15,18 @@ namespace WebKit {
 
 class WebThread;
 
-// Implements CCThread in terms of WebThread.
-class CCThreadImpl : public cc::CCThread {
+// Implements Thread in terms of WebThread.
+class CCThreadImpl : public cc::Thread {
 public:
     // Creates a CCThreadImpl wrapping the current thread.
-    static scoped_ptr<cc::CCThread> createForCurrentThread();
+    static scoped_ptr<cc::Thread> createForCurrentThread();
 
-    // Creates a CCThread wrapping a non-current WebThread.
-    static scoped_ptr<cc::CCThread> createForDifferentThread(WebThread*);
+    // Creates a Thread wrapping a non-current WebThread.
+    static scoped_ptr<cc::Thread> createForDifferentThread(WebThread*);
 
     virtual ~CCThreadImpl();
-    virtual void postTask(PassOwnPtr<cc::CCThread::Task>);
-    virtual void postDelayedTask(PassOwnPtr<cc::CCThread::Task>, long long delayMs);
+    virtual void postTask(PassOwnPtr<cc::Thread::Task>);
+    virtual void postDelayedTask(PassOwnPtr<cc::Thread::Task>, long long delayMs);
     base::PlatformThreadId threadID() const;
 
 private:
diff --git a/webkit/compositor_bindings/web_animation_curve_common.cc b/webkit/compositor_bindings/web_animation_curve_common.cc
index 211cc67..09092bd 100644
--- a/webkit/compositor_bindings/web_animation_curve_common.cc
+++ b/webkit/compositor_bindings/web_animation_curve_common.cc
@@ -10,21 +10,21 @@
 
 namespace WebKit {
 
-scoped_ptr<cc::CCTimingFunction> createTimingFunction(WebAnimationCurve::TimingFunctionType type)
+scoped_ptr<cc::TimingFunction> createTimingFunction(WebAnimationCurve::TimingFunctionType type)
 {
     switch (type) {
     case WebAnimationCurve::TimingFunctionTypeEase:
-        return cc::CCEaseTimingFunction::create();
+        return cc::EaseTimingFunction::create();
     case WebAnimationCurve::TimingFunctionTypeEaseIn:
-        return cc::CCEaseInTimingFunction::create();
+        return cc::EaseInTimingFunction::create();
     case WebAnimationCurve::TimingFunctionTypeEaseOut:
-        return cc::CCEaseOutTimingFunction::create();
+        return cc::EaseOutTimingFunction::create();
     case WebAnimationCurve::TimingFunctionTypeEaseInOut:
-        return cc::CCEaseInOutTimingFunction::create();
+        return cc::EaseInOutTimingFunction::create();
     case WebAnimationCurve::TimingFunctionTypeLinear:
-        return scoped_ptr<cc::CCTimingFunction>();
+        return scoped_ptr<cc::TimingFunction>();
     }
-    return scoped_ptr<cc::CCTimingFunction>();
+    return scoped_ptr<cc::TimingFunction>();
 }
 
 } // namespace WebKit
diff --git a/webkit/compositor_bindings/web_animation_curve_common.h b/webkit/compositor_bindings/web_animation_curve_common.h
index 8a6726b..becfd02 100644
--- a/webkit/compositor_bindings/web_animation_curve_common.h
+++ b/webkit/compositor_bindings/web_animation_curve_common.h
@@ -9,11 +9,11 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebAnimationCurve.h"
 
 namespace cc {
-class CCTimingFunction;
+class TimingFunction;
 }
 
 namespace WebKit {
-scoped_ptr<cc::CCTimingFunction> createTimingFunction(WebAnimationCurve::TimingFunctionType);
+scoped_ptr<cc::TimingFunction> createTimingFunction(WebAnimationCurve::TimingFunctionType);
 }
 
 #endif // WebAnimationCurveCommon_h
diff --git a/webkit/compositor_bindings/web_animation_impl.cc b/webkit/compositor_bindings/web_animation_impl.cc
index 222b18e..4720199 100644
--- a/webkit/compositor_bindings/web_animation_impl.cc
+++ b/webkit/compositor_bindings/web_animation_impl.cc
@@ -13,7 +13,7 @@
 #include "web_float_animation_curve_impl.h"
 #include "web_transform_animation_curve_impl.h"
 
-using cc::CCActiveAnimation;
+using cc::ActiveAnimation;
 
 namespace WebKit {
 
@@ -32,20 +32,20 @@ WebAnimationImpl::WebAnimationImpl(const WebAnimationCurve& webCurve, TargetProp
         groupId = nextGroupId++;
 
     WebAnimationCurve::AnimationCurveType curveType = webCurve.type();
-    scoped_ptr<cc::CCAnimationCurve> curve;
+    scoped_ptr<cc::AnimationCurve> curve;
     switch (curveType) {
     case WebAnimationCurve::AnimationCurveTypeFloat: {
         const WebFloatAnimationCurveImpl* floatCurveImpl = static_cast<const WebFloatAnimationCurveImpl*>(&webCurve);
-        curve = floatCurveImpl->cloneToCCAnimationCurve();
+        curve = floatCurveImpl->cloneToAnimationCurve();
         break;
     }
     case WebAnimationCurve::AnimationCurveTypeTransform: {
         const WebTransformAnimationCurveImpl* transformCurveImpl = static_cast<const WebTransformAnimationCurveImpl*>(&webCurve);
-        curve = transformCurveImpl->cloneToCCAnimationCurve();
+        curve = transformCurveImpl->cloneToAnimationCurve();
         break;
     }
     }
-    m_animation = CCActiveAnimation::create(curve.Pass(), animationId, groupId, static_cast<cc::CCActiveAnimation::TargetProperty>(targetProperty));
+    m_animation = ActiveAnimation::create(curve.Pass(), animationId, groupId, static_cast<cc::ActiveAnimation::TargetProperty>(targetProperty));
 }
 
 WebAnimationImpl::~WebAnimationImpl()
@@ -102,9 +102,9 @@ void WebAnimationImpl::setAlternatesDirection(bool alternates)
     m_animation->setAlternatesDirection(alternates);
 }
 
-scoped_ptr<cc::CCActiveAnimation> WebAnimationImpl::cloneToCCAnimation()
+scoped_ptr<cc::ActiveAnimation> WebAnimationImpl::cloneToAnimation()
 {
-    scoped_ptr<cc::CCActiveAnimation> toReturn(m_animation->clone(cc::CCActiveAnimation::NonControllingInstance));
+    scoped_ptr<cc::ActiveAnimation> toReturn(m_animation->clone(cc::ActiveAnimation::NonControllingInstance));
     toReturn->setNeedsSynchronizedStartTime(true);
     return toReturn.Pass();
 }
diff --git a/webkit/compositor_bindings/web_animation_impl.h b/webkit/compositor_bindings/web_animation_impl.h
index d7312b1..25b054d 100644
--- a/webkit/compositor_bindings/web_animation_impl.h
+++ b/webkit/compositor_bindings/web_animation_impl.h
@@ -9,7 +9,7 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebAnimation.h"
 
 namespace cc {
-class CCActiveAnimation;
+class ActiveAnimation;
 }
 
 namespace WebKit {
@@ -31,10 +31,10 @@ public:
     virtual bool alternatesDirection() const OVERRIDE;
     virtual void setAlternatesDirection(bool) OVERRIDE;
 
-    scoped_ptr<cc::CCActiveAnimation> cloneToCCAnimation();
+    scoped_ptr<cc::ActiveAnimation> cloneToAnimation();
 
 private:
-    scoped_ptr<cc::CCActiveAnimation> m_animation;
+    scoped_ptr<cc::ActiveAnimation> m_animation;
 };
 
 }
diff --git a/webkit/compositor_bindings/web_compositor_impl.cc b/webkit/compositor_bindings/web_compositor_impl.cc
index fedf1bc..5d0a2e9 100644
--- a/webkit/compositor_bindings/web_compositor_impl.cc
+++ b/webkit/compositor_bindings/web_compositor_impl.cc
@@ -22,8 +22,8 @@ using namespace cc;
 namespace WebKit {
 
 bool WebCompositorImpl::s_initialized = false;
-CCThread* WebCompositorImpl::s_mainThread = 0;
-CCThread* WebCompositorImpl::s_implThread = 0;
+Thread* WebCompositorImpl::s_mainThread = 0;
+Thread* WebCompositorImpl::s_implThread = 0;
 
 void WebCompositor::initialize(WebThread* implThread)
 {
@@ -46,12 +46,12 @@ void WebCompositorImpl::initialize(WebThread* implThread)
     s_initialized = true;
 
     s_mainThread = CCThreadImpl::createForCurrentThread().release();
-    CCProxy::setMainThread(s_mainThread);
+    Proxy::setMainThread(s_mainThread);
     if (implThread) {
         s_implThread = CCThreadImpl::createForDifferentThread(implThread).release();
-        CCProxy::setImplThread(s_implThread);
+        Proxy::setImplThread(s_implThread);
     } else
-        CCProxy::setImplThread(0);
+        Proxy::setImplThread(0);
 }
 
 bool WebCompositorImpl::isThreadingEnabled()
@@ -67,7 +67,7 @@ bool WebCompositorImpl::initialized()
 void WebCompositorImpl::shutdown()
 {
     ASSERT(s_initialized);
-    ASSERT(!CCLayerTreeHost::anyLayerTreeHostInstanceExists());
+    ASSERT(!LayerTreeHost::anyLayerTreeHostInstanceExists());
 
     if (s_implThread) {
         delete s_implThread;
@@ -75,8 +75,8 @@ void WebCompositorImpl::shutdown()
     }
     delete s_mainThread;
     s_mainThread = 0;
-    CCProxy::setImplThread(0);
-    CCProxy::setMainThread(0);
+    Proxy::setImplThread(0);
+    Proxy::setMainThread(0);
     s_initialized = false;
 }
 
diff --git a/webkit/compositor_bindings/web_compositor_impl.h b/webkit/compositor_bindings/web_compositor_impl.h
index f07871e..fe63b27 100644
--- a/webkit/compositor_bindings/web_compositor_impl.h
+++ b/webkit/compositor_bindings/web_compositor_impl.h
@@ -8,7 +8,7 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCompositor.h"
 
 namespace cc {
-class CCThread;
+class Thread;
 }
 
 namespace WebKit {
@@ -25,8 +25,8 @@ public:
 
 private:
     static bool s_initialized;
-    static cc::CCThread* s_mainThread;
-    static cc::CCThread* s_implThread;
+    static cc::Thread* s_mainThread;
+    static cc::Thread* s_implThread;
 };
 
 }
diff --git a/webkit/compositor_bindings/web_content_layer_impl.cc b/webkit/compositor_bindings/web_content_layer_impl.cc
index 09b2415..6ac5916 100644
--- a/webkit/compositor_bindings/web_content_layer_impl.cc
+++ b/webkit/compositor_bindings/web_content_layer_impl.cc
@@ -26,7 +26,7 @@ WebContentLayer* WebContentLayer::create(WebContentLayerClient* client)
 }
 
 WebContentLayerImpl::WebContentLayerImpl(WebContentLayerClient* client)
-    : m_layer(new WebLayerImpl(ContentLayerChromium::create(this)))
+    : m_layer(new WebLayerImpl(ContentLayer::create(this)))
     , m_client(client)
 {
     m_layer->layer()->setIsDrawable(true);
@@ -34,7 +34,7 @@ WebContentLayerImpl::WebContentLayerImpl(WebContentLayerClient* client)
 
 WebContentLayerImpl::~WebContentLayerImpl()
 {
-    static_cast<ContentLayerChromium*>(m_layer->layer())->clearClient();
+    static_cast<ContentLayer*>(m_layer->layer())->clearClient();
 }
 
 WebLayer* WebContentLayerImpl::layer()
diff --git a/webkit/compositor_bindings/web_content_layer_impl.h b/webkit/compositor_bindings/web_content_layer_impl.h
index c08a675..dc568d9 100644
--- a/webkit/compositor_bindings/web_content_layer_impl.h
+++ b/webkit/compositor_bindings/web_content_layer_impl.h
@@ -24,7 +24,7 @@ namespace WebKit {
 class WebContentLayerClient;
 
 class WebContentLayerImpl : public WebContentLayer,
-                            public cc::ContentLayerChromiumClient {
+                            public cc::ContentLayerClient {
 public:
     explicit WebContentLayerImpl(WebContentLayerClient*);
 
@@ -39,7 +39,7 @@ public:
 protected:
     virtual ~WebContentLayerImpl();
 
-    // ContentLayerChromiumClient implementation.
+    // ContentLayerClient implementation.
     virtual void paintContents(SkCanvas*, const cc::IntRect& clip, cc::FloatRect& opaque) OVERRIDE;
 
     scoped_ptr<WebLayerImpl> m_layer;
diff --git a/webkit/compositor_bindings/web_delegated_renderer_layer_impl.cc b/webkit/compositor_bindings/web_delegated_renderer_layer_impl.cc
index f3adf20..9a9f6a7 100644
--- a/webkit/compositor_bindings/web_delegated_renderer_layer_impl.cc
+++ b/webkit/compositor_bindings/web_delegated_renderer_layer_impl.cc
@@ -12,7 +12,7 @@ using namespace cc;
 namespace WebKit {
 
 WebDelegatedRendererLayerImpl::WebDelegatedRendererLayerImpl()
-    : m_layer(new WebLayerImpl(DelegatedRendererLayerChromium::create()))
+    : m_layer(new WebLayerImpl(DelegatedRendererLayer::create()))
 {
 }
 
diff --git a/webkit/compositor_bindings/web_external_texture_layer_impl.cc b/webkit/compositor_bindings/web_external_texture_layer_impl.cc
index 6fc1dcc..60fb4d2 100644
--- a/webkit/compositor_bindings/web_external_texture_layer_impl.cc
+++ b/webkit/compositor_bindings/web_external_texture_layer_impl.cc
@@ -25,18 +25,18 @@ WebExternalTextureLayer* WebExternalTextureLayer::create(WebExternalTextureLayer
 WebExternalTextureLayerImpl::WebExternalTextureLayerImpl(WebExternalTextureLayerClient* client)
     : m_client(client)
 {
-    scoped_refptr<TextureLayerChromium> layer;
+    scoped_refptr<TextureLayer> layer;
     if (m_client)
-        layer = TextureLayerChromium::create(this);
+        layer = TextureLayer::create(this);
     else
-        layer = TextureLayerChromium::create(0);
+        layer = TextureLayer::create(0);
     layer->setIsDrawable(true);
     m_layer.reset(new WebLayerImpl(layer));
 }
 
 WebExternalTextureLayerImpl::~WebExternalTextureLayerImpl()
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->clearClient();
+    static_cast<TextureLayer*>(m_layer->layer())->clearClient();
 }
 
 WebLayer* WebExternalTextureLayerImpl::layer()
@@ -46,42 +46,42 @@ WebLayer* WebExternalTextureLayerImpl::layer()
 
 void WebExternalTextureLayerImpl::setTextureId(unsigned id)
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->setTextureId(id);
+    static_cast<TextureLayer*>(m_layer->layer())->setTextureId(id);
 }
 
 void WebExternalTextureLayerImpl::setFlipped(bool flipped)
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->setFlipped(flipped);
+    static_cast<TextureLayer*>(m_layer->layer())->setFlipped(flipped);
 }
 
 void WebExternalTextureLayerImpl::setUVRect(const WebFloatRect& rect)
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->setUVRect(convert(rect));
+    static_cast<TextureLayer*>(m_layer->layer())->setUVRect(convert(rect));
 }
 
 void WebExternalTextureLayerImpl::setOpaque(bool opaque)
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->setContentsOpaque(opaque);
+    static_cast<TextureLayer*>(m_layer->layer())->setContentsOpaque(opaque);
 }
 
 void WebExternalTextureLayerImpl::setPremultipliedAlpha(bool premultipliedAlpha)
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->setPremultipliedAlpha(premultipliedAlpha);
+    static_cast<TextureLayer*>(m_layer->layer())->setPremultipliedAlpha(premultipliedAlpha);
 }
 
 void WebExternalTextureLayerImpl::willModifyTexture()
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->willModifyTexture();
+    static_cast<TextureLayer*>(m_layer->layer())->willModifyTexture();
 }
 
 void WebExternalTextureLayerImpl::setRateLimitContext(bool rateLimit)
 {
-    static_cast<TextureLayerChromium*>(m_layer->layer())->setRateLimitContext(rateLimit);
+    static_cast<TextureLayer*>(m_layer->layer())->setRateLimitContext(rateLimit);
 }
 
 class WebTextureUpdaterImpl : public WebTextureUpdater {
 public:
-    explicit WebTextureUpdaterImpl(CCTextureUpdateQueue& queue)
+    explicit WebTextureUpdaterImpl(TextureUpdateQueue& queue)
         : m_queue(queue)
     {
     }
@@ -93,10 +93,10 @@ public:
     }
 
 private:
-    CCTextureUpdateQueue& m_queue;
+    TextureUpdateQueue& m_queue;
 };
 
-unsigned WebExternalTextureLayerImpl::prepareTexture(CCTextureUpdateQueue& queue)
+unsigned WebExternalTextureLayerImpl::prepareTexture(TextureUpdateQueue& queue)
 {
     ASSERT(m_client);
     WebTextureUpdaterImpl updaterImpl(queue);
diff --git a/webkit/compositor_bindings/web_external_texture_layer_impl.h b/webkit/compositor_bindings/web_external_texture_layer_impl.h
index d631058..cf82629 100644
--- a/webkit/compositor_bindings/web_external_texture_layer_impl.h
+++ b/webkit/compositor_bindings/web_external_texture_layer_impl.h
@@ -14,7 +14,7 @@ namespace WebKit {
 class WebLayerImpl;
 
 class WebExternalTextureLayerImpl : public WebExternalTextureLayer,
-                                    public cc::TextureLayerChromiumClient {
+                                    public cc::TextureLayerClient {
 public:
     explicit WebExternalTextureLayerImpl(WebExternalTextureLayerClient*);
     virtual ~WebExternalTextureLayerImpl();
@@ -29,8 +29,8 @@ public:
     virtual void willModifyTexture() OVERRIDE;
     virtual void setRateLimitContext(bool) OVERRIDE;
 
-    // TextureLayerChromiumClient implementation.
-    virtual unsigned prepareTexture(cc::CCTextureUpdateQueue&) OVERRIDE;
+    // TextureLayerClient implementation.
+    virtual unsigned prepareTexture(cc::TextureUpdateQueue&) OVERRIDE;
     virtual WebGraphicsContext3D* context() OVERRIDE;
 
 private:
diff --git a/webkit/compositor_bindings/web_float_animation_curve_impl.cc b/webkit/compositor_bindings/web_float_animation_curve_impl.cc
index a3d909e..cbd9a53 100644
--- a/webkit/compositor_bindings/web_float_animation_curve_impl.cc
+++ b/webkit/compositor_bindings/web_float_animation_curve_impl.cc
@@ -19,7 +19,7 @@ WebFloatAnimationCurve* WebFloatAnimationCurve::create()
 }
 
 WebFloatAnimationCurveImpl::WebFloatAnimationCurveImpl()
-    : m_curve(cc::CCKeyframedFloatAnimationCurve::create())
+    : m_curve(cc::KeyframedFloatAnimationCurve::create())
 {
 }
 
@@ -39,12 +39,12 @@ void WebFloatAnimationCurveImpl::add(const WebFloatKeyframe& keyframe)
 
 void WebFloatAnimationCurveImpl::add(const WebFloatKeyframe& keyframe, TimingFunctionType type)
 {
-    m_curve->addKeyframe(cc::CCFloatKeyframe::create(keyframe.time, keyframe.value, createTimingFunction(type)));
+    m_curve->addKeyframe(cc::FloatKeyframe::create(keyframe.time, keyframe.value, createTimingFunction(type)));
 }
 
 void WebFloatAnimationCurveImpl::add(const WebFloatKeyframe& keyframe, double x1, double y1, double x2, double y2)
 {
-    m_curve->addKeyframe(cc::CCFloatKeyframe::create(keyframe.time, keyframe.value, cc::CCCubicBezierTimingFunction::create(x1, y1, x2, y2).PassAs<cc::CCTimingFunction>()));
+    m_curve->addKeyframe(cc::FloatKeyframe::create(keyframe.time, keyframe.value, cc::CubicBezierTimingFunction::create(x1, y1, x2, y2).PassAs<cc::TimingFunction>()));
 }
 
 float WebFloatAnimationCurveImpl::getValue(double time) const
@@ -52,7 +52,7 @@ float WebFloatAnimationCurveImpl::getValue(double time) const
     return m_curve->getValue(time);
 }
 
-scoped_ptr<cc::CCAnimationCurve> WebFloatAnimationCurveImpl::cloneToCCAnimationCurve() const
+scoped_ptr<cc::AnimationCurve> WebFloatAnimationCurveImpl::cloneToAnimationCurve() const
 {
     return m_curve->clone();
 }
diff --git a/webkit/compositor_bindings/web_float_animation_curve_impl.h b/webkit/compositor_bindings/web_float_animation_curve_impl.h
index 299190f..b33ca8b 100644
--- a/webkit/compositor_bindings/web_float_animation_curve_impl.h
+++ b/webkit/compositor_bindings/web_float_animation_curve_impl.h
@@ -9,8 +9,8 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatAnimationCurve.h"
 
 namespace cc {
-class CCAnimationCurve;
-class CCKeyframedFloatAnimationCurve;
+class AnimationCurve;
+class KeyframedFloatAnimationCurve;
 }
 
 namespace WebKit {
@@ -30,10 +30,10 @@ public:
 
     virtual float getValue(double time) const OVERRIDE;
 
-    scoped_ptr<cc::CCAnimationCurve> cloneToCCAnimationCurve() const;
+    scoped_ptr<cc::AnimationCurve> cloneToAnimationCurve() const;
 
 private:
-    scoped_ptr<cc::CCKeyframedFloatAnimationCurve> m_curve;
+    scoped_ptr<cc::KeyframedFloatAnimationCurve> m_curve;
 };
 
 }
diff --git a/webkit/compositor_bindings/web_float_animation_curve_unittest.cc b/webkit/compositor_bindings/web_float_animation_curve_unittest.cc
index 04ba715..449a892 100644
--- a/webkit/compositor_bindings/web_float_animation_curve_unittest.cc
+++ b/webkit/compositor_bindings/web_float_animation_curve_unittest.cc
@@ -116,7 +116,7 @@ TEST(WebFloatAnimationCurveTest, EaseTimingFunction)
     curve->add(WebFloatKeyframe(0, 0), WebAnimationCurve::TimingFunctionTypeEase);
     curve->add(WebFloatKeyframe(1, 1), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time));
@@ -143,7 +143,7 @@ TEST(WebFloatAnimationCurveTest, EaseInTimingFunction)
     curve->add(WebFloatKeyframe(0, 0), WebAnimationCurve::TimingFunctionTypeEaseIn);
     curve->add(WebFloatKeyframe(1, 1), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseInTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseInTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time));
@@ -157,7 +157,7 @@ TEST(WebFloatAnimationCurveTest, EaseOutTimingFunction)
     curve->add(WebFloatKeyframe(0, 0), WebAnimationCurve::TimingFunctionTypeEaseOut);
     curve->add(WebFloatKeyframe(1, 1), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseOutTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseOutTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time));
@@ -171,7 +171,7 @@ TEST(WebFloatAnimationCurveTest, EaseInOutTimingFunction)
     curve->add(WebFloatKeyframe(0, 0), WebAnimationCurve::TimingFunctionTypeEaseInOut);
     curve->add(WebFloatKeyframe(1, 1), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseInOutTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseInOutTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time));
@@ -189,7 +189,7 @@ TEST(WebFloatAnimationCurveTest, CustomBezierTimingFunction)
     curve->add(WebFloatKeyframe(0, 0), x1, y1, x2, y2);
     curve->add(WebFloatKeyframe(1, 1), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCCubicBezierTimingFunction::create(x1, y1, x2, y2));
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::CubicBezierTimingFunction::create(x1, y1, x2, y2));
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time));
@@ -203,7 +203,7 @@ TEST(WebFloatAnimationCurveTest, DefaultTimingFunction)
     curve->add(WebFloatKeyframe(0, 0));
     curve->add(WebFloatKeyframe(1, 1), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time));
diff --git a/webkit/compositor_bindings/web_image_layer_impl.cc b/webkit/compositor_bindings/web_image_layer_impl.cc
index f72168f..a40391f 100644
--- a/webkit/compositor_bindings/web_image_layer_impl.cc
+++ b/webkit/compositor_bindings/web_image_layer_impl.cc
@@ -8,7 +8,7 @@
 #include "cc/image_layer.h"
 #include "web_layer_impl.h"
 
-using cc::ImageLayerChromium;
+using cc::ImageLayer;
 
 namespace WebKit {
 
@@ -18,7 +18,7 @@ WebImageLayer* WebImageLayer::create()
 }
 
 WebImageLayerImpl::WebImageLayerImpl()
-    : m_layer(new WebLayerImpl(ImageLayerChromium::create()))
+    : m_layer(new WebLayerImpl(ImageLayer::create()))
 {
 }
 
@@ -33,7 +33,7 @@ WebLayer* WebImageLayerImpl::layer()
 
 void WebImageLayerImpl::setBitmap(SkBitmap bitmap)
 {
-    static_cast<ImageLayerChromium*>(m_layer->layer())->setBitmap(bitmap);
+    static_cast<ImageLayer*>(m_layer->layer())->setBitmap(bitmap);
 }
 
 } // namespace WebKit
diff --git a/webkit/compositor_bindings/web_io_surface_layer_impl.cc b/webkit/compositor_bindings/web_io_surface_layer_impl.cc
index 5e0fd9f..ee56546 100644
--- a/webkit/compositor_bindings/web_io_surface_layer_impl.cc
+++ b/webkit/compositor_bindings/web_io_surface_layer_impl.cc
@@ -9,7 +9,7 @@
 #include "webcore_convert.h"
 #include "web_layer_impl.h"
 
-using cc::IOSurfaceLayerChromium;
+using cc::IOSurfaceLayer;
 
 namespace WebKit {
 
@@ -19,7 +19,7 @@ WebIOSurfaceLayer* WebIOSurfaceLayer::create()
 }
 
 WebIOSurfaceLayerImpl::WebIOSurfaceLayerImpl()
-    : m_layer(new WebLayerImpl(IOSurfaceLayerChromium::create()))
+    : m_layer(new WebLayerImpl(IOSurfaceLayer::create()))
 {
     m_layer->layer()->setIsDrawable(true);
 }
@@ -30,7 +30,7 @@ WebIOSurfaceLayerImpl::~WebIOSurfaceLayerImpl()
 
 void WebIOSurfaceLayerImpl::setIOSurfaceProperties(unsigned ioSurfaceId, WebSize size)
 {
-    static_cast<IOSurfaceLayerChromium*>(m_layer->layer())->setIOSurfaceProperties(ioSurfaceId, convert(size));
+    static_cast<IOSurfaceLayer*>(m_layer->layer())->setIOSurfaceProperties(ioSurfaceId, convert(size));
 }
 
 WebLayer* WebIOSurfaceLayerImpl::layer()
diff --git a/webkit/compositor_bindings/web_layer_impl.cc b/webkit/compositor_bindings/web_layer_impl.cc
index e476598..a54ae74 100644
--- a/webkit/compositor_bindings/web_layer_impl.cc
+++ b/webkit/compositor_bindings/web_layer_impl.cc
@@ -19,8 +19,8 @@
 #include "web_animation_impl.h"
 #include "webcore_convert.h"
 
-using cc::CCActiveAnimation;
-using cc::LayerChromium;
+using cc::ActiveAnimation;
+using cc::Layer;
 
 namespace WebKit {
 
@@ -66,11 +66,11 @@ WebLayer* WebLayer::create()
 }
 
 WebLayerImpl::WebLayerImpl()
-    : m_layer(LayerChromium::create())
+    : m_layer(Layer::create())
 {
 }
 
-WebLayerImpl::WebLayerImpl(scoped_refptr<LayerChromium> layer)
+WebLayerImpl::WebLayerImpl(scoped_refptr<Layer> layer)
     : m_layer(layer)
 {
 }
@@ -294,7 +294,7 @@ void WebLayerImpl::setAnimationDelegate(WebAnimationDelegate* delegate)
 
 bool WebLayerImpl::addAnimation(WebAnimation* animation)
 {
-    return m_layer->addAnimation(static_cast<WebAnimationImpl*>(animation)->cloneToCCAnimation());
+    return m_layer->addAnimation(static_cast<WebAnimationImpl*>(animation)->cloneToAnimation());
 }
 
 void WebLayerImpl::removeAnimation(int animationId)
@@ -304,7 +304,7 @@ void WebLayerImpl::removeAnimation(int animationId)
 
 void WebLayerImpl::removeAnimation(int animationId, WebAnimation::TargetProperty targetProperty)
 {
-    m_layer->layerAnimationController()->removeAnimation(animationId, static_cast<CCActiveAnimation::TargetProperty>(targetProperty));
+    m_layer->layerAnimationController()->removeAnimation(animationId, static_cast<ActiveAnimation::TargetProperty>(targetProperty));
 }
 
 void WebLayerImpl::pauseAnimation(int animationId, double timeOffset)
@@ -433,7 +433,7 @@ void WebLayerImpl::setScrollClient(WebLayerScrollClient* scrollClient)
     m_layer->setLayerScrollClient(scrollClient);
 }
 
-LayerChromium* WebLayerImpl::layer() const
+Layer* WebLayerImpl::layer() const
 {
     return m_layer.get();
 }
diff --git a/webkit/compositor_bindings/web_layer_impl.h b/webkit/compositor_bindings/web_layer_impl.h
index 88a433f..01a7baf 100644
--- a/webkit/compositor_bindings/web_layer_impl.h
+++ b/webkit/compositor_bindings/web_layer_impl.h
@@ -9,7 +9,7 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayer.h"
 
 namespace cc {
-class LayerChromium;
+class Layer;
 }
 
 namespace WebKit {
@@ -17,7 +17,7 @@ namespace WebKit {
 class WebLayerImpl : public WebLayer {
 public:
     WebLayerImpl();
-    explicit WebLayerImpl(scoped_refptr<cc::LayerChromium>);
+    explicit WebLayerImpl(scoped_refptr<cc::Layer>);
     virtual ~WebLayerImpl();
 
     // WebLayer implementation.
@@ -90,10 +90,10 @@ public:
     virtual bool fixedToContainerLayer() const;
     virtual void setScrollClient(WebLayerScrollClient*) OVERRIDE;
 
-    cc::LayerChromium* layer() const;
+    cc::Layer* layer() const;
 
 protected:
-    scoped_refptr<cc::LayerChromium> m_layer;
+    scoped_refptr<cc::Layer> m_layer;
 };
 
 } // namespace WebKit
diff --git a/webkit/compositor_bindings/web_layer_tree_view_impl.cc b/webkit/compositor_bindings/web_layer_tree_view_impl.cc
index 0e27512..e61a166 100644
--- a/webkit/compositor_bindings/web_layer_tree_view_impl.cc
+++ b/webkit/compositor_bindings/web_layer_tree_view_impl.cc
@@ -44,7 +44,7 @@ WebLayerTreeViewImpl::~WebLayerTreeViewImpl()
 
 bool WebLayerTreeViewImpl::initialize(const WebLayerTreeView::Settings& webSettings)
 {
-    CCLayerTreeSettings settings;
+    LayerTreeSettings settings;
     settings.acceleratePainting = webSettings.acceleratePainting;
     settings.showFPSCounter = webSettings.showFPSCounter;
     settings.showPlatformLayerTree = webSettings.showPlatformLayerTree;
@@ -53,7 +53,7 @@ bool WebLayerTreeViewImpl::initialize(const WebLayerTreeView::Settings& webSetti
     settings.refreshRate = webSettings.refreshRate;
     settings.defaultTileSize = convert(webSettings.defaultTileSize);
     settings.maxUntiledLayerSize = convert(webSettings.maxUntiledLayerSize);
-    m_layerTreeHost = CCLayerTreeHost::create(this, settings);
+    m_layerTreeHost = LayerTreeHost::create(this, settings);
     if (!m_layerTreeHost.get())
         return false;
     return true;
@@ -71,7 +71,7 @@ void WebLayerTreeViewImpl::setRootLayer(const WebLayer& root)
 
 void WebLayerTreeViewImpl::clearRootLayer()
 {
-    m_layerTreeHost->setRootLayer(scoped_refptr<LayerChromium>());
+    m_layerTreeHost->setRootLayer(scoped_refptr<Layer>());
 }
 
 void WebLayerTreeViewImpl::setViewportSize(const WebSize& layoutViewportSize, const WebSize& deviceViewportSize)
@@ -144,7 +144,7 @@ bool WebLayerTreeViewImpl::commitRequested() const
 
 void WebLayerTreeViewImpl::composite()
 {
-    if (CCProxy::hasImplThread())
+    if (Proxy::hasImplThread())
         m_layerTreeHost->setNeedsCommit();
     else
         m_layerTreeHost->composite();
@@ -167,7 +167,7 @@ void WebLayerTreeViewImpl::finishAllRendering()
 
 void WebLayerTreeViewImpl::renderingStats(WebRenderingStats& stats) const
 {
-    CCRenderingStats ccStats;
+    RenderingStats ccStats;
     m_layerTreeHost->renderingStats(&ccStats);
 
     stats.numAnimationFrames = ccStats.numAnimationFrames;
@@ -186,7 +186,7 @@ void WebLayerTreeViewImpl::setFontAtlas(SkBitmap bitmap, WebRect asciiToWebRectT
     IntRect asciiToRectTable[128];
     for (int i = 0; i < 128; ++i)
         asciiToRectTable[i] = convert(asciiToWebRectTable[i]);
-    scoped_ptr<CCFontAtlas> fontAtlas = CCFontAtlas::create(bitmap, asciiToRectTable, fontHeight);
+    scoped_ptr<FontAtlas> fontAtlas = FontAtlas::create(bitmap, asciiToRectTable, fontHeight);
     m_layerTreeHost->setFontAtlas(fontAtlas.Pass());
 }
 
@@ -230,9 +230,9 @@ void WebLayerTreeViewImpl::didRecreateOutputSurface(bool success)
     m_client->didRecreateOutputSurface(success);
 }
 
-scoped_ptr<CCInputHandler> WebLayerTreeViewImpl::createInputHandler()
+scoped_ptr<InputHandler> WebLayerTreeViewImpl::createInputHandler()
 {
-    scoped_ptr<CCInputHandler> ret;
+    scoped_ptr<InputHandler> ret;
     scoped_ptr<WebInputHandler> handler(m_client->createInputHandler());
     if (handler)
         ret = WebToCCInputHandlerAdapter::create(handler.Pass());
diff --git a/webkit/compositor_bindings/web_layer_tree_view_impl.h b/webkit/compositor_bindings/web_layer_tree_view_impl.h
index f9b9e11..9b0ecbf 100644
--- a/webkit/compositor_bindings/web_layer_tree_view_impl.h
+++ b/webkit/compositor_bindings/web_layer_tree_view_impl.h
@@ -10,7 +10,7 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerTreeView.h"
 
 namespace cc {
-class CCLayerTreeHost;
+class LayerTreeHost;
 }
 
 namespace WebKit {
@@ -18,7 +18,7 @@ class WebLayer;
 class WebLayerTreeViewClient;
 class WebLayerTreeViewClientAdapter;
 
-class WebLayerTreeViewImpl : public WebLayerTreeView, public cc::CCLayerTreeHostClient {
+class WebLayerTreeViewImpl : public WebLayerTreeView, public cc::LayerTreeHostClient {
 public:
     explicit WebLayerTreeViewImpl(WebLayerTreeViewClient*);
     virtual ~WebLayerTreeViewImpl();
@@ -50,7 +50,7 @@ public:
     virtual void setFontAtlas(SkBitmap, WebRect asciiToRectTable[128], int fontHeight) OVERRIDE;
     virtual void loseCompositorContext(int numTimes) OVERRIDE;
 
-    // cc::CCLayerTreeHostClient implementation.
+    // cc::LayerTreeHostClient implementation.
     virtual void willBeginFrame() OVERRIDE;
     virtual void didBeginFrame() OVERRIDE;
     virtual void animate(double monotonicFrameBeginTime) OVERRIDE;
@@ -58,7 +58,7 @@ public:
     virtual void applyScrollAndScale(const cc::IntSize& scrollDelta, float pageScale) OVERRIDE;
     virtual scoped_ptr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
     virtual void didRecreateOutputSurface(bool success) OVERRIDE;
-    virtual scoped_ptr<cc::CCInputHandler> createInputHandler() OVERRIDE;
+    virtual scoped_ptr<cc::InputHandler> createInputHandler() OVERRIDE;
     virtual void willCommit() OVERRIDE;
     virtual void didCommit() OVERRIDE;
     virtual void didCommitAndDrawFrame() OVERRIDE;
@@ -67,7 +67,7 @@ public:
 
 private:
     WebLayerTreeViewClient* m_client;
-    scoped_ptr<cc::CCLayerTreeHost> m_layerTreeHost;
+    scoped_ptr<cc::LayerTreeHost> m_layerTreeHost;
 };
 
 } // namespace WebKit
diff --git a/webkit/compositor_bindings/web_scrollbar_layer_impl.cc b/webkit/compositor_bindings/web_scrollbar_layer_impl.cc
index 0b80806..c9fffb6 100644
--- a/webkit/compositor_bindings/web_scrollbar_layer_impl.cc
+++ b/webkit/compositor_bindings/web_scrollbar_layer_impl.cc
@@ -8,7 +8,7 @@
 #include "cc/scrollbar_layer.h"
 #include "web_layer_impl.h"
 
-using cc::ScrollbarLayerChromium;
+using cc::ScrollbarLayer;
 
 namespace WebKit {
 
@@ -19,7 +19,7 @@ WebScrollbarLayer* WebScrollbarLayer::create(WebScrollbar* scrollbar, WebScrollb
 
 
 WebScrollbarLayerImpl::WebScrollbarLayerImpl(WebScrollbar* scrollbar, WebScrollbarThemePainter painter, WebScrollbarThemeGeometry* geometry)
-    : m_layer(new WebLayerImpl(ScrollbarLayerChromium::create(make_scoped_ptr(scrollbar), painter, make_scoped_ptr(geometry), 0)))
+    : m_layer(new WebLayerImpl(ScrollbarLayer::create(make_scoped_ptr(scrollbar), painter, make_scoped_ptr(geometry), 0)))
 {
 }
 
@@ -35,7 +35,7 @@ WebLayer* WebScrollbarLayerImpl::layer()
 void WebScrollbarLayerImpl::setScrollLayer(WebLayer* layer)
 {
     int id = layer ? static_cast<WebLayerImpl*>(layer)->layer()->id() : 0;
-    static_cast<ScrollbarLayerChromium*>(m_layer->layer())->setScrollLayerId(id);
+    static_cast<ScrollbarLayer*>(m_layer->layer())->setScrollLayerId(id);
 }
 
 
diff --git a/webkit/compositor_bindings/web_solid_color_layer_impl.cc b/webkit/compositor_bindings/web_solid_color_layer_impl.cc
index 177d657..62f8c8d 100644
--- a/webkit/compositor_bindings/web_solid_color_layer_impl.cc
+++ b/webkit/compositor_bindings/web_solid_color_layer_impl.cc
@@ -8,7 +8,7 @@
 #include "cc/solid_color_layer.h"
 #include "web_layer_impl.h"
 
-using cc::SolidColorLayerChromium;
+using cc::SolidColorLayer;
 
 namespace WebKit {
 
@@ -18,7 +18,7 @@ WebSolidColorLayer* WebSolidColorLayer::create()
 }
 
 WebSolidColorLayerImpl::WebSolidColorLayerImpl()
-    : m_layer(new WebLayerImpl(SolidColorLayerChromium::create()))
+    : m_layer(new WebLayerImpl(SolidColorLayer::create()))
 {
     m_layer->layer()->setIsDrawable(true);
 }
diff --git a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc
index 31341de..3bb1b27 100644
--- a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc
+++ b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.cc
@@ -14,11 +14,11 @@
 #define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, cc_name) \
     COMPILE_ASSERT(int(WebKit::webkit_name) == int(cc::cc_name), mismatching_enums)
 
-COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollStatusOnMainThread, CCInputHandlerClient::ScrollOnMainThread);
-COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollStatusStarted, CCInputHandlerClient::ScrollStarted);
-COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollStatusIgnored, CCInputHandlerClient::ScrollIgnored);
-COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollInputTypeGesture, CCInputHandlerClient::Gesture);
-COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollInputTypeWheel, CCInputHandlerClient::Wheel);
+COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollStatusOnMainThread, InputHandlerClient::ScrollOnMainThread);
+COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollStatusStarted, InputHandlerClient::ScrollStarted);
+COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollStatusIgnored, InputHandlerClient::ScrollIgnored);
+COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollInputTypeGesture, InputHandlerClient::Gesture);
+COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollInputTypeWheel, InputHandlerClient::Wheel);
 
 namespace WebKit {
 
@@ -38,7 +38,7 @@ WebToCCInputHandlerAdapter::~WebToCCInputHandlerAdapter()
 
 class WebToCCInputHandlerAdapter::ClientAdapter : public WebInputHandlerClient {
 public:
-    ClientAdapter(cc::CCInputHandlerClient* client)
+    ClientAdapter(cc::InputHandlerClient* client)
         : m_client(client)
     {
     }
@@ -49,7 +49,7 @@ public:
 
     virtual ScrollStatus scrollBegin(WebPoint point, ScrollInputType type) OVERRIDE
     {
-        return static_cast<WebInputHandlerClient::ScrollStatus>(m_client->scrollBegin(convert(point), static_cast<cc::CCInputHandlerClient::ScrollInputType>(type)));
+        return static_cast<WebInputHandlerClient::ScrollStatus>(m_client->scrollBegin(convert(point), static_cast<cc::InputHandlerClient::ScrollInputType>(type)));
     }
 
     virtual void scrollBy(WebPoint point, WebSize offset) OVERRIDE
@@ -92,11 +92,11 @@ public:
     }
 
 private:
-    cc::CCInputHandlerClient* m_client;
+    cc::InputHandlerClient* m_client;
 };
 
 
-void WebToCCInputHandlerAdapter::bindToClient(cc::CCInputHandlerClient* client)
+void WebToCCInputHandlerAdapter::bindToClient(cc::InputHandlerClient* client)
 {
     m_clientAdapter.reset(new ClientAdapter(client));
     m_handler->bindToClient(m_clientAdapter.get());
diff --git a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h
index 7cbf3244..359b591 100644
--- a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h
+++ b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h
@@ -11,13 +11,13 @@
 
 namespace WebKit {
 
-class WebToCCInputHandlerAdapter : public cc::CCInputHandler {
+class WebToCCInputHandlerAdapter : public cc::InputHandler {
 public:
     static scoped_ptr<WebToCCInputHandlerAdapter> create(scoped_ptr<WebInputHandler>);
     virtual ~WebToCCInputHandlerAdapter();
 
-    // cc::CCInputHandler implementation.
-    virtual void bindToClient(cc::CCInputHandlerClient*) OVERRIDE;
+    // cc::InputHandler implementation.
+    virtual void bindToClient(cc::InputHandlerClient*) OVERRIDE;
     virtual void animate(double monotonicTime) OVERRIDE;
 
 private:
diff --git a/webkit/compositor_bindings/web_transform_animation_curve_impl.cc b/webkit/compositor_bindings/web_transform_animation_curve_impl.cc
index 139ae05..07c75f3 100644
--- a/webkit/compositor_bindings/web_transform_animation_curve_impl.cc
+++ b/webkit/compositor_bindings/web_transform_animation_curve_impl.cc
@@ -18,7 +18,7 @@ WebTransformAnimationCurve* WebTransformAnimationCurve::create()
 }
 
 WebTransformAnimationCurveImpl::WebTransformAnimationCurveImpl()
-    : m_curve(cc::CCKeyframedTransformAnimationCurve::create())
+    : m_curve(cc::KeyframedTransformAnimationCurve::create())
 {
 }
 
@@ -38,12 +38,12 @@ void WebTransformAnimationCurveImpl::add(const WebTransformKeyframe& keyframe)
 
 void WebTransformAnimationCurveImpl::add(const WebTransformKeyframe& keyframe, TimingFunctionType type)
 {
-    m_curve->addKeyframe(cc::CCTransformKeyframe::create(keyframe.time, keyframe.value, createTimingFunction(type)));
+    m_curve->addKeyframe(cc::TransformKeyframe::create(keyframe.time, keyframe.value, createTimingFunction(type)));
 }
 
 void WebTransformAnimationCurveImpl::add(const WebTransformKeyframe& keyframe, double x1, double y1, double x2, double y2)
 {
-    m_curve->addKeyframe(cc::CCTransformKeyframe::create(keyframe.time, keyframe.value, cc::CCCubicBezierTimingFunction::create(x1, y1, x2, y2).PassAs<cc::CCTimingFunction>()));
+    m_curve->addKeyframe(cc::TransformKeyframe::create(keyframe.time, keyframe.value, cc::CubicBezierTimingFunction::create(x1, y1, x2, y2).PassAs<cc::TimingFunction>()));
 }
 
 WebTransformationMatrix WebTransformAnimationCurveImpl::getValue(double time) const
@@ -51,7 +51,7 @@ WebTransformationMatrix WebTransformAnimationCurveImpl::getValue(double time) co
     return m_curve->getValue(time);
 }
 
-scoped_ptr<cc::CCAnimationCurve> WebTransformAnimationCurveImpl::cloneToCCAnimationCurve() const
+scoped_ptr<cc::AnimationCurve> WebTransformAnimationCurveImpl::cloneToAnimationCurve() const
 {
     return m_curve->clone();
 }
diff --git a/webkit/compositor_bindings/web_transform_animation_curve_impl.h b/webkit/compositor_bindings/web_transform_animation_curve_impl.h
index 51a8011..94ba09f 100644
--- a/webkit/compositor_bindings/web_transform_animation_curve_impl.h
+++ b/webkit/compositor_bindings/web_transform_animation_curve_impl.h
@@ -9,8 +9,8 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebTransformAnimationCurve.h"
 
 namespace cc {
-class CCAnimationCurve;
-class CCKeyframedTransformAnimationCurve;
+class AnimationCurve;
+class KeyframedTransformAnimationCurve;
 }
 
 namespace WebKit {
@@ -30,10 +30,10 @@ public:
 
     virtual WebTransformationMatrix getValue(double time) const OVERRIDE;
 
-    scoped_ptr<cc::CCAnimationCurve> cloneToCCAnimationCurve() const;
+    scoped_ptr<cc::AnimationCurve> cloneToAnimationCurve() const;
 
 private:
-    scoped_ptr<cc::CCKeyframedTransformAnimationCurve> m_curve;
+    scoped_ptr<cc::KeyframedTransformAnimationCurve> m_curve;
 };
 
 }
diff --git a/webkit/compositor_bindings/web_transform_animation_curve_unittest.cc b/webkit/compositor_bindings/web_transform_animation_curve_unittest.cc
index f278b85..2ca4e48 100644
--- a/webkit/compositor_bindings/web_transform_animation_curve_unittest.cc
+++ b/webkit/compositor_bindings/web_transform_animation_curve_unittest.cc
@@ -153,7 +153,7 @@ TEST(WebTransformAnimationCurveTest, EaseTimingFunction)
     curve->add(WebTransformKeyframe(0, operations1), WebAnimationCurve::TimingFunctionTypeEase);
     curve->add(WebTransformKeyframe(1, operations2), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time).m41());
@@ -188,7 +188,7 @@ TEST(WebTransformAnimationCurveTest, EaseInTimingFunction)
     curve->add(WebTransformKeyframe(0, operations1), WebAnimationCurve::TimingFunctionTypeEaseIn);
     curve->add(WebTransformKeyframe(1, operations2), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseInTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseInTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time).m41());
@@ -206,7 +206,7 @@ TEST(WebTransformAnimationCurveTest, EaseOutTimingFunction)
     curve->add(WebTransformKeyframe(0, operations1), WebAnimationCurve::TimingFunctionTypeEaseOut);
     curve->add(WebTransformKeyframe(1, operations2), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseOutTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseOutTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time).m41());
@@ -224,7 +224,7 @@ TEST(WebTransformAnimationCurveTest, EaseInOutTimingFunction)
     curve->add(WebTransformKeyframe(0, operations1), WebAnimationCurve::TimingFunctionTypeEaseInOut);
     curve->add(WebTransformKeyframe(1, operations2), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseInOutTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseInOutTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time).m41());
@@ -246,7 +246,7 @@ TEST(WebTransformAnimationCurveTest, CustomBezierTimingFunction)
     curve->add(WebTransformKeyframe(0, operations1), x1, y1, x2, y2);
     curve->add(WebTransformKeyframe(1, operations2), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCCubicBezierTimingFunction::create(x1, y1, x2, y2));
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::CubicBezierTimingFunction::create(x1, y1, x2, y2));
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time).m41());
@@ -264,7 +264,7 @@ TEST(WebTransformAnimationCurveTest, DefaultTimingFunction)
     curve->add(WebTransformKeyframe(0, operations1));
     curve->add(WebTransformKeyframe(1, operations2), WebAnimationCurve::TimingFunctionTypeLinear);
 
-    scoped_ptr<cc::CCTimingFunction> timingFunction(cc::CCEaseTimingFunction::create());
+    scoped_ptr<cc::TimingFunction> timingFunction(cc::EaseTimingFunction::create());
     for (int i = 0; i <= 4; ++i) {
         const double time = i * 0.25;
         EXPECT_FLOAT_EQ(timingFunction->getValue(time), curve->getValue(time).m41());
diff --git a/webkit/compositor_bindings/web_video_layer_impl.cc b/webkit/compositor_bindings/web_video_layer_impl.cc
index 34cb1f6..95f16c6 100644
--- a/webkit/compositor_bindings/web_video_layer_impl.cc
+++ b/webkit/compositor_bindings/web_video_layer_impl.cc
@@ -16,7 +16,7 @@ WebVideoLayer* WebVideoLayer::create(WebVideoFrameProvider* provider)
 }
 
 WebVideoLayerImpl::WebVideoLayerImpl(WebVideoFrameProvider* provider)
-    : m_layer(new WebLayerImpl(cc::VideoLayerChromium::create(provider)))
+    : m_layer(new WebLayerImpl(cc::VideoLayer::create(provider)))
 {
 }