cc: Rename cc classes and members to match filenames

cc/thread_proxy.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 "config.h"
 
 #include "CCThreadProxy.h"
 
 #include "CCDelayBasedTimeSource.h"
 #include "CCDrawQuad.h"
@@ skipping 12 matching lines @@
 
 namespace {
 
 // Measured in seconds.
 const double contextRecreationTickRate = 0.03;
 
 }  // namespace
 
 namespace cc {
 
-scoped_ptr<CCProxy> CCThreadProxy::create(CCLayerTreeHost* layerTreeHost)
+scoped_ptr<Proxy> ThreadProxy::create(LayerTreeHost* layerTreeHost)
 {
-    return make_scoped_ptr(new CCThreadProxy(layerTreeHost)).PassAs<CCProxy>();
+    return make_scoped_ptr(new ThreadProxy(layerTreeHost)).PassAs<Proxy>();
 }
 
-CCThreadProxy::CCThreadProxy(CCLayerTreeHost* layerTreeHost)
+ThreadProxy::ThreadProxy(LayerTreeHost* layerTreeHost)
     : m_animateRequested(false)
     , m_commitRequested(false)
     , m_commitRequestSentToImplThread(false)
     , m_forcedCommitRequested(false)
     , m_layerTreeHost(layerTreeHost)
     , m_rendererInitialized(false)
     , m_started(false)
     , m_texturesAcquired(true)
     , m_inCompositeAndReadback(false)
-    , m_mainThreadProxy(CCScopedThreadProxy::create(CCProxy::mainThread()))
+    , m_mainThreadProxy(ScopedThreadProxy::create(Proxy::mainThread()))
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
     , m_totalCommitCount(0)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::CCThreadProxy");
+    TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     ASSERT(isMainThread());
 }
 
-CCThreadProxy::~CCThreadProxy()
+ThreadProxy::~ThreadProxy()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::~CCThreadProxy");
+    TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
     ASSERT(isMainThread());
     ASSERT(!m_started);
 }
 
-bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
+bool ThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
 {
-    TRACE_EVENT0("cc", "CCThreadPRoxy::compositeAndReadback");
+    TRACE_EVENT0("cc", "ThreadPRoxy::compositeAndReadback");
     ASSERT(isMainThread());
     ASSERT(m_layerTreeHost);
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "compositeAndReadback_EarlyOut_LR_Uninitialized");
         return false;
     }
 
 
     // Perform a synchronous commit.
     {
         DebugScopedSetMainThreadBlocked mainThreadBlocked;
-        CCCompletionEvent beginFrameCompletion;
-        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));
+        CompletionEvent beginFrameCompletion;
+        Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::forceBeginFrameOnImplThread, &beginFrameCompletion));
         beginFrameCompletion.wait();
     }
     m_inCompositeAndReadback = true;
     beginFrame();
     m_inCompositeAndReadback = false;
 
     // Perform a synchronous readback.
     ReadbackRequest request;
     request.rect = rect;
     request.pixels = pixels;
     {
         DebugScopedSetMainThreadBlocked mainThreadBlocked;
-        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestReadbackOnImplThread, &request));
+        Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::requestReadbackOnImplThread, &request));
         request.completion.wait();
     }
     return request.success;
 }
 
-void CCThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
+void ThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
 {
-    ASSERT(CCProxy::isImplThread());
+    ASSERT(Proxy::isImplThread());
     ASSERT(!m_readbackRequestOnImplThread);
     if (!m_layerTreeHostImpl.get()) {
         request->success = false;
         request->completion.signal();
         return;
     }
 
     m_readbackRequestOnImplThread = request;
     m_schedulerOnImplThread->setNeedsRedraw();
     m_schedulerOnImplThread->setNeedsForcedRedraw();
 }
 
-void CCThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration)
+void ThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration)
 {
-    ASSERT(CCProxy::isMainThread());
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestStartPageScaleAnimationOnImplThread, targetPosition, useAnchor, scale, duration));
+    ASSERT(Proxy::isMainThread());
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::requestStartPageScaleAnimationOnImplThread, targetPosition, useAnchor, scale, duration));
 }
 
-void CCThreadProxy::requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double duration)
+void ThreadProxy::requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double duration)
 {
-    ASSERT(CCProxy::isImplThread());
+    ASSERT(Proxy::isImplThread());
     if (m_layerTreeHostImpl.get())
         m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, monotonicallyIncreasingTime(), duration);
 }
 
-void CCThreadProxy::finishAllRendering()
+void ThreadProxy::finishAllRendering()
 {
-    ASSERT(CCProxy::isMainThread());
+    ASSERT(Proxy::isMainThread());
 
     // Make sure all GL drawing is finished on the impl thread.
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCCompletionEvent completion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::finishAllRenderingOnImplThread, &completion));
+    CompletionEvent completion;
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::finishAllRenderingOnImplThread, &completion));
     completion.wait();
 }
 
-bool CCThreadProxy::isStarted() const
+bool ThreadProxy::isStarted() const
 {
-    ASSERT(CCProxy::isMainThread());
+    ASSERT(Proxy::isMainThread());
     return m_started;
 }
 
-bool CCThreadProxy::initializeContext()
+bool ThreadProxy::initializeContext()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::initializeContext");
-    scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
+    TRACE_EVENT0("cc", "ThreadProxy::initializeContext");
+    scoped_ptr<GraphicsContext> context = m_layerTreeHost->createContext();
     if (!context.get())
         return false;
 
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeContextOnImplThread,
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::initializeContextOnImplThread,
                                                        context.release()));
     return true;
 }
 
-void CCThreadProxy::setSurfaceReady()
+void ThreadProxy::setSurfaceReady()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::setSurfaceReady");
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setSurfaceReadyOnImplThread));
+    TRACE_EVENT0("cc", "ThreadProxy::setSurfaceReady");
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setSurfaceReadyOnImplThread));
 }
 
-void CCThreadProxy::setSurfaceReadyOnImplThread()
+void ThreadProxy::setSurfaceReadyOnImplThread()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::setSurfaceReadyOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::setSurfaceReadyOnImplThread");
     m_schedulerOnImplThread->setCanBeginFrame(true);
 }
 
-void CCThreadProxy::setVisible(bool visible)
+void ThreadProxy::setVisible(bool visible)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::setVisible");
+    TRACE_EVENT0("cc", "ThreadProxy::setVisible");
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCCompletionEvent completion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setVisibleOnImplThread, &completion, visible));
+    CompletionEvent completion;
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setVisibleOnImplThread, &completion, visible));
     completion.wait();
 }
 
-void CCThreadProxy::setVisibleOnImplThread(CCCompletionEvent* completion, bool visible)
+void ThreadProxy::setVisibleOnImplThread(CompletionEvent* completion, bool visible)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::setVisibleOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::setVisibleOnImplThread");
     m_layerTreeHostImpl->setVisible(visible);
     m_schedulerOnImplThread->setVisible(visible);
     completion->signal();
 }
 
-bool CCThreadProxy::initializeRenderer()
+bool ThreadProxy::initializeRenderer()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::initializeRenderer");
+    TRACE_EVENT0("cc", "ThreadProxy::initializeRenderer");
     // Make a blocking call to initializeRendererOnImplThread. The results of that call
     // are pushed into the initializeSucceeded and capabilities local variables.
-    CCCompletionEvent completion;
+    CompletionEvent completion;
     bool initializeSucceeded = false;
     RendererCapabilities capabilities;
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeRendererOnImplThread,
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::initializeRendererOnImplThread,
                                                        &completion,
                                                        &initializeSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (initializeSucceeded) {
         m_rendererInitialized = true;
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     }
     return initializeSucceeded;
 }
 
-bool CCThreadProxy::recreateContext()
+bool ThreadProxy::recreateContext()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::recreateContext");
+    TRACE_EVENT0("cc", "ThreadProxy::recreateContext");
     ASSERT(isMainThread());
 
     // Try to create the context.
-    scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
+    scoped_ptr<GraphicsContext> context = m_layerTreeHost->createContext();
     if (!context.get())
         return false;
     if (m_layerTreeHost->needsSharedContext())
         if (!WebSharedGraphicsContext3D::createCompositorThreadContext())
             return false;
 
     // Make a blocking call to recreateContextOnImplThread. The results of that
     // call are pushed into the recreateSucceeded and capabilities local
     // variables.
-    CCCompletionEvent completion;
+    CompletionEvent completion;
     bool recreateSucceeded = false;
     RendererCapabilities capabilities;
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::recreateContextOnImplThread,
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::recreateContextOnImplThread,
                                                        &completion,
                                                        context.release(),
                                                        &recreateSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (recreateSucceeded)
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     return recreateSucceeded;
 }
 
-void CCThreadProxy::renderingStats(CCRenderingStats* stats)
+void ThreadProxy::renderingStats(RenderingStats* stats)
 {
     ASSERT(isMainThread());
 
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCCompletionEvent completion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::renderingStatsOnImplThread,
+    CompletionEvent completion;
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::renderingStatsOnImplThread,
                                                        &completion,
                                                        stats));
     stats->totalCommitTimeInSeconds = m_totalCommitTime.InSecondsF();
     stats->totalCommitCount = m_totalCommitCount;
 
     completion.wait();
 }
 
-const RendererCapabilities& CCThreadProxy::rendererCapabilities() const
+const RendererCapabilities& ThreadProxy::rendererCapabilities() const
 {
     ASSERT(m_rendererInitialized);
     return m_RendererCapabilitiesMainThreadCopy;
 }
 
-void CCThreadProxy::loseContext()
+void ThreadProxy::loseContext()
 {
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::didLoseContextOnImplThread));
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::didLoseContextOnImplThread));
 }
 
-void CCThreadProxy::setNeedsAnimate()
+void ThreadProxy::setNeedsAnimate()
 {
     ASSERT(isMainThread());
     if (m_animateRequested)
         return;
 
-    TRACE_EVENT0("cc", "CCThreadProxy::setNeedsAnimate");
+    TRACE_EVENT0("cc", "ThreadProxy::setNeedsAnimate");
     m_animateRequested = true;
 
     if (m_commitRequestSentToImplThread)
         return;
     m_commitRequestSentToImplThread = true;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsCommitOnImplThread));
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setNeedsCommitOnImplThread));
 }
 
-void CCThreadProxy::setNeedsCommit()
+void ThreadProxy::setNeedsCommit()
 {
     ASSERT(isMainThread());
     if (m_commitRequested)
         return;
-    TRACE_EVENT0("cc", "CCThreadProxy::setNeedsCommit");
+    TRACE_EVENT0("cc", "ThreadProxy::setNeedsCommit");
     m_commitRequested = true;
 
     if (m_commitRequestSentToImplThread)
         return;
     m_commitRequestSentToImplThread = true;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsCommitOnImplThread));
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setNeedsCommitOnImplThread));
 }
 
-void CCThreadProxy::didLoseContextOnImplThread()
+void ThreadProxy::didLoseContextOnImplThread()
 {
     ASSERT(isImplThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::didLoseContextOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::didLoseContextOnImplThread");
     m_schedulerOnImplThread->didLoseContext();
 }
 
-void CCThreadProxy::onSwapBuffersCompleteOnImplThread()
+void ThreadProxy::onSwapBuffersCompleteOnImplThread()
 {
     ASSERT(isImplThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::onSwapBuffersCompleteOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::onSwapBuffersCompleteOnImplThread");
     m_schedulerOnImplThread->didSwapBuffersComplete();
-    m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::didCompleteSwapBuffers));
+    m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::didCompleteSwapBuffers));
 }
 
-void CCThreadProxy::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
+void ThreadProxy::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
 {
     ASSERT(isImplThread());
-    TRACE_EVENT2("cc", "CCThreadProxy::onVSyncParametersChanged", "monotonicTimebase", monotonicTimebase, "intervalInSeconds", intervalInSeconds);
+    TRACE_EVENT2("cc", "ThreadProxy::onVSyncParametersChanged", "monotonicTimebase", monotonicTimebase, "intervalInSeconds", intervalInSeconds);
     base::TimeTicks timebase = base::TimeTicks::FromInternalValue(monotonicTimebase * base::Time::kMicrosecondsPerSecond);
     base::TimeDelta interval = base::TimeDelta::FromMicroseconds(intervalInSeconds * base::Time::kMicrosecondsPerSecond);
     m_schedulerOnImplThread->setTimebaseAndInterval(timebase, interval);
 }
 
-void CCThreadProxy::onCanDrawStateChanged(bool canDraw)
+void ThreadProxy::onCanDrawStateChanged(bool canDraw)
 {
     ASSERT(isImplThread());
-    TRACE_EVENT1("cc", "CCThreadProxy::onCanDrawStateChanged", "canDraw", canDraw);
+    TRACE_EVENT1("cc", "ThreadProxy::onCanDrawStateChanged", "canDraw", canDraw);
     m_schedulerOnImplThread->setCanDraw(canDraw);
 }
 
-void CCThreadProxy::setNeedsCommitOnImplThread()
+void ThreadProxy::setNeedsCommitOnImplThread()
 {
     ASSERT(isImplThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::setNeedsCommitOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::setNeedsCommitOnImplThread");
     m_schedulerOnImplThread->setNeedsCommit();
 }
 
-void CCThreadProxy::setNeedsForcedCommitOnImplThread()
+void ThreadProxy::setNeedsForcedCommitOnImplThread()
 {
     ASSERT(isImplThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::setNeedsForcedCommitOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::setNeedsForcedCommitOnImplThread");
     m_schedulerOnImplThread->setNeedsCommit();
     m_schedulerOnImplThread->setNeedsForcedCommit();
 }
 
-void CCThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<CCAnimationEventsVector> events, double wallClockTime)
+void ThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, double wallClockTime)
 {
     ASSERT(isImplThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::postAnimationEventsToMainThreadOnImplThread");
-    m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::setAnimationEvents, events.release(), wallClockTime));
+    TRACE_EVENT0("cc", "ThreadProxy::postAnimationEventsToMainThreadOnImplThread");
+    m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::setAnimationEvents, events.release(), wallClockTime));
 }
 
-bool CCThreadProxy::reduceContentsTextureMemoryOnImplThread(size_t limitBytes)
+bool ThreadProxy::reduceContentsTextureMemoryOnImplThread(size_t limitBytes)
 {
     ASSERT(isImplThread());
 
     if (!m_layerTreeHost->contentsTextureManager())
         return false;
 
     if (!m_layerTreeHost->contentsTextureManager()->reduceMemoryOnImplThread(limitBytes, m_layerTreeHostImpl->resourceProvider()))
         return false;
 
     // The texture upload queue may reference textures that were just purged, clear
     // them from the queue.
     if (m_currentTextureUpdateControllerOnImplThread.get())
         m_currentTextureUpdateControllerOnImplThread->discardUploadsToEvictedResources();
     return true;
 }
 
-void CCThreadProxy::setNeedsRedraw()
+void ThreadProxy::setNeedsRedraw()
 {
     ASSERT(isMainThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::setNeedsRedraw");
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setFullRootLayerDamageOnImplThread));
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsRedrawOnImplThread));
+    TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedraw");
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setFullRootLayerDamageOnImplThread));
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::setNeedsRedrawOnImplThread));
 }
 
-bool CCThreadProxy::commitRequested() const
+bool ThreadProxy::commitRequested() const
 {
     ASSERT(isMainThread());
     return m_commitRequested;
 }
 
-void CCThreadProxy::setNeedsRedrawOnImplThread()
+void ThreadProxy::setNeedsRedrawOnImplThread()
 {
     ASSERT(isImplThread());
-    TRACE_EVENT0("cc", "CCThreadProxy::setNeedsRedrawOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedrawOnImplThread");
     m_schedulerOnImplThread->setNeedsRedraw();
 }
 
-void CCThreadProxy::start()
+void ThreadProxy::start()
 {
     ASSERT(isMainThread());
-    ASSERT(CCProxy::implThread());
+    ASSERT(Proxy::implThread());
     // Create LayerTreeHostImpl.
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCCompletionEvent completion;
-    scoped_ptr<CCInputHandler> handler = m_layerTreeHost->createInputHandler();
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeImplOnImplThread, &completion, handler.release()));
+    CompletionEvent completion;
+    scoped_ptr<InputHandler> handler = m_layerTreeHost->createInputHandler();
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::initializeImplOnImplThread, &completion, handler.release()));
     completion.wait();
 
     m_started = true;
 }
 
-void CCThreadProxy::stop()
+void ThreadProxy::stop()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::stop");
+    TRACE_EVENT0("cc", "ThreadProxy::stop");
     ASSERT(isMainThread());
     ASSERT(m_started);
 
     // Synchronously deletes the impl.
     {
         DebugScopedSetMainThreadBlocked mainThreadBlocked;
 
-        CCCompletionEvent completion;
-        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::layerTreeHostClosedOnImplThread, &completion));
+        CompletionEvent completion;
+        Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::layerTreeHostClosedOnImplThread, &completion));
         completion.wait();
     }
 
     m_mainThreadProxy->shutdown(); // Stop running tasks posted to us.
 
     ASSERT(!m_layerTreeHostImpl.get()); // verify that the impl deleted.
     m_layerTreeHost = 0;
     m_started = false;
 }
 
-void CCThreadProxy::forceSerializeOnSwapBuffers()
+void ThreadProxy::forceSerializeOnSwapBuffers()
 {
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCCompletionEvent completion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread, &completion));
+    CompletionEvent completion;
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::forceSerializeOnSwapBuffersOnImplThread, &completion));
     completion.wait();
 }
 
-void CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent* completion)
+void ThreadProxy::forceSerializeOnSwapBuffersOnImplThread(CompletionEvent* completion)
 {
     if (m_rendererInitialized)
         m_layerTreeHostImpl->renderer()->doNoOp();
     completion->signal();
 }
 
 
-void CCThreadProxy::finishAllRenderingOnImplThread(CCCompletionEvent* completion)
+void ThreadProxy::finishAllRenderingOnImplThread(CompletionEvent* completion)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::finishAllRenderingOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::finishAllRenderingOnImplThread");
     ASSERT(isImplThread());
     m_layerTreeHostImpl->finishAllRendering();
     completion->signal();
 }
 
-void CCThreadProxy::forceBeginFrameOnImplThread(CCCompletionEvent* completion)
+void ThreadProxy::forceBeginFrameOnImplThread(CompletionEvent* completion)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::forceBeginFrameOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::forceBeginFrameOnImplThread");
     ASSERT(!m_beginFrameCompletionEventOnImplThread);
 
     if (m_schedulerOnImplThread->commitPending()) {
         completion->signal();
         return;
     }
 
     m_beginFrameCompletionEventOnImplThread = completion;
     setNeedsForcedCommitOnImplThread();
 }
 
-void CCThreadProxy::scheduledActionBeginFrame()
+void ThreadProxy::scheduledActionBeginFrame()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionBeginFrame");
+    TRACE_EVENT0("cc", "ThreadProxy::scheduledActionBeginFrame");
     ASSERT(!m_pendingBeginFrameRequest);
     m_pendingBeginFrameRequest = make_scoped_ptr(new BeginFrameAndCommitState());
     m_pendingBeginFrameRequest->monotonicFrameBeginTime = monotonicallyIncreasingTime();
     m_pendingBeginFrameRequest->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
     m_pendingBeginFrameRequest->implTransform = m_layerTreeHostImpl->implTransform();
     m_pendingBeginFrameRequest->memoryAllocationLimitBytes = m_layerTreeHostImpl->memoryAllocationLimitBytes();
     if (m_layerTreeHost->contentsTextureManager())
          m_layerTreeHost->contentsTextureManager()->getEvictedBackings(m_pendingBeginFrameRequest->evictedContentsTexturesBackings);
 
-    m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrame));
+    m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::beginFrame));
 
     if (m_beginFrameCompletionEventOnImplThread) {
         m_beginFrameCompletionEventOnImplThread->signal();
         m_beginFrameCompletionEventOnImplThread = 0;
     }
 }
 
-void CCThreadProxy::beginFrame()
+void ThreadProxy::beginFrame()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::beginFrame");
+    TRACE_EVENT0("cc", "ThreadProxy::beginFrame");
     ASSERT(isMainThread());
     if (!m_layerTreeHost)
         return;
 
     if (!m_pendingBeginFrameRequest) {
         TRACE_EVENT0("cc", "EarlyOut_StaleBeginFrameMessage");
         return;
     }
 
     if (m_layerTreeHost->needsSharedContext() && !WebSharedGraphicsContext3D::haveCompositorThreadContext())
@@ skipping 18 matching lines @@
     // Re-do the commit flow so that we don't send the scrollInfo on the BFAC message.
     m_layerTreeHost->applyScrollAndScale(*request->scrollInfo);
     m_layerTreeHost->setImplTransform(request->implTransform);
 
     if (!m_inCompositeAndReadback && !m_layerTreeHost->visible()) {
         m_commitRequested = false;
         m_commitRequestSentToImplThread = false;
         m_forcedCommitRequested = false;
 
         TRACE_EVENT0("cc", "EarlyOut_NotVisible");
-        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrameAbortedOnImplThread));
+        Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::beginFrameAbortedOnImplThread));
         return;
     }
 
     m_layerTreeHost->willBeginFrame();
 
     m_layerTreeHost->updateAnimations(request->monotonicFrameBeginTime);
     m_layerTreeHost->layout();
 
     // Clear the commit flag after updating animations and layout here --- objects that only
     // layout when painted will trigger another setNeedsCommit inside
     // updateLayers.
     m_commitRequested = false;
     m_commitRequestSentToImplThread = false;
     m_forcedCommitRequested = false;
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "EarlyOut_InitializeFailed");
         return;
     }
 
     m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(request->evictedContentsTexturesBackings);
 
-    scoped_ptr<CCTextureUpdateQueue> queue = make_scoped_ptr(new CCTextureUpdateQueue);
+    scoped_ptr<TextureUpdateQueue> queue = make_scoped_ptr(new TextureUpdateQueue);
     m_layerTreeHost->updateLayers(*(queue.get()), request->memoryAllocationLimitBytes);
 
     // Once single buffered layers are committed, they cannot be modified until
     // they are drawn by the impl thread.
     m_texturesAcquired = false;
 
     m_layerTreeHost->willCommit();
     // Before applying scrolls and calling animate, we set m_animateRequested to
     // false. If it is true now, it means setNeedAnimate was called again, but
     // during a state when m_commitRequestSentToImplThread = true. We need to
     // force that call to happen again now so that the commit request is sent to
     // the impl thread.
     if (m_animateRequested) {
         // Forces setNeedsAnimate to consider posting a commit task.
         m_animateRequested = false;
         setNeedsAnimate();
     }
 
     // Notify the impl thread that the beginFrame has completed. This will
     // begin the commit process, which is blocking from the main thread's
     // point of view, but asynchronously performed on the impl thread,
-    // coordinated by the CCScheduler.
+    // coordinated by the Scheduler.
     {
         TRACE_EVENT0("cc", "commit");
 
         DebugScopedSetMainThreadBlocked mainThreadBlocked;
 
         base::TimeTicks startTime = base::TimeTicks::HighResNow();
-        CCCompletionEvent completion;
-        CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrameCompleteOnImplThread, &completion, queue.release()));
+        CompletionEvent completion;
+        Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::beginFrameCompleteOnImplThread, &completion, queue.release()));
         completion.wait();
         base::TimeTicks endTime = base::TimeTicks::HighResNow();
 
         m_totalCommitTime += endTime - startTime;
         m_totalCommitCount++;
     }
 
     m_layerTreeHost->commitComplete();
     m_layerTreeHost->didBeginFrame();
 }
 
-void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion, CCTextureUpdateQueue* rawQueue)
+void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, TextureUpdateQueue* rawQueue)
 {
-    scoped_ptr<CCTextureUpdateQueue> queue(rawQueue);
+    scoped_ptr<TextureUpdateQueue> queue(rawQueue);
 
-    TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::beginFrameCompleteOnImplThread");
     ASSERT(!m_commitCompletionEventOnImplThread);
     ASSERT(isImplThread() && isMainThreadBlocked());
     ASSERT(m_schedulerOnImplThread);
     ASSERT(m_schedulerOnImplThread->commitPending());
 
     if (!m_layerTreeHostImpl.get()) {
         TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
         completion->signal();
         return;
     }
 
     if (m_layerTreeHost->contentsTextureManager()->linkedEvictedBackingsExist()) {
         // Clear any uploads we were making to textures linked to evicted
         // resources
         queue->clearUploadsToEvictedResources();
         // Some textures in the layer tree are invalid. Kick off another commit
         // to fill them again.
         setNeedsCommitOnImplThread();
     }
 
     m_layerTreeHost->contentsTextureManager()->pushTexturePrioritiesToBackings();
 
-    m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(this, CCProxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->resourceProvider()->textureUploader());
+    m_currentTextureUpdateControllerOnImplThread = TextureUpdateController::create(this, Proxy::implThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->resourceProvider()->textureUploader());
     m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(
         m_schedulerOnImplThread->anticipatedDrawTime());
 
     m_commitCompletionEventOnImplThread = completion;
 }
 
-void CCThreadProxy::beginFrameAbortedOnImplThread()
+void ThreadProxy::beginFrameAbortedOnImplThread()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::beginFrameAbortedOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::beginFrameAbortedOnImplThread");
     ASSERT(isImplThread());
     ASSERT(m_schedulerOnImplThread);
     ASSERT(m_schedulerOnImplThread->commitPending());
 
     m_schedulerOnImplThread->beginFrameAborted();
 }
 
-void CCThreadProxy::scheduledActionCommit()
+void ThreadProxy::scheduledActionCommit()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionCommit");
+    TRACE_EVENT0("cc", "ThreadProxy::scheduledActionCommit");
     ASSERT(isImplThread());
     ASSERT(m_commitCompletionEventOnImplThread);
     ASSERT(m_currentTextureUpdateControllerOnImplThread);
 
     // Complete all remaining texture updates.
     m_currentTextureUpdateControllerOnImplThread->finalize();
     m_currentTextureUpdateControllerOnImplThread.reset();
 
     // If there are linked evicted backings, these backings' resources may be put into the
     // impl tree, so we can't draw yet. Determine this before clearing all evicted backings.
@@ skipping 12 matching lines @@
 
     m_nextFrameIsNewlyCommittedFrameOnImplThread = true;
 
     m_commitCompletionEventOnImplThread->signal();
     m_commitCompletionEventOnImplThread = 0;
 
     // SetVisible kicks off the next scheduler action, so this must be last.
     m_schedulerOnImplThread->setVisible(m_layerTreeHostImpl->visible());
 }
 
-void CCThreadProxy::scheduledActionBeginContextRecreation()
+void ThreadProxy::scheduledActionBeginContextRecreation()
 {
     ASSERT(isImplThread());
-    m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::beginContextRecreation));
+    m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::beginContextRecreation));
 }
 
-CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapInternal(bool forcedDraw)
+ScheduledActionDrawAndSwapResult ThreadProxy::scheduledActionDrawAndSwapInternal(bool forcedDraw)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionDrawAndSwap");
-    CCScheduledActionDrawAndSwapResult result;
+    TRACE_EVENT0("cc", "ThreadProxy::scheduledActionDrawAndSwap");
+    ScheduledActionDrawAndSwapResult result;
     result.didDraw = false;
     result.didSwap = false;
     ASSERT(isImplThread());
     ASSERT(m_layerTreeHostImpl.get());
     if (!m_layerTreeHostImpl.get())
         return result;
 
     ASSERT(m_layerTreeHostImpl->renderer());
     if (!m_layerTreeHostImpl->renderer())
         return result;
 
     // FIXME: compute the frame display time more intelligently
     double monotonicTime = monotonicallyIncreasingTime();
     double wallClockTime = currentTime();
 
     if (m_inputHandlerOnImplThread.get())
         m_inputHandlerOnImplThread->animate(monotonicTime);
     m_layerTreeHostImpl->animate(monotonicTime, wallClockTime);
 
     // This method is called on a forced draw, regardless of whether we are able to produce a frame,
     // as the calling site on main thread is blocked until its request completes, and we signal
     // completion here. If canDraw() is false, we will indicate success=false to the caller, but we
     // must still signal completion to avoid deadlock.
 
     // We guard prepareToDraw() with canDraw() because it always returns a valid frame, so can only
     // be used when such a frame is possible. Since drawLayers() depends on the result of
     // prepareToDraw(), it is guarded on canDraw() as well.
 
-    CCLayerTreeHostImpl::FrameData frame;
+    LayerTreeHostImpl::FrameData frame;
     bool drawFrame = m_layerTreeHostImpl->canDraw() && (m_layerTreeHostImpl->prepareToDraw(frame) || forcedDraw);
     if (drawFrame) {
         m_layerTreeHostImpl->drawLayers(frame);
         result.didDraw = true;
     }
     m_layerTreeHostImpl->didDrawAllLayers(frame);
 
     // Check for a pending compositeAndReadback.
     if (m_readbackRequestOnImplThread) {
         m_readbackRequestOnImplThread->success = false;
         if (drawFrame) {
             m_layerTreeHostImpl->readback(m_readbackRequestOnImplThread->pixels, m_readbackRequestOnImplThread->rect);
             m_readbackRequestOnImplThread->success = !m_layerTreeHostImpl->isContextLost();
         }
         m_readbackRequestOnImplThread->completion.signal();
         m_readbackRequestOnImplThread = 0;
     } else if (drawFrame)
         result.didSwap = m_layerTreeHostImpl->swapBuffers();
 
     // Tell the main thread that the the newly-commited frame was drawn.
     if (m_nextFrameIsNewlyCommittedFrameOnImplThread) {
         m_nextFrameIsNewlyCommittedFrameOnImplThread = false;
-        m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::didCommitAndDrawFrame));
+        m_mainThreadProxy->postTask(createThreadTask(this, &ThreadProxy::didCommitAndDrawFrame));
     }
 
     return result;
 }
 
-void CCThreadProxy::acquireLayerTextures()
+void ThreadProxy::acquireLayerTextures()
 {
     // Called when the main thread needs to modify a layer texture that is used
     // directly by the compositor.
     // This method will block until the next compositor draw if there is a
     // previously committed frame that is still undrawn. This is necessary to
     // ensure that the main thread does not monopolize access to the textures.
     ASSERT(isMainThread());
 
     if (m_texturesAcquired)
         return;
 
-    TRACE_EVENT0("cc", "CCThreadProxy::acquireLayerTextures");
+    TRACE_EVENT0("cc", "ThreadProxy::acquireLayerTextures");
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
-    CCCompletionEvent completion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread, &completion));
+    CompletionEvent completion;
+    Proxy::implThread()->postTask(createThreadTask(this, &ThreadProxy::acquireLayerTexturesForMainThreadOnImplThread, &completion));
     completion.wait(); // Block until it is safe to write to layer textures from the main thread.
 
     m_texturesAcquired = true;
 }
 
-void CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent* completion)
+void ThreadProxy::acquireLayerTexturesForMainThreadOnImplThread(CompletionEvent* completion)
 {
     ASSERT(isImplThread());
     ASSERT(!m_textureAcquisitionCompletionEventOnImplThread);
 
     m_textureAcquisitionCompletionEventOnImplThread = completion;
     m_schedulerOnImplThread->setMainThreadNeedsLayerTextures();
 }
 
-void CCThreadProxy::scheduledActionAcquireLayerTexturesForMainThread()
+void ThreadProxy::scheduledActionAcquireLayerTexturesForMainThread()
 {
     ASSERT(m_textureAcquisitionCompletionEventOnImplThread);
     m_textureAcquisitionCompletionEventOnImplThread->signal();
     m_textureAcquisitionCompletionEventOnImplThread = 0;
 }
 
-CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapIfPossible()
+ScheduledActionDrawAndSwapResult ThreadProxy::scheduledActionDrawAndSwapIfPossible()
 {
     return scheduledActionDrawAndSwapInternal(false);
 }
 
-CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapForced()
+ScheduledActionDrawAndSwapResult ThreadProxy::scheduledActionDrawAndSwapForced()
 {
     return scheduledActionDrawAndSwapInternal(true);
 }
 
-void CCThreadProxy::didAnticipatedDrawTimeChange(base::TimeTicks time)
+void ThreadProxy::didAnticipatedDrawTimeChange(base::TimeTicks time)
 {
     if (!m_currentTextureUpdateControllerOnImplThread)
         return;
 
     m_currentTextureUpdateControllerOnImplThread->performMoreUpdates(time);
 }
 
-void CCThreadProxy::readyToFinalizeTextureUpdates()
+void ThreadProxy::readyToFinalizeTextureUpdates()
 {
     ASSERT(isImplThread());
     m_schedulerOnImplThread->beginFrameComplete();
 }
 
-void CCThreadProxy::didCommitAndDrawFrame()
+void ThreadProxy::didCommitAndDrawFrame()
 {
     ASSERT(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->didCommitAndDrawFrame();
 }
 
-void CCThreadProxy::didCompleteSwapBuffers()
+void ThreadProxy::didCompleteSwapBuffers()
 {
     ASSERT(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->didCompleteSwapBuffers();
 }
 
-void CCThreadProxy::setAnimationEvents(CCAnimationEventsVector* passed_events, double wallClockTime)
+void ThreadProxy::setAnimationEvents(AnimationEventsVector* passed_events, double wallClockTime)
 {
-    scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(passed_events));
+    scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(passed_events));
 
-    TRACE_EVENT0("cc", "CCThreadProxy::setAnimationEvents");
+    TRACE_EVENT0("cc", "ThreadProxy::setAnimationEvents");
     ASSERT(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->setAnimationEvents(events.Pass(), wallClockTime);
 }
 
-class CCThreadProxyContextRecreationTimer : public CCTimer, CCTimerClient {
+class ThreadProxyContextRecreationTimer : public Timer, TimerClient {
 public:
-    static scoped_ptr<CCThreadProxyContextRecreationTimer> create(CCThreadProxy* proxy) { return make_scoped_ptr(new CCThreadProxyContextRecreationTimer(proxy)); }
+    static scoped_ptr<ThreadProxyContextRecreationTimer> create(ThreadProxy* proxy) { return make_scoped_ptr(new ThreadProxyContextRecreationTimer(proxy)); }
 
     virtual void onTimerFired() OVERRIDE
     {
         m_proxy->tryToRecreateContext();
     }
 
 private:
-    explicit CCThreadProxyContextRecreationTimer(CCThreadProxy* proxy)
-        : CCTimer(CCProxy::mainThread(), this)
+    explicit ThreadProxyContextRecreationTimer(ThreadProxy* proxy)
+        : Timer(Proxy::mainThread(), this)
         , m_proxy(proxy)
     {
     }
 
-    CCThreadProxy* m_proxy;
+    ThreadProxy* m_proxy;
 };
 
-void CCThreadProxy::beginContextRecreation()
+void ThreadProxy::beginContextRecreation()
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::beginContextRecreation");
+    TRACE_EVENT0("cc", "ThreadProxy::beginContextRecreation");
     ASSERT(isMainThread());
     ASSERT(!m_contextRecreationTimer);
-    m_contextRecreationTimer = CCThreadProxyContextRecreationTimer::create(this);
+    m_contextRecreationTimer = ThreadProxyContextRecreationTimer::create(this);
     m_layerTreeHost->didLoseContext();
     m_contextRecreationTimer->startOneShot(contextRecreationTickRate);
 }
 
-void CCThreadProxy::tryToRecreateContext()
+void ThreadProxy::tryToRecreateContext()
 {
     ASSERT(isMainThread());
     ASSERT(m_layerTreeHost);
-    CCLayerTreeHost::RecreateResult result = m_layerTreeHost->recreateContext();
-    if (result == CCLayerTreeHost::RecreateFailedButTryAgain)
+    LayerTreeHost::RecreateResult result = m_layerTreeHost->recreateContext();
+    if (result == LayerTreeHost::RecreateFailedButTryAgain)
         m_contextRecreationTimer->startOneShot(contextRecreationTickRate);
-    else if (result == CCLayerTreeHost::RecreateSucceeded)
+    else if (result == LayerTreeHost::RecreateSucceeded)
         m_contextRecreationTimer.reset();
 }
 
-void CCThreadProxy::initializeImplOnImplThread(CCCompletionEvent* completion, CCInputHandler* handler)
+void ThreadProxy::initializeImplOnImplThread(CompletionEvent* completion, InputHandler* handler)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::initializeImplOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::initializeImplOnImplThread");
     ASSERT(isImplThread());
     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
     const base::TimeDelta displayRefreshInterval = base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond / 60);
-    scoped_ptr<CCFrameRateController> frameRateController;
+    scoped_ptr<FrameRateController> frameRateController;
     if (m_renderVSyncEnabled)
-        frameRateController.reset(new CCFrameRateController(CCDelayBasedTimeSource::create(displayRefreshInterval, CCProxy::implThread())));
+        frameRateController.reset(new FrameRateController(DelayBasedTimeSource::create(displayRefreshInterval, Proxy::implThread())));
     else
-        frameRateController.reset(new CCFrameRateController(CCProxy::implThread()));
-    m_schedulerOnImplThread = CCScheduler::create(this, frameRateController.Pass());
+        frameRateController.reset(new FrameRateController(Proxy::implThread()));
+    m_schedulerOnImplThread = Scheduler::create(this, frameRateController.Pass());
     m_schedulerOnImplThread->setVisible(m_layerTreeHostImpl->visible());
 
-    m_inputHandlerOnImplThread = scoped_ptr<CCInputHandler>(handler);
+    m_inputHandlerOnImplThread = scoped_ptr<InputHandler>(handler);
     if (m_inputHandlerOnImplThread.get())
         m_inputHandlerOnImplThread->bindToClient(m_layerTreeHostImpl.get());
 
     completion->signal();
 }
 
-void CCThreadProxy::initializeContextOnImplThread(CCGraphicsContext* context)
+void ThreadProxy::initializeContextOnImplThread(GraphicsContext* context)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::initializeContextOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::initializeContextOnImplThread");
     ASSERT(isImplThread());
-    m_contextBeforeInitializationOnImplThread = scoped_ptr<CCGraphicsContext>(context).Pass();
+    m_contextBeforeInitializationOnImplThread = scoped_ptr<GraphicsContext>(context).Pass();
 }
 
-void CCThreadProxy::initializeRendererOnImplThread(CCCompletionEvent* completion, bool* initializeSucceeded, RendererCapabilities* capabilities)
+void ThreadProxy::initializeRendererOnImplThread(CompletionEvent* completion, bool* initializeSucceeded, RendererCapabilities* capabilities)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::initializeRendererOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::initializeRendererOnImplThread");
     ASSERT(isImplThread());
     ASSERT(m_contextBeforeInitializationOnImplThread.get());
     *initializeSucceeded = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitializationOnImplThread.Pass());
     if (*initializeSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_schedulerOnImplThread->setSwapBuffersCompleteSupported(
                 capabilities->usingSwapCompleteCallback);
     }
 
     completion->signal();
 }
 
-void CCThreadProxy::layerTreeHostClosedOnImplThread(CCCompletionEvent* completion)
+void ThreadProxy::layerTreeHostClosedOnImplThread(CompletionEvent* completion)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::layerTreeHostClosedOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::layerTreeHostClosedOnImplThread");
     ASSERT(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     m_inputHandlerOnImplThread.reset();
     m_layerTreeHostImpl.reset();
     m_schedulerOnImplThread.reset();
     completion->signal();
 }
 
-void CCThreadProxy::setFullRootLayerDamageOnImplThread()
+void ThreadProxy::setFullRootLayerDamageOnImplThread()
 {
     ASSERT(isImplThread());
     m_layerTreeHostImpl->setFullRootLayerDamage();
 }
 
-size_t CCThreadProxy::maxPartialTextureUpdates() const
+size_t ThreadProxy::maxPartialTextureUpdates() const
 {
-    return CCTextureUpdateController::maxPartialTextureUpdates();
+    return TextureUpdateController::maxPartialTextureUpdates();
 }
 
-void CCThreadProxy::recreateContextOnImplThread(CCCompletionEvent* completion, CCGraphicsContext* contextPtr, bool* recreateSucceeded, RendererCapabilities* capabilities)
+void ThreadProxy::recreateContextOnImplThread(CompletionEvent* completion, GraphicsContext* contextPtr, bool* recreateSucceeded, RendererCapabilities* capabilities)
 {
-    TRACE_EVENT0("cc", "CCThreadProxy::recreateContextOnImplThread");
+    TRACE_EVENT0("cc", "ThreadProxy::recreateContextOnImplThread");
     ASSERT(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
-    *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(scoped_ptr<CCGraphicsContext>(contextPtr).Pass());
+    *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(scoped_ptr<GraphicsContext>(contextPtr).Pass());
     if (*recreateSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_schedulerOnImplThread->didRecreateContext();
     }
     completion->signal();
 }
 
-void CCThreadProxy::renderingStatsOnImplThread(CCCompletionEvent* completion, CCRenderingStats* stats)
+void ThreadProxy::renderingStatsOnImplThread(CompletionEvent* completion, RenderingStats* stats)
 {
     ASSERT(isImplThread());
     m_layerTreeHostImpl->renderingStats(stats);
     completion->signal();
 }
 
-CCThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
+ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : monotonicFrameBeginTime(0)
 {
 }
 
-CCThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
+ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 }  // namespace cc