cc: Rename cc classes and members to match filenames

cc/software_renderer.cc

Index: cc/software_renderer.cc
diff --git a/cc/software_renderer.cc b/cc/software_renderer.cc
index 0aeb33bc055fd8fca0f6efa697ff890cdbf2fd83..45679b88361bdf349d53ea54d94b5290479a4ffe 100644
--- a/cc/software_renderer.cc
+++ b/cc/software_renderer.cc
@@ -64,18 +64,18 @@ bool isScaleAndTranslate(const SkMatrix& matrix)
 
 } // anonymous namespace
 
-scoped_ptr<CCRendererSoftware> CCRendererSoftware::create(CCRendererClient* client, CCResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
+scoped_ptr<SoftwareRenderer> SoftwareRenderer::create(RendererClient* client, ResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
 {
-    return make_scoped_ptr(new CCRendererSoftware(client, resourceProvider, outputDevice));
+    return make_scoped_ptr(new SoftwareRenderer(client, resourceProvider, outputDevice));
 }
 
-CCRendererSoftware::CCRendererSoftware(CCRendererClient* client, CCResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
-    : CCDirectRenderer(client, resourceProvider)
+SoftwareRenderer::SoftwareRenderer(RendererClient* client, ResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
+    : DirectRenderer(client, resourceProvider)
     , m_visible(true)
     , m_outputDevice(outputDevice)
     , m_skCurrentCanvas(0)
 {
-    m_resourceProvider->setDefaultResourceType(CCResourceProvider::Bitmap);
+    m_resourceProvider->setDefaultResourceType(ResourceProvider::Bitmap);
 
     m_capabilities.maxTextureSize = INT_MAX;
     m_capabilities.bestTextureFormat = GraphicsContext3D::RGBA;
@@ -85,26 +85,26 @@ CCRendererSoftware::CCRendererSoftware(CCRendererClient* client, CCResourceProvi
     viewportChanged();
 }
 
-CCRendererSoftware::~CCRendererSoftware()
+SoftwareRenderer::~SoftwareRenderer()
 {
 }
 
-const RendererCapabilities& CCRendererSoftware::capabilities() const
+const RendererCapabilities& SoftwareRenderer::capabilities() const
 {
     return m_capabilities;
 }
 
-void CCRendererSoftware::viewportChanged()
+void SoftwareRenderer::viewportChanged()
 {
     m_outputDevice->didChangeViewportSize(WebSize(viewportSize().width(), viewportSize().height()));
 }
 
-void CCRendererSoftware::beginDrawingFrame(DrawingFrame& frame)
+void SoftwareRenderer::beginDrawingFrame(DrawingFrame& frame)
 {
     m_skRootCanvas = make_scoped_ptr(new SkCanvas(m_outputDevice->lock(true)->getSkBitmap()));
 }
 
-void CCRendererSoftware::finishDrawingFrame(DrawingFrame& frame)
+void SoftwareRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_skCurrentCanvas = 0;
@@ -112,24 +112,24 @@ void CCRendererSoftware::finishDrawingFrame(DrawingFrame& frame)
     m_outputDevice->unlock();
 }
 
-bool CCRendererSoftware::flippedFramebuffer() const
+bool SoftwareRenderer::flippedFramebuffer() const
 {
     return false;
 }
 
-void CCRendererSoftware::finish()
+void SoftwareRenderer::finish()
 {
 }
 
-void CCRendererSoftware::bindFramebufferToOutputSurface(DrawingFrame& frame)
+void SoftwareRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_skCurrentCanvas = m_skRootCanvas.get();
 }
 
-bool CCRendererSoftware::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect)
+bool SoftwareRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedTexture* texture, const IntRect& framebufferRect)
 {
-    m_currentFramebufferLock = make_scoped_ptr(new CCResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
+    m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
     m_skCurrentCanvas = m_currentFramebufferLock->skCanvas();
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
@@ -137,18 +137,18 @@ bool CCRendererSoftware::bindFramebufferToTexture(DrawingFrame& frame, const CCS
     return true;
 }
 
-void CCRendererSoftware::enableScissorTestRect(const IntRect& scissorRect)
+void SoftwareRenderer::enableScissorTestRect(const IntRect& scissorRect)
 {
     m_skCurrentCanvas->clipRect(toSkRect(scissorRect), SkRegion::kReplace_Op);
 }
 
-void CCRendererSoftware::disableScissorTest()
+void SoftwareRenderer::disableScissorTest()
 {
     IntRect canvasRect(IntPoint(), viewportSize());
     m_skCurrentCanvas->clipRect(toSkRect(canvasRect), SkRegion::kReplace_Op);
 }
 
-void CCRendererSoftware::clearFramebuffer(DrawingFrame& frame)
+void SoftwareRenderer::clearFramebuffer(DrawingFrame& frame)
 {
     if (frame.currentRenderPass->hasTransparentBackground()) {
         m_skCurrentCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
@@ -160,16 +160,16 @@ void CCRendererSoftware::clearFramebuffer(DrawingFrame& frame)
     }
 }
 
-void CCRendererSoftware::setDrawViewportSize(const IntSize& viewportSize)
+void SoftwareRenderer::setDrawViewportSize(const IntSize& viewportSize)
 {
 }
 
-bool CCRendererSoftware::isSoftwareResource(CCResourceProvider::ResourceId id) const
+bool SoftwareRenderer::isSoftwareResource(ResourceProvider::ResourceId id) const
 {
     switch (m_resourceProvider->resourceType(id)) {
-    case CCResourceProvider::GLTexture:
+    case ResourceProvider::GLTexture:
         return false;
-    case CCResourceProvider::Bitmap:
+    case ResourceProvider::Bitmap:
         return true;
     }
 
@@ -177,7 +177,7 @@ bool CCRendererSoftware::isSoftwareResource(CCResourceProvider::ResourceId id) c
     return false;
 }
 
-void CCRendererSoftware::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)
+void SoftwareRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 {
     WebTransformationMatrix quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->quadRect());
@@ -199,20 +199,20 @@ void CCRendererSoftware::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)
     }
 
     switch (quad->material()) {
-    case CCDrawQuad::DebugBorder:
-        drawDebugBorderQuad(frame, CCDebugBorderDrawQuad::materialCast(quad));
+    case DrawQuad::DebugBorder:
+        drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::SolidColor:
-        drawSolidColorQuad(frame, CCSolidColorDrawQuad::materialCast(quad));
+    case DrawQuad::SolidColor:
+        drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::TextureContent:
-        drawTextureQuad(frame, CCTextureDrawQuad::materialCast(quad));
+    case DrawQuad::TextureContent:
+        drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::TiledContent:
-        drawTileQuad(frame, CCTileDrawQuad::materialCast(quad));
+    case DrawQuad::TiledContent:
+        drawTileQuad(frame, TileDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::RenderPass:
-        drawRenderPassQuad(frame, CCRenderPassDrawQuad::materialCast(quad));
+    case DrawQuad::RenderPass:
+        drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
         break;
     default:
         drawUnsupportedQuad(frame, quad);
@@ -222,7 +222,7 @@ void CCRendererSoftware::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)
     m_skCurrentCanvas->resetMatrix();
 }
 
-void CCRendererSoftware::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugBorderDrawQuad* quad)
+void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 {
     // We need to apply the matrix manually to have pixel-sized stroke width.
     SkPoint vertices[4];
@@ -238,14 +238,14 @@ void CCRendererSoftware::drawDebugBorderQuad(const DrawingFrame& frame, const CC
     m_skCurrentCanvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, transformedVertices, m_skCurrentPaint);
 }
 
-void CCRendererSoftware::drawSolidColorQuad(const DrawingFrame& frame, const CCSolidColorDrawQuad* quad)
+void SoftwareRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
     m_skCurrentPaint.setColor(quad->color());
     m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
     m_skCurrentCanvas->drawRect(toSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
-void CCRendererSoftware::drawTextureQuad(const DrawingFrame& frame, const CCTextureDrawQuad* quad)
+void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
     if (!isSoftwareResource(quad->resourceId())) {
         drawUnsupportedQuad(frame, quad);
@@ -253,7 +253,7 @@ void CCRendererSoftware::drawTextureQuad(const DrawingFrame& frame, const CCText
     }
 
     // FIXME: Add support for non-premultiplied alpha.
-    CCResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
     FloatRect uvRect = quad->uvRect();
     uvRect.scale(quad->quadRect().width(), quad->quadRect().height());
     SkIRect skUvRect = toSkIRect(enclosingIntRect(uvRect));
@@ -262,23 +262,23 @@ void CCRendererSoftware::drawTextureQuad(const DrawingFrame& frame, const CCText
     m_skCurrentCanvas->drawBitmapRect(*quadResourceLock.skBitmap(), &skUvRect, toSkRect(quadVertexRect()), &m_skCurrentPaint);
 }
 
-void CCRendererSoftware::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad* quad)
+void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 {
     ASSERT(isSoftwareResource(quad->resourceId()));
-    CCResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
 
     SkIRect uvRect = toSkIRect(IntRect(quad->textureOffset(), quad->quadRect().size()));
     m_skCurrentCanvas->drawBitmapRect(*quadResourceLock.skBitmap(), &uvRect, toSkRect(quadVertexRect()), &m_skCurrentPaint);
 }
 
-void CCRendererSoftware::drawRenderPassQuad(const DrawingFrame& frame, const CCRenderPassDrawQuad* quad)
+void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
     CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     ASSERT(isSoftwareResource(contentsTexture->id()));
-    CCResourceProvider::ScopedReadLockSoftware contentsTextureLock(m_resourceProvider, contentsTexture->id());
+    ResourceProvider::ScopedReadLockSoftware contentsTextureLock(m_resourceProvider, contentsTexture->id());
 
     const SkBitmap* bitmap = contentsTextureLock.skBitmap();
 
@@ -297,7 +297,7 @@ void CCRendererSoftware::drawRenderPassQuad(const DrawingFrame& frame, const CCR
     m_skCurrentPaint.setShader(shader);
 
     if (quad->maskResourceId()) {
-        CCResourceProvider::ScopedReadLockSoftware maskResourceLock(m_resourceProvider, quad->maskResourceId());
+        ResourceProvider::ScopedReadLockSoftware maskResourceLock(m_resourceProvider, quad->maskResourceId());
         const SkBitmap* maskBitmap = maskResourceLock.skBitmap();
 
         SkMatrix maskMat;
@@ -323,21 +323,21 @@ void CCRendererSoftware::drawRenderPassQuad(const DrawingFrame& frame, const CCR
     }
 }
 
-void CCRendererSoftware::drawUnsupportedQuad(const DrawingFrame& frame, const CCDrawQuad* quad)
+void SoftwareRenderer::drawUnsupportedQuad(const DrawingFrame& frame, const DrawQuad* quad)
 {
     m_skCurrentPaint.setColor(SK_ColorMAGENTA);
     m_skCurrentPaint.setAlpha(quad->opacity() * 255);
     m_skCurrentCanvas->drawRect(toSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
-bool CCRendererSoftware::swapBuffers()
+bool SoftwareRenderer::swapBuffers()
 {
-    if (CCProxy::hasImplThread())
+    if (Proxy::hasImplThread())
         m_client->onSwapBuffersComplete();
     return true;
 }
 
-void CCRendererSoftware::getFramebufferPixels(void *pixels, const IntRect& rect)
+void SoftwareRenderer::getFramebufferPixels(void *pixels, const IntRect& rect)
 {
     SkBitmap fullBitmap = m_outputDevice->lock(false)->getSkBitmap();
     SkBitmap subsetBitmap;
@@ -347,7 +347,7 @@ void CCRendererSoftware::getFramebufferPixels(void *pixels, const IntRect& rect)
     m_outputDevice->unlock();
 }
 
-void CCRendererSoftware::setVisible(bool visible)
+void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;