cc: Rename cc classes and members to match filenames

cc/heads_up_display_layer_impl.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCHeadsUpDisplayLayerImpl.h"
 
 #include "base/stringprintf.h"
 #include "ui/gfx/point.h"
@@ skipping 22 matching lines @@
     swizzleMatrix.fMat[0 + 5 * 2] = 1;
     swizzleMatrix.fMat[1 + 5 * 1] = 1;
     swizzleMatrix.fMat[2 + 5 * 0] = 1;
     swizzleMatrix.fMat[3 + 5 * 3] = 1;
 
     SkPaint paint;
     paint.setColorFilter(new SkColorMatrixFilter(swizzleMatrix))->unref();
     return paint;
 }
 
-CCHeadsUpDisplayLayerImpl::CCHeadsUpDisplayLayerImpl(int id)
-    : CCLayerImpl(id)
+HeadsUpDisplayLayerImpl::HeadsUpDisplayLayerImpl(int id)
+    : LayerImpl(id)
 {
 }
 
-CCHeadsUpDisplayLayerImpl::~CCHeadsUpDisplayLayerImpl()
+HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl()
 {
 }
 
-void CCHeadsUpDisplayLayerImpl::setFontAtlas(scoped_ptr<CCFontAtlas> fontAtlas)
+void HeadsUpDisplayLayerImpl::setFontAtlas(scoped_ptr<FontAtlas> fontAtlas)
 {
     m_fontAtlas = fontAtlas.Pass();
 }
 
-void CCHeadsUpDisplayLayerImpl::willDraw(CCResourceProvider* resourceProvider)
+void HeadsUpDisplayLayerImpl::willDraw(ResourceProvider* resourceProvider)
 {
-    CCLayerImpl::willDraw(resourceProvider);
+    LayerImpl::willDraw(resourceProvider);
 
     if (!m_hudTexture)
-        m_hudTexture = CCScopedTexture::create(resourceProvider);
+        m_hudTexture = ScopedTexture::create(resourceProvider);
 
     // FIXME: Scale the HUD by deviceScale to make it more friendly under high DPI.
 
     if (m_hudTexture->size() != bounds())
         m_hudTexture->free();
 
     if (!m_hudTexture->id())
-        m_hudTexture->allocate(CCRenderer::ImplPool, bounds(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny);
+        m_hudTexture->allocate(Renderer::ImplPool, bounds(), GraphicsContext3D::RGBA, ResourceProvider::TextureUsageAny);
 }
 
-void CCHeadsUpDisplayLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
+void HeadsUpDisplayLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 {
     if (!m_hudTexture->id())
         return;
 
-    CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
+    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
     IntRect quadRect(IntPoint(), bounds());
     bool premultipliedAlpha = true;
     FloatRect uvRect(0, 0, 1, 1);
     bool flipped = false;
-    quadSink.append(CCTextureDrawQuad::create(sharedQuadState, quadRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped).PassAs<CCDrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData);
 }
 
-void CCHeadsUpDisplayLayerImpl::updateHudTexture(CCResourceProvider* resourceProvider)
+void HeadsUpDisplayLayerImpl::updateHudTexture(ResourceProvider* resourceProvider)
 {
     if (!m_hudTexture->id())
         return;
 
     SkISize canvasSize;
     if (m_hudCanvas)
         canvasSize = m_hudCanvas->getDeviceSize();
     else
         canvasSize.set(0, 0);
 
     if (canvasSize.fWidth != bounds().width() || canvasSize.fHeight != bounds().height() || !m_hudCanvas)
         m_hudCanvas = make_scoped_ptr(skia::CreateBitmapCanvas(bounds().width(), bounds().height(), false /* opaque */));
 
     m_hudCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
     drawHudContents(m_hudCanvas.get());
 
     const SkBitmap* bitmap = &m_hudCanvas->getDevice()->accessBitmap(false);
     SkAutoLockPixels locker(*bitmap);
 
     IntRect layerRect(IntPoint(), bounds());
     ASSERT(bitmap->config() == SkBitmap::kARGB_8888_Config);
     resourceProvider->upload(m_hudTexture->id(), static_cast<const uint8_t*>(bitmap->getPixels()), layerRect, layerRect, IntSize());
 }
 
-void CCHeadsUpDisplayLayerImpl::didDraw(CCResourceProvider* resourceProvider)
+void HeadsUpDisplayLayerImpl::didDraw(ResourceProvider* resourceProvider)
 {
-    CCLayerImpl::didDraw(resourceProvider);
+    LayerImpl::didDraw(resourceProvider);
 
     if (!m_hudTexture->id())
         return;
 
     // FIXME: the following assert will not be true when sending resources to a
     // parent compositor. We will probably need to hold on to m_hudTexture for
     // longer, and have several HUD textures in the pipeline.
     ASSERT(!resourceProvider->inUseByConsumer(m_hudTexture->id()));
 }
 
-void CCHeadsUpDisplayLayerImpl::didLoseContext()
+void HeadsUpDisplayLayerImpl::didLoseContext()
 {
     m_hudTexture.reset();
 }
 
-bool CCHeadsUpDisplayLayerImpl::layerIsAlwaysDamaged() const
+bool HeadsUpDisplayLayerImpl::layerIsAlwaysDamaged() const
 {
     return true;
 }
 
-void CCHeadsUpDisplayLayerImpl::drawHudContents(SkCanvas* canvas)
+void HeadsUpDisplayLayerImpl::drawHudContents(SkCanvas* canvas)
 {
-    const CCLayerTreeSettings& settings = layerTreeHostImpl()->settings();
+    const LayerTreeSettings& settings = layerTreeHostImpl()->settings();
 
     if (settings.showPlatformLayerTree) {
         SkPaint paint = createPaint();
         paint.setColor(SkColorSetARGB(192, 0, 0, 0));
         canvas->drawRect(SkRect::MakeXYWH(0, 0, bounds().width(), bounds().height()), paint);
     }
 
     int fpsCounterHeight = 40;
     int fpsCounterTop = 2;
     int platformLayerTreeTop;
 
     if (settings.showFPSCounter)
         platformLayerTreeTop = fpsCounterTop + fpsCounterHeight;
     else
         platformLayerTreeTop = 0;
 
     if (settings.showFPSCounter)
         drawFPSCounter(canvas, layerTreeHostImpl()->fpsCounter(), fpsCounterTop, fpsCounterHeight);
 
     if (settings.showPlatformLayerTree && m_fontAtlas.get()) {
         std::string layerTree = layerTreeHostImpl()->layerTreeAsText();
         m_fontAtlas->drawText(canvas, createPaint(), layerTree, gfx::Point(2, platformLayerTreeTop), bounds());
     }
 
     if (settings.showDebugRects())
         drawDebugRects(canvas, layerTreeHostImpl()->debugRectHistory());
 }
 
-void CCHeadsUpDisplayLayerImpl::drawFPSCounter(SkCanvas* canvas, CCFrameRateCounter* fpsCounter, int top, int height)
+void HeadsUpDisplayLayerImpl::drawFPSCounter(SkCanvas* canvas, FrameRateCounter* fpsCounter, int top, int height)
 {
     float textWidth = 170; // so text fits on linux.
     float graphWidth = fpsCounter->timeStampHistorySize();
 
     // Draw the FPS text.
     drawFPSCounterText(canvas, fpsCounter, top, textWidth, height);
 
     // Draw FPS graph.
     const double loFPS = 0;
     const double hiFPS = 80;
@@ skipping 35 matching lines @@
             path.lineTo(cur);
         x += 1;
     }
     paint.setColor(SK_ColorRED);
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(1);
     paint.setAntiAlias(true);
     canvas->drawPath(path, paint);
 }
 
-void CCHeadsUpDisplayLayerImpl::drawFPSCounterText(SkCanvas* canvas, CCFrameRateCounter* fpsCounter, int top, int width, int height)
+void HeadsUpDisplayLayerImpl::drawFPSCounterText(SkCanvas* canvas, FrameRateCounter* fpsCounter, int top, int width, int height)
 {
     double averageFPS, stdDeviation;
     fpsCounter->getAverageFPSAndStandardDeviation(averageFPS, stdDeviation);
 
     // Draw background.
     SkPaint paint = createPaint();
     paint.setColor(SK_ColorBLACK);
     canvas->drawRect(SkRect::MakeXYWH(2, top, width, height), paint);
 
     // Draw FPS text.
     if (m_fontAtlas.get())
         m_fontAtlas->drawText(canvas, createPaint(), base::StringPrintf("FPS: %4.1f +/- %3.1f", averageFPS, stdDeviation), gfx::Point(10, height / 3), IntSize(width, height));
 }
 
-void CCHeadsUpDisplayLayerImpl::drawDebugRects(SkCanvas* canvas, CCDebugRectHistory* debugRectHistory)
+void HeadsUpDisplayLayerImpl::drawDebugRects(SkCanvas* canvas, DebugRectHistory* debugRectHistory)
 {
-    const Vector<CCDebugRect>& debugRects = debugRectHistory->debugRects();
+    const Vector<DebugRect>& debugRects = debugRectHistory->debugRects();
 
     for (size_t i = 0; i < debugRects.size(); ++i) {
         SkColor strokeColor = 0;
         SkColor fillColor = 0;
 
         switch (debugRects[i].type) {
         case PaintRectType:
             // Paint rects in red
             strokeColor = SkColorSetARGB(255, 255, 0, 0);
             fillColor = SkColorSetARGB(30, 255, 0, 0);
@@ skipping 31 matching lines @@
         paint.setColor(fillColor);
         canvas->drawRect(skRect, paint);
 
         paint.setColor(strokeColor);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(2);
         canvas->drawRect(skRect, paint);
     }
 }
 
-const char* CCHeadsUpDisplayLayerImpl::layerTypeAsString() const
+const char* HeadsUpDisplayLayerImpl::layerTypeAsString() const
 {
     return "HeadsUpDisplayLayer";
 }
 
 }