cc: Rename cc classes and members to match filenames

cc/gl_renderer.cc

 // Copyright 2010 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 "CCRendererGL.h"
 
 #include "CCDamageTracker.h"
 #include "CCLayerQuad.h"
@@ skipping 41 matching lines @@
 {
 #if OS(DARWIN)
     return true;
 #else
     return false;
 #endif
 }
 
 } // anonymous namespace
 
-scoped_ptr<CCRendererGL> CCRendererGL::create(CCRendererClient* client, CCResourceProvider* resourceProvider)
+scoped_ptr<GLRenderer> GLRenderer::create(RendererClient* client, ResourceProvider* resourceProvider)
 {
-    scoped_ptr<CCRendererGL> renderer(make_scoped_ptr(new CCRendererGL(client, resourceProvider)));
+    scoped_ptr<GLRenderer> renderer(make_scoped_ptr(new GLRenderer(client, resourceProvider)));
     if (!renderer->initialize())
-        return scoped_ptr<CCRendererGL>();
+        return scoped_ptr<GLRenderer>();
 
     return renderer.Pass();
 }
 
-CCRendererGL::CCRendererGL(CCRendererClient* client,
-                           CCResourceProvider* resourceProvider)
-    : CCDirectRenderer(client, resourceProvider)
+GLRenderer::GLRenderer(RendererClient* client,
+                           ResourceProvider* resourceProvider)
+    : DirectRenderer(client, resourceProvider)
     , m_offscreenFramebufferId(0)
     , m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f))
     , m_context(resourceProvider->graphicsContext3D())
     , m_isViewportChanged(false)
     , m_isFramebufferDiscarded(false)
     , m_discardFramebufferWhenNotVisible(false)
     , m_isUsingBindUniform(false)
     , m_visible(true)
 {
     ASSERT(m_context);
 }
 
-bool CCRendererGL::initialize()
+bool GLRenderer::initialize()
 {
     if (!m_context->makeContextCurrent())
         return false;
 
     m_context->setContextLostCallback(this);
     m_context->pushGroupMarkerEXT("CompositorContext");
 
     std::string extensionsString = UTF16ToASCII(m_context->getString(GraphicsContext3D::EXTENSIONS));
     std::vector<std::string> extensionsList;
     base::SplitString(extensionsString, ' ', &extensionsList);
     std::set<string> extensions(extensionsList.begin(), extensionsList.end());
 
     if (settings().acceleratePainting && extensions.count("GL_EXT_texture_format_BGRA8888")
                                       && extensions.count("GL_EXT_read_format_bgra"))
         m_capabilities.usingAcceleratedPainting = true;
     else
         m_capabilities.usingAcceleratedPainting = false;
 
 
     m_capabilities.contextHasCachedFrontBuffer = extensions.count("GL_CHROMIUM_front_buffer_cached");
 
-    m_capabilities.usingPartialSwap = CCSettings::partialSwapEnabled() && extensions.count("GL_CHROMIUM_post_sub_buffer");
+    m_capabilities.usingPartialSwap = Settings::partialSwapEnabled() && extensions.count("GL_CHROMIUM_post_sub_buffer");
 
     // Use the swapBuffers callback only with the threaded proxy.
-    if (CCProxy::hasImplThread())
+    if (Proxy::hasImplThread())
         m_capabilities.usingSwapCompleteCallback = extensions.count("GL_CHROMIUM_swapbuffers_complete_callback");
     if (m_capabilities.usingSwapCompleteCallback)
         m_context->setSwapBuffersCompleteCallbackCHROMIUM(this);
 
     m_capabilities.usingSetVisibility = extensions.count("GL_CHROMIUM_set_visibility");
 
     if (extensions.count("GL_CHROMIUM_iosurface"))
         ASSERT(extensions.count("GL_ARB_texture_rectangle"));
 
     m_capabilities.usingGpuMemoryManager = extensions.count("GL_CHROMIUM_gpu_memory_manager");
@@ skipping 10 matching lines @@
     m_isUsingBindUniform = extensions.count("GL_CHROMIUM_bind_uniform_location");
 
     if (!initializeSharedObjects())
         return false;
 
     // Make sure the viewport and context gets initialized, even if it is to zero.
     viewportChanged();
     return true;
 }
 
-CCRendererGL::~CCRendererGL()
+GLRenderer::~GLRenderer()
 {
-    ASSERT(CCProxy::isImplThread());
+    ASSERT(Proxy::isImplThread());
     m_context->setSwapBuffersCompleteCallbackCHROMIUM(0);
     m_context->setMemoryAllocationChangedCallbackCHROMIUM(0);
     m_context->setContextLostCallback(0);
     cleanupSharedObjects();
 }
 
-const RendererCapabilities& CCRendererGL::capabilities() const
+const RendererCapabilities& GLRenderer::capabilities() const
 {
     return m_capabilities;
 }
 
-WebGraphicsContext3D* CCRendererGL::context()
+WebGraphicsContext3D* GLRenderer::context()
 {
     return m_context;
 }
 
-void CCRendererGL::debugGLCall(WebGraphicsContext3D* context, const char* command, const char* file, int line)
+void GLRenderer::debugGLCall(WebGraphicsContext3D* context, const char* command, const char* file, int line)
 {
     unsigned long error = context->getError();
     if (error != GraphicsContext3D::NO_ERROR)
         LOG_ERROR("GL command failed: File: %s\n\tLine %d\n\tcommand: %s, error %x\n", file, line, command, static_cast<int>(error));
 }
 
-void CCRendererGL::setVisible(bool visible)
+void GLRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 
     // TODO: Replace setVisibilityCHROMIUM with an extension to explicitly manage front/backbuffers
     // crbug.com/116049
     if (m_capabilities.usingSetVisibility)
         m_context->setVisibilityCHROMIUM(visible);
 
     enforceMemoryPolicy();
 }
 
-void CCRendererGL::releaseRenderPassTextures()
+void GLRenderer::releaseRenderPassTextures()
 {
     m_renderPassTextures.clear();
 }
 
-void CCRendererGL::viewportChanged()
+void GLRenderer::viewportChanged()
 {
     m_isViewportChanged = true;
 }
 
-void CCRendererGL::clearFramebuffer(DrawingFrame& frame)
+void GLRenderer::clearFramebuffer(DrawingFrame& frame)
 {
     // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
     if (frame.currentRenderPass->hasTransparentBackground())
         GLC(m_context, m_context->clearColor(0, 0, 0, 0));
     else
         GLC(m_context, m_context->clearColor(0, 0, 1, 1));
 
 #if defined(NDEBUG)
     if (frame.currentRenderPass->hasTransparentBackground())
 #endif
         m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
 }
 
-void CCRendererGL::beginDrawingFrame(DrawingFrame& frame)
+void GLRenderer::beginDrawingFrame(DrawingFrame& frame)
 {
     // FIXME: Remove this once framebuffer is automatically recreated on first use
     ensureFramebuffer();
 
     if (viewportSize().isEmpty())
         return;
 
-    TRACE_EVENT0("cc", "CCRendererGL::drawLayers");
+    TRACE_EVENT0("cc", "GLRenderer::drawLayers");
     if (m_isViewportChanged) {
         // Only reshape when we know we are going to draw. Otherwise, the reshape
         // can leave the window at the wrong size if we never draw and the proper
         // viewport size is never set.
         m_isViewportChanged = false;
         m_context->reshape(viewportWidth(), viewportHeight());
     }
 
     makeContextCurrent();
     // Bind the common vertex attributes used for drawing all the layers.
     m_sharedGeometry->prepareForDraw();
 
     GLC(m_context, m_context->disable(GraphicsContext3D::DEPTH_TEST));
     GLC(m_context, m_context->disable(GraphicsContext3D::CULL_FACE));
     GLC(m_context, m_context->colorMask(true, true, true, true));
     GLC(m_context, m_context->enable(GraphicsContext3D::BLEND));
     GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
 }
 
-void CCRendererGL::doNoOp()
+void GLRenderer::doNoOp()
 {
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
     GLC(m_context, m_context->flush());
 }
 
-void CCRendererGL::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)
+void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 {
     if (quad->needsBlending())
         GLC(m_context, m_context->enable(GraphicsContext3D::BLEND));
     else
         GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));
 
     switch (quad->material()) {
-    case CCDrawQuad::Invalid:
+    case DrawQuad::Invalid:
         ASSERT_NOT_REACHED();
         break;
-    case CCDrawQuad::Checkerboard:
-        drawCheckerboardQuad(frame, CCCheckerboardDrawQuad::materialCast(quad));
+    case DrawQuad::Checkerboard:
+        drawCheckerboardQuad(frame, CheckerboardDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::DebugBorder:
-        drawDebugBorderQuad(frame, CCDebugBorderDrawQuad::materialCast(quad));
+    case DrawQuad::DebugBorder:
+        drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::IOSurfaceContent:
-        drawIOSurfaceQuad(frame, CCIOSurfaceDrawQuad::materialCast(quad));
+    case DrawQuad::IOSurfaceContent:
+        drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::RenderPass:
-        drawRenderPassQuad(frame, CCRenderPassDrawQuad::materialCast(quad));
+    case DrawQuad::RenderPass:
+        drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::SolidColor:
-        drawSolidColorQuad(frame, CCSolidColorDrawQuad::materialCast(quad));
+    case DrawQuad::SolidColor:
+        drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
         break;
-    case CCDrawQuad::StreamVideoContent:
-        drawStreamVideoQuad(frame, CCStreamVideoDrawQuad::materialCast(quad));
+    case DrawQuad::StreamVideoContent:
+        drawStreamVideoQuad(frame, StreamVideoDrawQuad::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::YUVVideoContent:
-        drawYUVVideoQuad(frame, CCYUVVideoDrawQuad::materialCast(quad));
+    case DrawQuad::YUVVideoContent:
+        drawYUVVideoQuad(frame, YUVVideoDrawQuad::materialCast(quad));
         break;
     }
 }
 
-void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheckerboardDrawQuad* quad)
+void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const CheckerboardDrawQuad* quad)
 {
     const TileCheckerboardProgram* program = tileCheckerboardProgram();
     ASSERT(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
     SkColor color = quad->color();
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1));
 
     const int checkerboardWidth = 16;
     float frequency = 1.0 / checkerboardWidth;
 
     IntRect tileRect = quad->quadRect();
     float texOffsetX = tileRect.x() % checkerboardWidth;
     float texOffsetY = tileRect.y() % checkerboardWidth;
     float texScaleX = tileRect.width();
     float texScaleY = tileRect.height();
     GLC(context(), context()->uniform4f(program->fragmentShader().texTransformLocation(), texOffsetX, texOffsetY, texScaleX, texScaleY));
 
     GLC(context(), context()->uniform1f(program->fragmentShader().frequencyLocation(), frequency));
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());
 }
 
-void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugBorderDrawQuad* quad)
+void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 {
     static float glMatrix[16];
     const SolidColorProgram* program = solidColorProgram();
     ASSERT(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
     // Use the full quadRect for debug quads to not move the edges based on partial swaps.
     const IntRect& layerRect = quad->quadRect();
     WebTransformationMatrix renderMatrix = quad->quadTransform();
     renderMatrix.translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());
     renderMatrix.scaleNonUniform(layerRect.width(), layerRect.height());
-    CCRendererGL::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
+    GLRenderer::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));
 
     SkColor color = quad->color();
     float alpha = SkColorGetA(color) / 255.0;
 
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
 
     GLC(context(), context()->lineWidth(quad->width()));
 
     // The indices for the line are stored in the same array as the triangle indices.
     GLC(context(), context()->drawElements(GraphicsContext3D::LINE_LOOP, 4, GraphicsContext3D::UNSIGNED_SHORT, 6 * sizeof(unsigned short)));
 }
 
-static inline SkBitmap applyFilters(CCRendererGL* renderer, const WebKit::WebFilterOperations& filters, CCScopedTexture* sourceTexture)
+static inline SkBitmap applyFilters(GLRenderer* renderer, const WebKit::WebFilterOperations& filters, ScopedTexture* sourceTexture)
 {
     if (filters.isEmpty())
         return SkBitmap();
 
-    WebGraphicsContext3D* filterContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext();
-    GrContext* filterGrContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext();
+    WebGraphicsContext3D* filterContext = Proxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext();
+    GrContext* filterGrContext = Proxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext();
 
     if (!filterContext || !filterGrContext)
         return SkBitmap();
 
     renderer->context()->flush();
 
-    CCResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
-    SkBitmap source = CCRenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);
+    ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
+    SkBitmap source = RenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);
     return source;
 }
 
-scoped_ptr<CCScopedTexture> CCRendererGL::drawBackgroundFilters(DrawingFrame& frame, const CCRenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform)
+scoped_ptr<ScopedTexture> GLRenderer::drawBackgroundFilters(DrawingFrame& frame, const RenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform)
 {
     // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
     // The algorithm works as follows:
     // 1. Compute a bounding box around the pixels that will be visible through the quad.
     // 2. Read the pixels in the bounding box into a buffer R.
     // 3. Apply the background filter to R, so that it is applied in the pixels' coordinate space.
     // 4. Apply the quad's inverse transform to map the pixels in R into the quad's content space. This implicitly
     // clips R by the content bounds of the quad since the destination texture has bounds matching the quad's content.
     // 5. Draw the background texture for the contents using the same transform as used to draw the contents itself. This is done
     // without blending to replace the current background pixels with the new filtered background.
     // 6. Draw the contents of the quad over drop of the new background with blending, as per usual. The filtered background
     // pixels will show through any non-opaque pixels in this draws.
     //
     // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
-    // FIXME: When this algorithm changes, update CCLayerTreeHost::prioritizeTextures() accordingly.
+    // FIXME: When this algorithm changes, update LayerTreeHost::prioritizeTextures() accordingly.
 
     if (filters.isEmpty())
-        return scoped_ptr<CCScopedTexture>();
+        return scoped_ptr<ScopedTexture>();
 
     // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain
     // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
     if (frame.currentRenderPass->hasTransparentBackground())
-        return scoped_ptr<CCScopedTexture>();
+        return scoped_ptr<ScopedTexture>();
     ASSERT(!frame.currentTexture);
 
     // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).
-    IntRect deviceRect = enclosingIntRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));
+    IntRect deviceRect = enclosingIntRect(MathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));
 
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
     deviceRect.move(-left, -top);
     deviceRect.expand(left + right, top + bottom);
 
     deviceRect.intersect(frame.currentRenderPass->outputRect());
 
-    scoped_ptr<CCScopedTexture> deviceBackgroundTexture = CCScopedTexture::create(m_resourceProvider);
+    scoped_ptr<ScopedTexture> deviceBackgroundTexture = ScopedTexture::create(m_resourceProvider);
     if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
-        return scoped_ptr<CCScopedTexture>();
+        return scoped_ptr<ScopedTexture>();
 
     SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get());
     if (!filteredDeviceBackground.getTexture())
-        return scoped_ptr<CCScopedTexture>();
+        return scoped_ptr<ScopedTexture>();
 
     GrTexture* texture = reinterpret_cast<GrTexture*>(filteredDeviceBackground.getTexture());
     int filteredDeviceBackgroundTextureId = texture->getTextureHandle();
 
-    scoped_ptr<CCScopedTexture> backgroundTexture = CCScopedTexture::create(m_resourceProvider);
-    if (!backgroundTexture->allocate(CCRenderer::ImplPool, quad->quadRect().size(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageFramebuffer))
-        return scoped_ptr<CCScopedTexture>();
+    scoped_ptr<ScopedTexture> backgroundTexture = ScopedTexture::create(m_resourceProvider);
+    if (!backgroundTexture->allocate(Renderer::ImplPool, quad->quadRect().size(), GraphicsContext3D::RGBA, ResourceProvider::TextureUsageFramebuffer))
+        return scoped_ptr<ScopedTexture>();
 
-    const CCRenderPass* targetRenderPass = frame.currentRenderPass;
+    const RenderPass* targetRenderPass = frame.currentRenderPass;
     bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->quadRect());
 
     if (usingBackgroundTexture) {
         // Copy the readback pixels from device to the background texture for the surface.
         WebTransformationMatrix deviceToFramebufferTransform;
         deviceToFramebufferTransform.translate(quad->quadRect().width() / 2.0, quad->quadRect().height() / 2.0);
         deviceToFramebufferTransform.scale3d(quad->quadRect().width(), quad->quadRect().height(), 1);
         deviceToFramebufferTransform.multiply(contentsDeviceTransform.inverse());
         copyTextureToFramebuffer(frame, filteredDeviceBackgroundTextureId, deviceRect, deviceToFramebufferTransform);
     }
 
     useRenderPass(frame, targetRenderPass);
 
     if (!usingBackgroundTexture)
-        return scoped_ptr<CCScopedTexture>();
+        return scoped_ptr<ScopedTexture>();
     return backgroundTexture.Pass();
 }
 
-void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDrawQuad* quad)
+void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
     CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentsTexture || !contentsTexture->id())
         return;
 
-    const CCRenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
+    const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
     ASSERT(renderPass);
     if (!renderPass)
         return;
 
     WebTransformationMatrix quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->quadRect());
     WebTransformationMatrix contentsDeviceTransform = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();
 
     // Can only draw surface if device matrix is invertible.
     if (!contentsDeviceTransform.isInvertible())
         return;
 
-    scoped_ptr<CCScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);
+    scoped_ptr<ScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);
 
     // FIXME: Cache this value so that we don't have to do it for both the surface and its replica.
     // Apply filters to the contents texture.
     SkBitmap filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);
-    scoped_ptr<CCResourceProvider::ScopedReadLockGL> contentsResourceLock;
+    scoped_ptr<ResourceProvider::ScopedReadLockGL> contentsResourceLock;
     unsigned contentsTextureId = 0;
     if (filterBitmap.getTexture()) {
         GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());
         contentsTextureId = texture->getTextureHandle();
     } else {
-        contentsResourceLock = make_scoped_ptr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
+        contentsResourceLock = make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
         contentsTextureId = contentsResourceLock->textureId();
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
         ASSERT(backgroundTexture->size() == quad->quadRect().size());
-        CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
+        ResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
         copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
     }
 
     bool clipped = false;
-    FloatQuad deviceQuad = CCMathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
+    FloatQuad deviceQuad = MathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
     ASSERT(!clipped);
-    CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceQuad.boundingBox()));
-    CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceQuad);
+    LayerQuad deviceLayerBounds = LayerQuad(FloatQuad(deviceQuad.boundingBox()));
+    LayerQuad deviceLayerEdges = LayerQuad(deviceQuad);
 
     // Use anti-aliasing programs only when necessary.
     bool useAA = (!deviceQuad.isRectilinear() || !deviceQuad.boundingBox().isExpressibleAsIntRect());
     if (useAA) {
         deviceLayerBounds.inflateAntiAliasingDistance();
         deviceLayerEdges.inflateAntiAliasingDistance();
     }
 
-    scoped_ptr<CCResourceProvider::ScopedReadLockGL> maskResourceLock;
+    scoped_ptr<ResourceProvider::ScopedReadLockGL> maskResourceLock;
     unsigned maskTextureId = 0;
     if (quad->maskResourceId()) {
-        maskResourceLock.reset(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
+        maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
         maskTextureId = maskResourceLock->textureId();
     }
 
     // FIXME: use the backgroundTexture and blend the background in with this draw instead of having a separate copy of the background texture.
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     context()->bindTexture(GraphicsContext3D::TEXTURE_2D, contentsTextureId);
 
     int shaderQuadLocation = -1;
     int shaderEdgeLocation = -1;
@@ skipping 54 matching lines @@
     }
 
     if (shaderEdgeLocation != -1) {
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(shaderEdgeLocation, 8, edge));
     }
 
     // Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
-    FloatQuad surfaceQuad = CCMathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);
+    FloatQuad surfaceQuad = MathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);
     ASSERT(!clipped);
 
     setShaderOpacity(quad->opacity(), shaderAlphaLocation);
     setShaderFloatQuad(surfaceQuad, shaderQuadLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation);
 }
 
-void CCRendererGL::drawSolidColorQuad(const DrawingFrame& frame, const CCSolidColorDrawQuad* quad)
+void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
     const SolidColorProgram* program = solidColorProgram();
     GLC(context(), context()->useProgram(program->program()));
 
     SkColor color = quad->color();
     float opacity = quad->opacity();
     float alpha = (SkColorGetA(color) / 255.0) * opacity;
 
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
 
@@ skipping 18 matching lines @@
     uniforms.vertexTexTransformLocation = program->vertexShader().vertexTexTransformLocation();
     uniforms.matrixLocation = program->vertexShader().matrixLocation();
     uniforms.pointLocation = program->vertexShader().pointLocation();
 
     uniforms.samplerLocation = program->fragmentShader().samplerLocation();
     uniforms.alphaLocation = program->fragmentShader().alphaLocation();
     uniforms.fragmentTexTransformLocation = program->fragmentShader().fragmentTexTransformLocation();
     uniforms.edgeLocation = program->fragmentShader().edgeLocation();
 }
 
-void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad* quad)
+void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 {
     IntRect tileRect = quad->quadVisibleRect();
 
     FloatRect clampRect(tileRect);
     // Clamp texture coordinates to avoid sampling outside the layer
     // by deflating the tile region half a texel or half a texel
     // minus epsilon for one pixel layers. The resulting clamp region
     // is mapped to the unit square by the vertex shader and mapped
     // back to normalized texture coordinates by the fragment shader
     // after being clamped to 0-1 range.
@@ skipping 20 matching lines @@
     float fragmentTexScaleX = clampRect.width() / textureSize.width();
     float fragmentTexScaleY = clampRect.height() / textureSize.height();
 
 
     FloatQuad localQuad;
     WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();
     if (!deviceTransform.isInvertible())
         return;
 
     bool clipped = false;
-    FloatQuad deviceLayerQuad = CCMathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);
+    FloatQuad deviceLayerQuad = MathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);
     ASSERT(!clipped);
 
     TileProgramUniforms uniforms;
     // For now, we simply skip anti-aliasing with the quad is clipped. This only happens
     // on perspective transformed layers that go partially behind the camera.
     if (quad->isAntialiased() && !clipped) {
         if (quad->swizzleContents())
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
             tileUniformLocation(tileProgramAA(), uniforms);
     } else {
         if (quad->needsBlending()) {
             if (quad->swizzleContents())
                 tileUniformLocation(tileProgramSwizzle(), uniforms);
             else
                 tileUniformLocation(tileProgram(), uniforms);
         } else {
             if (quad->swizzleContents())
                 tileUniformLocation(tileProgramSwizzleOpaque(), uniforms);
             else
                 tileUniformLocation(tileProgramOpaque(), uniforms);
         }
     }
 
     GLC(context(), context()->useProgram(uniforms.program));
     GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
-    CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, quad->textureFilter()));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, quad->textureFilter()));
 
     bool useAA = !clipped && quad->isAntialiased();
     if (useAA) {
-        CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceLayerQuad.boundingBox()));
+        LayerQuad deviceLayerBounds = LayerQuad(FloatQuad(deviceLayerQuad.boundingBox()));
         deviceLayerBounds.inflateAntiAliasingDistance();
 
-        CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceLayerQuad);
+        LayerQuad deviceLayerEdges = LayerQuad(deviceLayerQuad);
         deviceLayerEdges.inflateAntiAliasingDistance();
 
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(uniforms.edgeLocation, 8, edge));
 
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
         GLC(context(), context()->uniform4f(uniforms.fragmentTexTransformLocation, fragmentTexTranslateX, fragmentTexTranslateY, fragmentTexScaleX, fragmentTexScaleY));
 
         FloatPoint bottomRight(tileRect.maxX(), tileRect.maxY());
         FloatPoint bottomLeft(tileRect.x(), tileRect.maxY());
         FloatPoint topLeft(tileRect.x(), tileRect.y());
         FloatPoint topRight(tileRect.maxX(), tileRect.y());
 
         // Map points to device space.
-        bottomRight = CCMathUtil::mapPoint(deviceTransform, bottomRight, clipped);
+        bottomRight = MathUtil::mapPoint(deviceTransform, bottomRight, clipped);
         ASSERT(!clipped);
-        bottomLeft = CCMathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
+        bottomLeft = MathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
         ASSERT(!clipped);
-        topLeft = CCMathUtil::mapPoint(deviceTransform, topLeft, clipped);
+        topLeft = MathUtil::mapPoint(deviceTransform, topLeft, clipped);
         ASSERT(!clipped);
-        topRight = CCMathUtil::mapPoint(deviceTransform, topRight, clipped);
+        topRight = MathUtil::mapPoint(deviceTransform, topRight, clipped);
         ASSERT(!clipped);
 
-        CCLayerQuad::Edge bottomEdge(bottomRight, bottomLeft);
-        CCLayerQuad::Edge leftEdge(bottomLeft, topLeft);
-        CCLayerQuad::Edge topEdge(topLeft, topRight);
-        CCLayerQuad::Edge rightEdge(topRight, bottomRight);
+        LayerQuad::Edge bottomEdge(bottomRight, bottomLeft);
+        LayerQuad::Edge leftEdge(bottomLeft, topLeft);
+        LayerQuad::Edge topEdge(topLeft, topRight);
+        LayerQuad::Edge rightEdge(topRight, bottomRight);
 
         // Only apply anti-aliasing to edges not clipped by culling or scissoring.
         if (quad->topEdgeAA() && tileRect.y() == quad->quadRect().y())
             topEdge = deviceLayerEdges.top();
         if (quad->leftEdgeAA() && tileRect.x() == quad->quadRect().x())
             leftEdge = deviceLayerEdges.left();
         if (quad->rightEdgeAA() && tileRect.maxX() == quad->quadRect().maxX())
             rightEdge = deviceLayerEdges.right();
         if (quad->bottomEdgeAA() && tileRect.maxY() == quad->quadRect().maxY())
             bottomEdge = deviceLayerEdges.bottom();
 
         float sign = FloatQuad(tileRect).isCounterclockwise() ? -1 : 1;
         bottomEdge.scale(sign);
         leftEdge.scale(sign);
         topEdge.scale(sign);
         rightEdge.scale(sign);
 
         // Create device space quad.
-        CCLayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
+        LayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
 
         // Map device space quad to local space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
         WebTransformationMatrix inverseDeviceTransform = deviceTransform.inverse();
-        localQuad = CCMathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped);
+        localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped);
 
         // We should not ASSERT(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
         // clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case.
     } else {
         // Move fragment shader transform to vertex shader. We can do this while
         // still producing correct results as fragmentTexTransformLocation
         // should always be non-negative when tiles are transformed in a way
         // that could result in sampling outside the layer.
         vertexTexScaleX *= fragmentTexScaleX;
         vertexTexScaleY *= fragmentTexScaleY;
@@ skipping 15 matching lines @@
 
     // The tile quad shader behaves differently compared to all other shaders.
     // The transform and vertex data are used to figure out the extents that the
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original quadRect.
     FloatRect centeredRect(FloatPoint(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size());
     drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation);
 }
 
-void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoDrawQuad* quad)
+void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQuad* quad)
 {
     const VideoYUVProgram* program = videoYUVProgram();
     ASSERT(program && program->initialized());
 
-    const CCVideoLayerImpl::FramePlane& yPlane = quad->yPlane();
-    const CCVideoLayerImpl::FramePlane& uPlane = quad->uPlane();
-    const CCVideoLayerImpl::FramePlane& vPlane = quad->vPlane();
+    const VideoLayerImpl::FramePlane& yPlane = quad->yPlane();
+    const VideoLayerImpl::FramePlane& uPlane = quad->uPlane();
+    const VideoLayerImpl::FramePlane& vPlane = quad->vPlane();
 
-    CCResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
-    CCResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
-    CCResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);
+    ResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
+    ResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
+    ResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1));
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, yPlaneLock.textureId()));
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE2));
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, uPlaneLock.textureId()));
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE3));
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, vPlaneLock.textureId()));
 
     GLC(context(), context()->useProgram(program->program()));
 
     float yWidthScaleFactor = static_cast<float>(yPlane.visibleSize.width()) / yPlane.size.width();
     // Arbitrarily take the u sizes because u and v dimensions are identical.
     float uvWidthScaleFactor = static_cast<float>(uPlane.visibleSize.width()) / uPlane.size.width();
     GLC(context(), context()->uniform1f(program->vertexShader().yWidthScaleFactorLocation(), yWidthScaleFactor));
     GLC(context(), context()->uniform1f(program->vertexShader().uvWidthScaleFactorLocation(), uvWidthScaleFactor));
 
     GLC(context(), context()->uniform1i(program->fragmentShader().yTextureLocation(), 1));
     GLC(context(), context()->uniform1i(program->fragmentShader().uTextureLocation(), 2));
     GLC(context(), context()->uniform1i(program->fragmentShader().vTextureLocation(), 3));
 
     // These values are magic numbers that are used in the transformation from YUV to RGB color values.
     // They are taken from the following webpage: http://www.fourcc.org/fccyvrgb.php
     float yuv2RGB[9] = {
         1.164f, 1.164f, 1.164f,
         0.f, -.391f, 2.018f,
         1.596f, -.813f, 0.f,
     };
-    GLC(context(), context()->uniformMatrix3fv(program->fragmentShader().ccMatrixLocation(), 1, 0, yuv2RGB));
+    GLC(context(), context()->uniformMatrix3fv(program->fragmentShader().matrixLocation(), 1, 0, yuv2RGB));
 
     // These values map to 16, 128, and 128 respectively, and are computed
     // as a fraction over 256 (e.g. 16 / 256 = 0.0625).
     // They are used in the YUV to RGBA conversion formula:
     //   Y - 16   : Gives 16 values of head and footroom for overshooting
     //   U - 128  : Turns unsigned U into signed U [-128,127]
     //   V - 128  : Turns unsigned V into signed V [-128,127]
     float yuvAdjust[3] = {
         -0.0625f,
         -0.5f,
         -0.5f,
     };
     GLC(context(), context()->uniform3fv(program->fragmentShader().yuvAdjLocation(), 1, yuvAdjust));
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());
 
     // Reset active texture back to texture 0.
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
 }
 
-void CCRendererGL::drawStreamVideoQuad(const DrawingFrame& frame, const CCStreamVideoDrawQuad* quad)
+void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVideoDrawQuad* quad)
 {
     static float glMatrix[16];
 
     ASSERT(m_capabilities.usingEglImage);
 
     const VideoStreamTextureProgram* program = videoStreamTextureProgram();
     GLC(context(), context()->useProgram(program->program()));
 
     toGLMatrix(&glMatrix[0], quad->matrix());
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix));
@@ skipping 24 matching lines @@
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
     template<class Program> void set(Program* program)
     {
         TextureProgramBinding::set(program);
         texTransformLocation = program->vertexShader().texTransformLocation();
     }
     int texTransformLocation;
 };
 
-void CCRendererGL::drawTextureQuad(const DrawingFrame& frame, const CCTextureDrawQuad* quad)
+void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
-    ASSERT(CCProxy::isImplThread());
+    ASSERT(Proxy::isImplThread());
 
     TexTransformTextureProgramBinding binding;
     if (quad->flipped())
         binding.set(textureProgramFlip());
     else
         binding.set(textureProgram());
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
     const FloatRect& uvRect = quad->uvRect();
     GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
-    CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));
 
     // FIXME: setting the texture parameters every time is redundant. Move this code somewhere
     // where it will only happen once per texture.
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE));
 
     if (!quad->premultipliedAlpha()) {
         // As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA)
         // will never cause the alpha channel to be set to anything less than 1.0 if it is
         // initialized to that value! Therefore, premultipliedAlpha being false is the first
         // situation we can generally see an alpha channel less than 1.0 coming out of the
         // compositor. This is causing platform differences in some layout tests (see
         // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use a separate
         // blend function for the alpha channel to avoid modifying it. Don't use colorMask for this
         // as it has performance implications on some platforms.
         GLC(context(), context()->blendFuncSeparate(GraphicsContext3D::SRC_ALPHA, GraphicsContext3D::ONE_MINUS_SRC_ALPHA, GraphicsContext3D::ZERO, GraphicsContext3D::ONE));
     }
 
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation);
 
     if (!quad->premultipliedAlpha())
         GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
 }
 
-void CCRendererGL::drawIOSurfaceQuad(const DrawingFrame& frame, const CCIOSurfaceDrawQuad* quad)
+void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDrawQuad* quad)
 {
-    ASSERT(CCProxy::isImplThread());
+    ASSERT(Proxy::isImplThread());
     TexTransformTextureProgramBinding binding;
     binding.set(textureIOSurfaceProgram());
 
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
-    if (quad->orientation() == CCIOSurfaceDrawQuad::Flipped)
+    if (quad->orientation() == IOSurfaceDrawQuad::Flipped)
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0));
     else
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height()));
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     GLC(context(), context()->bindTexture(Extensions3D::TEXTURE_RECTANGLE_ARB, quad->ioSurfaceTextureId()));
 
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation);
 
     GLC(context(), context()->bindTexture(Extensions3D::TEXTURE_RECTANGLE_ARB, 0));
 }
 
-void CCRendererGL::finishDrawingFrame(DrawingFrame& frame)
+void GLRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_swapBufferRect.unite(enclosingIntRect(frame.rootDamageRect));
 
     GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
     GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));
 }
 
-bool CCRendererGL::flippedFramebuffer() const
+bool GLRenderer::flippedFramebuffer() const
 {
     return true;
 }
 
-void CCRendererGL::toGLMatrix(float* flattened, const WebTransformationMatrix& m)
+void GLRenderer::toGLMatrix(float* flattened, const WebTransformationMatrix& m)
 {
     flattened[0] = m.m11();
     flattened[1] = m.m12();
     flattened[2] = m.m13();
     flattened[3] = m.m14();
     flattened[4] = m.m21();
     flattened[5] = m.m22();
     flattened[6] = m.m23();
     flattened[7] = m.m24();
     flattened[8] = m.m31();
     flattened[9] = m.m32();
     flattened[10] = m.m33();
     flattened[11] = m.m34();
     flattened[12] = m.m41();
     flattened[13] = m.m42();
     flattened[14] = m.m43();
     flattened[15] = m.m44();
 }
 
-void CCRendererGL::setShaderFloatQuad(const FloatQuad& quad, int quadLocation)
+void GLRenderer::setShaderFloatQuad(const FloatQuad& quad, int quadLocation)
 {
     if (quadLocation == -1)
         return;
 
     float point[8];
     point[0] = quad.p1().x();
     point[1] = quad.p1().y();
     point[2] = quad.p2().x();
     point[3] = quad.p2().y();
     point[4] = quad.p3().x();
     point[5] = quad.p3().y();
     point[6] = quad.p4().x();
     point[7] = quad.p4().y();
     GLC(m_context, m_context->uniform2fv(quadLocation, 4, point));
 }
 
-void CCRendererGL::setShaderOpacity(float opacity, int alphaLocation)
+void GLRenderer::setShaderOpacity(float opacity, int alphaLocation)
 {
     if (alphaLocation != -1)
         GLC(m_context, m_context->uniform1f(alphaLocation, opacity));
 }
 
-void CCRendererGL::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation)
+void GLRenderer::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation)
 {
     WebTransformationMatrix quadRectMatrix;
     quadRectTransform(&quadRectMatrix, drawTransform, quadRect);
     static float glMatrix[16];
     toGLMatrix(&glMatrix[0], frame.projectionMatrix * quadRectMatrix);
     GLC(m_context, m_context->uniformMatrix4fv(matrixLocation, 1, false, &glMatrix[0]));
 
     GLC(m_context, m_context->drawElements(GraphicsContext3D::TRIANGLES, 6, GraphicsContext3D::UNSIGNED_SHORT, 0));
 }
 
-void CCRendererGL::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const IntRect& rect, const WebTransformationMatrix& drawMatrix)
+void GLRenderer::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const IntRect& rect, const WebTransformationMatrix& drawMatrix)
 {
     const RenderPassProgram* program = renderPassProgram();
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE));
 
     GLC(context(), context()->useProgram(program->program()));
     GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
     setShaderOpacity(1, program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, drawMatrix, rect, program->vertexShader().matrixLocation());
 }
 
-void CCRendererGL::finish()
+void GLRenderer::finish()
 {
-    TRACE_EVENT0("cc", "CCRendererGL::finish");
+    TRACE_EVENT0("cc", "GLRenderer::finish");
     m_context->finish();
 }
 
-bool CCRendererGL::swapBuffers()
+bool GLRenderer::swapBuffers()
 {
     ASSERT(m_visible);
     ASSERT(!m_isFramebufferDiscarded);
 
-    TRACE_EVENT0("cc", "CCRendererGL::swapBuffers");
+    TRACE_EVENT0("cc", "GLRenderer::swapBuffers");
     // We're done! Time to swapbuffers!
 
     if (m_capabilities.usingPartialSwap) {
         // If supported, we can save significant bandwidth by only swapping the damaged/scissored region (clamped to the viewport)
         m_swapBufferRect.intersect(IntRect(IntPoint(), viewportSize()));
         int flippedYPosOfRectBottom = viewportHeight() - m_swapBufferRect.y() - m_swapBufferRect.height();
         m_context->postSubBufferCHROMIUM(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height());
     } else {
         // Note that currently this has the same effect as swapBuffers; we should
         // consider exposing a different entry point on WebGraphicsContext3D.
         m_context->prepareTexture();
     }
 
     m_swapBufferRect = IntRect();
 
     return true;
 }
 
-void CCRendererGL::onSwapBuffersComplete()
+void GLRenderer::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersComplete();
 }
 
-void CCRendererGL::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)
+void GLRenderer::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)
 {
     // FIXME: This is called on the main thread in single threaded mode, but we expect it on the impl thread.
-    if (!CCProxy::hasImplThread()) {
-      ASSERT(CCProxy::isMainThread());
+    if (!Proxy::hasImplThread()) {
+      ASSERT(Proxy::isMainThread());
       DebugScopedSetImplThread impl;
       onMemoryAllocationChangedOnImplThread(allocation);
     } else {
-      ASSERT(CCProxy::isImplThread());
+      ASSERT(Proxy::isImplThread());
       onMemoryAllocationChangedOnImplThread(allocation);
     }
 }
 
-void CCRendererGL::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation allocation)
+void GLRenderer::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation allocation)
 {
     m_discardFramebufferWhenNotVisible = !allocation.suggestHaveBackbuffer;
     // Just ignore the memory manager when it says to set the limit to zero
     // bytes. This will happen when the memory manager thinks that the renderer
     // is not visible (which the renderer knows better).
     if (allocation.gpuResourceSizeInBytes)
         m_client->setMemoryAllocationLimitBytes(allocation.gpuResourceSizeInBytes);
     enforceMemoryPolicy();
 }
 
-void CCRendererGL::enforceMemoryPolicy()
+void GLRenderer::enforceMemoryPolicy()
 {
     if (!m_visible) {
-        TRACE_EVENT0("cc", "CCRendererGL::enforceMemoryPolicy dropping resources");
+        TRACE_EVENT0("cc", "GLRenderer::enforceMemoryPolicy dropping resources");
         releaseRenderPassTextures();
         if (m_discardFramebufferWhenNotVisible)
             discardFramebuffer();
         GLC(m_context, m_context->flush());
     }
 }
 
-void CCRendererGL::discardFramebuffer()
+void GLRenderer::discardFramebuffer()
 {
     if (m_isFramebufferDiscarded)
         return;
 
     if (!m_capabilities.usingDiscardFramebuffer)
         return;
 
     // FIXME: Update attachments argument to appropriate values once they are no longer ignored.
     m_context->discardFramebufferEXT(GraphicsContext3D::TEXTURE_2D, 0, 0);
     m_isFramebufferDiscarded = true;
 
     // Damage tracker needs a full reset every time framebuffer is discarded.
     m_client->setFullRootLayerDamage();
 }
 
-void CCRendererGL::ensureFramebuffer()
+void GLRenderer::ensureFramebuffer()
 {
     if (!m_isFramebufferDiscarded)
         return;
 
     if (!m_capabilities.usingDiscardFramebuffer)
         return;
 
     m_context->ensureFramebufferCHROMIUM();
     m_isFramebufferDiscarded = false;
 }
 
-void CCRendererGL::onContextLost()
+void GLRenderer::onContextLost()
 {
     m_client->didLoseContext();
 }
 
 
-void CCRendererGL::getFramebufferPixels(void *pixels, const IntRect& rect)
+void GLRenderer::getFramebufferPixels(void *pixels, const IntRect& rect)
 {
     ASSERT(rect.maxX() <= viewportWidth() && rect.maxY() <= viewportHeight());
 
     if (!pixels)
         return;
 
     makeContextCurrent();
 
     bool doWorkaround = needsIOSurfaceReadbackWorkaround();
 
@@ skipping 46 matching lines @@
         // Clean up.
         GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
         GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0));
         GLC(m_context, m_context->deleteFramebuffer(temporaryFBO));
         GLC(m_context, m_context->deleteTexture(temporaryTexture));
     }
 
     enforceMemoryPolicy();
 }
 
-bool CCRendererGL::getFramebufferTexture(CCScopedTexture* texture, const IntRect& deviceRect)
+bool GLRenderer::getFramebufferTexture(ScopedTexture* texture, const IntRect& deviceRect)
 {
     ASSERT(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GraphicsContext3D::RGB));
 
-    if (!texture->id() && !texture->allocate(CCRenderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, CCResourceProvider::TextureUsageAny))
+    if (!texture->id() && !texture->allocate(Renderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, ResourceProvider::TextureUsageAny))
         return false;
 
-    CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
+    ResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
     GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId()));
     GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),
                                              deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0));
     return true;
 }
 
-bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& viewportRect)
+bool GLRenderer::useScopedTexture(DrawingFrame& frame, const ScopedTexture* texture, const IntRect& viewportRect)
 {
     ASSERT(texture->id());
     frame.currentRenderPass = 0;
     frame.currentTexture = texture;
 
     return bindFramebufferToTexture(frame, texture, viewportRect);
 }
 
-void CCRendererGL::bindFramebufferToOutputSurface(DrawingFrame& frame)
+void GLRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
 }
 
-bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect)
+bool GLRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedTexture* texture, const IntRect& framebufferRect)
 {
     ASSERT(texture->id());
 
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId));
-    m_currentFramebufferLock = make_scoped_ptr(new CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
+    m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
     unsigned textureId = m_currentFramebufferLock->textureId();
     GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, textureId, 0));
 
 #if !defined ( NDEBUG )
     if (m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
         ASSERT_NOT_REACHED();
         return false;
     }
 #endif
 
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
 }
 
-void CCRendererGL::enableScissorTestRect(const IntRect& scissorRect)
+void GLRenderer::enableScissorTestRect(const IntRect& scissorRect)
 {
     GLC(m_context, m_context->enable(GraphicsContext3D::SCISSOR_TEST));
     GLC(m_context, m_context->scissor(scissorRect.x(), scissorRect.y(), scissorRect.width(), scissorRect.height()));
 }
 
-void CCRendererGL::disableScissorTest()
+void GLRenderer::disableScissorTest()
 {
     GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
 }
 
-void CCRendererGL::setDrawViewportSize(const IntSize& viewportSize)
+void GLRenderer::setDrawViewportSize(const IntSize& viewportSize)
 {
     GLC(m_context, m_context->viewport(0, 0, viewportSize.width(), viewportSize.height()));
 }
 
-bool CCRendererGL::makeContextCurrent()
+bool GLRenderer::makeContextCurrent()
 {
     return m_context->makeContextCurrent();
 }
 
-bool CCRendererGL::initializeSharedObjects()
+bool GLRenderer::initializeSharedObjects()
 {
-    TRACE_EVENT0("cc", "CCRendererGL::initializeSharedObjects");
+    TRACE_EVENT0("cc", "GLRenderer::initializeSharedObjects");
     makeContextCurrent();
 
     // Create an FBO for doing offscreen rendering.
     GLC(m_context, m_offscreenFramebufferId = m_context->createFramebuffer());
 
     // We will always need these programs to render, so create the programs eagerly so that the shader compilation can
     // start while we do other work. Other programs are created lazily on first access.
     m_sharedGeometry = make_scoped_ptr(new GeometryBinding(m_context, quadVertexRect()));
     m_renderPassProgram = make_scoped_ptr(new RenderPassProgram(m_context));
     m_tileProgram = make_scoped_ptr(new TileProgram(m_context));
     m_tileProgramOpaque = make_scoped_ptr(new TileProgramOpaque(m_context));
 
     GLC(m_context, m_context->flush());
 
     return true;
 }
 
-const CCRendererGL::TileCheckerboardProgram* CCRendererGL::tileCheckerboardProgram()
+const GLRenderer::TileCheckerboardProgram* GLRenderer::tileCheckerboardProgram()
 {
     if (!m_tileCheckerboardProgram)
         m_tileCheckerboardProgram = make_scoped_ptr(new TileCheckerboardProgram(m_context));
     if (!m_tileCheckerboardProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::checkerboardProgram::initalize");
+        TRACE_EVENT0("cc", "GLRenderer::checkerboardProgram::initalize");
         m_tileCheckerboardProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileCheckerboardProgram.get();
 }
 
-const CCRendererGL::SolidColorProgram* CCRendererGL::solidColorProgram()
+const GLRenderer::SolidColorProgram* GLRenderer::solidColorProgram()
 {
     if (!m_solidColorProgram)
         m_solidColorProgram = make_scoped_ptr(new SolidColorProgram(m_context));
     if (!m_solidColorProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::solidColorProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::solidColorProgram::initialize");
         m_solidColorProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_solidColorProgram.get();
 }
 
-const CCRendererGL::RenderPassProgram* CCRendererGL::renderPassProgram()
+const GLRenderer::RenderPassProgram* GLRenderer::renderPassProgram()
 {
     ASSERT(m_renderPassProgram);
     if (!m_renderPassProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::renderPassProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::renderPassProgram::initialize");
         m_renderPassProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_renderPassProgram.get();
 }
 
-const CCRendererGL::RenderPassProgramAA* CCRendererGL::renderPassProgramAA()
+const GLRenderer::RenderPassProgramAA* GLRenderer::renderPassProgramAA()
 {
     if (!m_renderPassProgramAA)
         m_renderPassProgramAA = make_scoped_ptr(new RenderPassProgramAA(m_context));
     if (!m_renderPassProgramAA->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::renderPassProgramAA::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::renderPassProgramAA::initialize");
         m_renderPassProgramAA->initialize(m_context, m_isUsingBindUniform);
     }
     return m_renderPassProgramAA.get();
 }
 
-const CCRendererGL::RenderPassMaskProgram* CCRendererGL::renderPassMaskProgram()
+const GLRenderer::RenderPassMaskProgram* GLRenderer::renderPassMaskProgram()
 {
     if (!m_renderPassMaskProgram)
         m_renderPassMaskProgram = make_scoped_ptr(new RenderPassMaskProgram(m_context));
     if (!m_renderPassMaskProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgram::initialize");
         m_renderPassMaskProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_renderPassMaskProgram.get();
 }
 
-const CCRendererGL::RenderPassMaskProgramAA* CCRendererGL::renderPassMaskProgramAA()
+const GLRenderer::RenderPassMaskProgramAA* GLRenderer::renderPassMaskProgramAA()
 {
     if (!m_renderPassMaskProgramAA)
         m_renderPassMaskProgramAA = make_scoped_ptr(new RenderPassMaskProgramAA(m_context));
     if (!m_renderPassMaskProgramAA->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgramAA::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgramAA::initialize");
         m_renderPassMaskProgramAA->initialize(m_context, m_isUsingBindUniform);
     }
     return m_renderPassMaskProgramAA.get();
 }
 
-const CCRendererGL::TileProgram* CCRendererGL::tileProgram()
+const GLRenderer::TileProgram* GLRenderer::tileProgram()
 {
     ASSERT(m_tileProgram);
     if (!m_tileProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::tileProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::tileProgram::initialize");
         m_tileProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgram.get();
 }
 
-const CCRendererGL::TileProgramOpaque* CCRendererGL::tileProgramOpaque()
+const GLRenderer::TileProgramOpaque* GLRenderer::tileProgramOpaque()
 {
     ASSERT(m_tileProgramOpaque);
     if (!m_tileProgramOpaque->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::tileProgramOpaque::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::tileProgramOpaque::initialize");
         m_tileProgramOpaque->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgramOpaque.get();
 }
 
-const CCRendererGL::TileProgramAA* CCRendererGL::tileProgramAA()
+const GLRenderer::TileProgramAA* GLRenderer::tileProgramAA()
 {
     if (!m_tileProgramAA)
         m_tileProgramAA = make_scoped_ptr(new TileProgramAA(m_context));
     if (!m_tileProgramAA->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::tileProgramAA::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::tileProgramAA::initialize");
         m_tileProgramAA->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgramAA.get();
 }
 
-const CCRendererGL::TileProgramSwizzle* CCRendererGL::tileProgramSwizzle()
+const GLRenderer::TileProgramSwizzle* GLRenderer::tileProgramSwizzle()
 {
     if (!m_tileProgramSwizzle)
         m_tileProgramSwizzle = make_scoped_ptr(new TileProgramSwizzle(m_context));
     if (!m_tileProgramSwizzle->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzle::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzle::initialize");
         m_tileProgramSwizzle->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgramSwizzle.get();
 }
 
-const CCRendererGL::TileProgramSwizzleOpaque* CCRendererGL::tileProgramSwizzleOpaque()
+const GLRenderer::TileProgramSwizzleOpaque* GLRenderer::tileProgramSwizzleOpaque()
 {
     if (!m_tileProgramSwizzleOpaque)
         m_tileProgramSwizzleOpaque = make_scoped_ptr(new TileProgramSwizzleOpaque(m_context));
     if (!m_tileProgramSwizzleOpaque->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzleOpaque::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleOpaque::initialize");
         m_tileProgramSwizzleOpaque->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgramSwizzleOpaque.get();
 }
 
-const CCRendererGL::TileProgramSwizzleAA* CCRendererGL::tileProgramSwizzleAA()
+const GLRenderer::TileProgramSwizzleAA* GLRenderer::tileProgramSwizzleAA()
 {
     if (!m_tileProgramSwizzleAA)
         m_tileProgramSwizzleAA = make_scoped_ptr(new TileProgramSwizzleAA(m_context));
     if (!m_tileProgramSwizzleAA->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzleAA::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleAA::initialize");
         m_tileProgramSwizzleAA->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgramSwizzleAA.get();
 }
 
-const CCRendererGL::TextureProgram* CCRendererGL::textureProgram()
+const GLRenderer::TextureProgram* GLRenderer::textureProgram()
 {
     if (!m_textureProgram)
         m_textureProgram = make_scoped_ptr(new TextureProgram(m_context));
     if (!m_textureProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::textureProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
         m_textureProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_textureProgram.get();
 }
 
-const CCRendererGL::TextureProgramFlip* CCRendererGL::textureProgramFlip()
+const GLRenderer::TextureProgramFlip* GLRenderer::textureProgramFlip()
 {
     if (!m_textureProgramFlip)
         m_textureProgramFlip = make_scoped_ptr(new TextureProgramFlip(m_context));
     if (!m_textureProgramFlip->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::textureProgramFlip::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::textureProgramFlip::initialize");
         m_textureProgramFlip->initialize(m_context, m_isUsingBindUniform);
     }
     return m_textureProgramFlip.get();
 }
 
-const CCRendererGL::TextureIOSurfaceProgram* CCRendererGL::textureIOSurfaceProgram()
+const GLRenderer::TextureIOSurfaceProgram* GLRenderer::textureIOSurfaceProgram()
 {
     if (!m_textureIOSurfaceProgram)
         m_textureIOSurfaceProgram = make_scoped_ptr(new TextureIOSurfaceProgram(m_context));
     if (!m_textureIOSurfaceProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::textureIOSurfaceProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");
         m_textureIOSurfaceProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_textureIOSurfaceProgram.get();
 }
 
-const CCRendererGL::VideoYUVProgram* CCRendererGL::videoYUVProgram()
+const GLRenderer::VideoYUVProgram* GLRenderer::videoYUVProgram()
 {
     if (!m_videoYUVProgram)
         m_videoYUVProgram = make_scoped_ptr(new VideoYUVProgram(m_context));
     if (!m_videoYUVProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::videoYUVProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");
         m_videoYUVProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_videoYUVProgram.get();
 }
 
-const CCRendererGL::VideoStreamTextureProgram* CCRendererGL::videoStreamTextureProgram()
+const GLRenderer::VideoStreamTextureProgram* GLRenderer::videoStreamTextureProgram()
 {
     if (!m_videoStreamTextureProgram)
         m_videoStreamTextureProgram = make_scoped_ptr(new VideoStreamTextureProgram(m_context));
     if (!m_videoStreamTextureProgram->initialized()) {
-        TRACE_EVENT0("cc", "CCRendererGL::streamTextureProgram::initialize");
+        TRACE_EVENT0("cc", "GLRenderer::streamTextureProgram::initialize");
         m_videoStreamTextureProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_videoStreamTextureProgram.get();
 }
 
-void CCRendererGL::cleanupSharedObjects()
+void GLRenderer::cleanupSharedObjects()
 {
     makeContextCurrent();
 
     m_sharedGeometry.reset();
 
     if (m_tileProgram)
         m_tileProgram->cleanup(m_context);
     if (m_tileProgramOpaque)
         m_tileProgramOpaque->cleanup(m_context);
     if (m_tileProgramSwizzle)
@@ skipping 30 matching lines @@
 
     if (m_solidColorProgram)
         m_solidColorProgram->cleanup(m_context);
 
     if (m_offscreenFramebufferId)
         GLC(m_context, m_context->deleteFramebuffer(m_offscreenFramebufferId));
 
     releaseRenderPassTextures();
 }
 
-bool CCRendererGL::isContextLost()
+bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace cc