cc: Chromify Layer and LayerImpl classes.

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 "cc/heads_up_display_layer_impl.h"
 
 #include "base/stringprintf.h"
 #include "base/strings/string_split.h"
 #include "cc/debug_colors.h"
 #include "cc/debug_rect_history.h"
@@ skipping 62 matching lines @@
     , m_fpsGraph(60.0, 80.0)
     , m_paintTimeGraph(16.0, 48.0)
     , m_typeface(skia::AdoptRef(SkFontHost::CreateTypeface(NULL, "monospace", SkTypeface::kBold)))
 {
 }
 
 HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl()
 {
 }
 
-scoped_ptr<LayerImpl> HeadsUpDisplayLayerImpl::createLayerImpl(LayerTreeImpl* treeImpl)
+scoped_ptr<LayerImpl> HeadsUpDisplayLayerImpl::CreateLayerImpl(LayerTreeImpl* treeImpl)
 {
-    return HeadsUpDisplayLayerImpl::create(treeImpl, id()).PassAs<LayerImpl>();
+    return HeadsUpDisplayLayerImpl::Create(treeImpl, id()).PassAs<LayerImpl>();
 }
 
-void HeadsUpDisplayLayerImpl::willDraw(ResourceProvider* resourceProvider)
+void HeadsUpDisplayLayerImpl::WillDraw(ResourceProvider* resourceProvider)
 {
-    LayerImpl::willDraw(resourceProvider);
+    LayerImpl::WillDraw(resourceProvider);
 
     if (!m_hudTexture)
         m_hudTexture = ScopedResource::create(resourceProvider);
 
     // TODO(danakj): Scale the HUD by deviceScale to make it more friendly under high DPI.
 
     // TODO(danakj): The HUD could swap between two textures instead of creating a texture every frame in ubercompositor.
     if (m_hudTexture->size() != bounds() || resourceProvider->InUseByConsumer(m_hudTexture->id()))
         m_hudTexture->Free();
 
     if (!m_hudTexture->id()) {
         m_hudTexture->Allocate(bounds(), GL_RGBA, ResourceProvider::TextureUsageAny);
         // TODO(epenner): This texture was being used before SetPixels was called,
         // which is now not allowed (it's an uninitialized read). This should be fixed
         // and this allocateForTesting() removed.
         // http://crbug.com/166784
         resourceProvider->AllocateForTesting(m_hudTexture->id());
     }
 }
 
-void HeadsUpDisplayLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
+void HeadsUpDisplayLayerImpl::AppendQuads(QuadSink* quadSink, AppendQuadsData* appendQuadsData)
 {
     if (!m_hudTexture->id())
         return;
 
-    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
+    SharedQuadState* sharedQuadState = quadSink->useSharedQuadState(CreateSharedQuadState());
 
     gfx::Rect quadRect(gfx::Point(), bounds());
-    gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
+    gfx::Rect opaqueRect(contents_opaque() ? quadRect : gfx::Rect());
     bool premultipliedAlpha = true;
     gfx::PointF uv_top_left(0.f, 0.f);
     gfx::PointF uv_bottom_right(1.f, 1.f);
     const float vertex_opacity[] = {1.f, 1.f, 1.f, 1.f};
     bool flipped = false;
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uv_top_left, uv_bottom_right, vertex_opacity, flipped);
-    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+    quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 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 */));
 
     updateHudContents();
 
     m_hudCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
     drawHudContents(m_hudCanvas.get());
 
     const SkBitmap* bitmap = &m_hudCanvas->getDevice()->accessBitmap(false);
     SkAutoLockPixels locker(*bitmap);
 
-    gfx::Rect layerRect(gfx::Point(), bounds());
+    gfx::Rect layerRect(bounds());
     DCHECK(bitmap->config() == SkBitmap::kARGB_8888_Config);
     resourceProvider->SetPixels(m_hudTexture->id(), static_cast<const uint8_t*>(bitmap->getPixels()), layerRect, layerRect, gfx::Vector2d());
 }
 
-void HeadsUpDisplayLayerImpl::didDraw(ResourceProvider* resourceProvider)
+void HeadsUpDisplayLayerImpl::DidDraw(ResourceProvider* resourceProvider)
 {
-    LayerImpl::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.
     DCHECK(!resourceProvider->InUseByConsumer(m_hudTexture->id()));
 }
 
-void HeadsUpDisplayLayerImpl::didLoseOutputSurface()
+void HeadsUpDisplayLayerImpl::DidLoseOutputSurface()
 {
     m_hudTexture.reset();
 }
 
-bool HeadsUpDisplayLayerImpl::layerIsAlwaysDamaged() const
+bool HeadsUpDisplayLayerImpl::LayerIsAlwaysDamaged() const
 {
     return true;
 }
 
 void HeadsUpDisplayLayerImpl::updateHudContents()
 {
-    const LayerTreeDebugState& debugState = layerTreeImpl()->debug_state();
+    const LayerTreeDebugState& debugState = layer_tree_impl()->debug_state();
 
     // Don't update numbers every frame so text is readable.
-    base::TimeTicks now = layerTreeImpl()->CurrentFrameTime();
+    base::TimeTicks now = layer_tree_impl()->CurrentFrameTime();
     if (base::TimeDelta(now - m_timeOfLastGraphUpdate).InSecondsF() > 0.25f) {
         m_timeOfLastGraphUpdate = now;
 
         if (debugState.showFPSCounter) {
-            FrameRateCounter* fpsCounter = layerTreeImpl()->frame_rate_counter();
+            FrameRateCounter* fpsCounter = layer_tree_impl()->frame_rate_counter();
             m_fpsGraph.value = fpsCounter->getAverageFPS();
             fpsCounter->getMinAndMaxFPS(m_fpsGraph.min, m_fpsGraph.max);
         }
 
         if (debugState.continuousPainting) {
-            PaintTimeCounter* paintTimeCounter = layerTreeImpl()->paint_time_counter();
+            PaintTimeCounter* paintTimeCounter = layer_tree_impl()->paint_time_counter();
             base::TimeDelta latest, min, max;
 
             if (paintTimeCounter->End())
                 latest = paintTimeCounter->End()->total_time();
             paintTimeCounter->GetMinAndMaxPaintTime(&min, &max);
 
             m_paintTimeGraph.value = latest.InMillisecondsF();
             m_paintTimeGraph.min = min.InMillisecondsF();
             m_paintTimeGraph.max = max.InMillisecondsF();
         }
 
         if (debugState.showMemoryStats()) {
-            MemoryHistory* memoryHistory = layerTreeImpl()->memory_history();
+            MemoryHistory* memoryHistory = layer_tree_impl()->memory_history();
             if (memoryHistory->End())
                 m_memoryEntry = **memoryHistory->End();
             else
                 m_memoryEntry = MemoryHistory::Entry();
         }
     }
 
     m_fpsGraph.updateUpperBound();
     m_paintTimeGraph.updateUpperBound();
 }
 
 void HeadsUpDisplayLayerImpl::drawHudContents(SkCanvas* canvas) const
 {
-    const LayerTreeDebugState& debugState = layerTreeImpl()->debug_state();
+    const LayerTreeDebugState& debugState = layer_tree_impl()->debug_state();
 
     if (debugState.showHudRects())
-        drawDebugRects(canvas, layerTreeImpl()->debug_rect_history());
+        drawDebugRects(canvas, layer_tree_impl()->debug_rect_history());
 
     if (debugState.showPlatformLayerTree)
         drawPlatformLayerTree(canvas);
 
     SkRect area = SkRect::MakeEmpty();
     if (debugState.continuousPainting)
-        area = drawPaintTimeDisplay(canvas, layerTreeImpl()->paint_time_counter(), 0, 0);
+        area = drawPaintTimeDisplay(canvas, layer_tree_impl()->paint_time_counter(), 0, 0);
     // Don't show the FPS display when continuous painting is enabled, because it would show misleading numbers.
     else if (debugState.showFPSCounter)
-        area = drawFPSDisplay(canvas, layerTreeImpl()->frame_rate_counter(), 0, 0);
+        area = drawFPSDisplay(canvas, layer_tree_impl()->frame_rate_counter(), 0, 0);
 
     if (debugState.showMemoryStats())
         drawMemoryDisplay(canvas, 0, area.bottom(), SkMaxScalar(area.width(), 150));
 }
 
 void HeadsUpDisplayLayerImpl::drawText(SkCanvas* canvas, SkPaint* paint, const std::string& text, SkPaint::Align align, int size, int x, int y) const
 {
     const bool antiAlias = paint->isAntiAlias();
     paint->setAntiAlias(true);
 
@@ skipping 30 matching lines @@
     canvas->drawLine(bounds.left(), bounds.top() + indicatorTop, bounds.right(), bounds.top() + indicatorTop, *paint);
     paint->setXfermode(NULL);
 }
 
 void HeadsUpDisplayLayerImpl::drawPlatformLayerTree(SkCanvas* canvas) const
 {
     const int fontHeight = 14;
     SkPaint paint = createPaint();
     drawGraphBackground(canvas, &paint, SkRect::MakeXYWH(0, 0, bounds().width(), bounds().height()));
 
-    std::string layerTree = layerTreeImpl()->layer_tree_as_text();
+    std::string layerTree = layer_tree_impl()->layer_tree_as_text();
     std::vector<std::string> lines;
     base::SplitString(layerTree, '\n', &lines);
 
     paint.setColor(DebugColors::PlatformLayerTreeTextColor());
     for (size_t i = 0; i < lines.size() && static_cast<int>(2 + i * fontHeight) < bounds().height(); ++i) {
         drawText(canvas, &paint, lines[i], SkPaint::kLeft_Align, fontHeight, 2, 2 + (i + 1) * fontHeight);
     }
 }
 
 SkRect HeadsUpDisplayLayerImpl::drawFPSDisplay(SkCanvas* canvas, const FrameRateCounter* fpsCounter, int right, int top) const
@@ skipping 176 matching lines @@
     }
 
     drawGraphLines(canvas, &paint, graphBounds, m_paintTimeGraph);
 
     return area;
 }
 
 void HeadsUpDisplayLayerImpl::drawDebugRects(SkCanvas* canvas, DebugRectHistory* debugRectHistory) const
 {
     const std::vector<DebugRect>& debugRects = debugRectHistory->debugRects();
-    float rectScale = 1 / layerTreeImpl()->device_scale_factor();
+    float rectScale = 1 / layer_tree_impl()->device_scale_factor();
     SkPaint paint = createPaint();
 
     canvas->save();
     canvas->scale(rectScale, rectScale);
 
     for (size_t i = 0; i < debugRects.size(); ++i) {
         SkColor strokeColor = 0;
         SkColor fillColor = 0;
         float strokeWidth = 0;
 
         switch (debugRects[i].type) {
         case PaintRectType:
             strokeColor = DebugColors::PaintRectBorderColor();
             fillColor = DebugColors::PaintRectFillColor();
-            strokeWidth = DebugColors::PaintRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::PaintRectBorderWidth(layer_tree_impl());
             break;
         case PropertyChangedRectType:
             strokeColor = DebugColors::PropertyChangedRectBorderColor();
             fillColor = DebugColors::PropertyChangedRectFillColor();
-            strokeWidth = DebugColors::PropertyChangedRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::PropertyChangedRectBorderWidth(layer_tree_impl());
             break;
         case SurfaceDamageRectType:
             strokeColor = DebugColors::SurfaceDamageRectBorderColor();
             fillColor = DebugColors::SurfaceDamageRectFillColor();
-            strokeWidth = DebugColors::SurfaceDamageRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::SurfaceDamageRectBorderWidth(layer_tree_impl());
             break;
         case ReplicaScreenSpaceRectType:
             strokeColor = DebugColors::ScreenSpaceSurfaceReplicaRectBorderColor();
             fillColor = DebugColors::ScreenSpaceSurfaceReplicaRectFillColor();
-            strokeWidth = DebugColors::ScreenSpaceSurfaceReplicaRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::ScreenSpaceSurfaceReplicaRectBorderWidth(layer_tree_impl());
             break;
         case ScreenSpaceRectType:
             strokeColor = DebugColors::ScreenSpaceLayerRectBorderColor();
             fillColor = DebugColors::ScreenSpaceLayerRectFillColor();
-            strokeWidth = DebugColors::ScreenSpaceLayerRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::ScreenSpaceLayerRectBorderWidth(layer_tree_impl());
             break;
         case OccludingRectType:
             strokeColor = DebugColors::OccludingRectBorderColor();
             fillColor = DebugColors::OccludingRectFillColor();
-            strokeWidth = DebugColors::OccludingRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::OccludingRectBorderWidth(layer_tree_impl());
             break;
         case NonOccludingRectType:
             strokeColor = DebugColors::NonOccludingRectBorderColor();
             fillColor = DebugColors::NonOccludingRectFillColor();
-            strokeWidth = DebugColors::NonOccludingRectBorderWidth(layerTreeImpl());
+            strokeWidth = DebugColors::NonOccludingRectBorderWidth(layer_tree_impl());
             break;
         }
 
         const gfx::RectF& rect = debugRects[i].rect;
         SkRect skRect = SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height());
         paint.setColor(fillColor);
         paint.setStyle(SkPaint::kFill_Style);
         canvas->drawRect(skRect, paint);
 
         paint.setColor(strokeColor);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(SkFloatToScalar(strokeWidth));
         canvas->drawRect(skRect, paint);
     }
 
     canvas->restore();
 }
 
-const char* HeadsUpDisplayLayerImpl::layerTypeAsString() const
+const char* HeadsUpDisplayLayerImpl::LayerTypeAsString() const
 {
     return "HeadsUpDisplayLayer";
 }
 
 }  // namespace cc