[cc] Show GPU memory usage and overage below FPS counter

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 "cc/debug_colors.h"
 #include "cc/debug_rect_history.h"
 #include "cc/font_atlas.h"
 #include "cc/frame_rate_counter.h"
 #include "cc/layer_tree_impl.h"
+#include "cc/memory_history.h"
 #include "cc/paint_time_counter.h"
 #include "cc/quad_sink.h"
 #include "cc/renderer.h"
 #include "cc/texture_draw_quad.h"
+#include "cc/tile_manager.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/size.h"
 
@@ skipping 157 matching lines @@
 bool HeadsUpDisplayLayerImpl::layerIsAlwaysDamaged() const
 {
     return true;
 }
 
 void HeadsUpDisplayLayerImpl::drawHudContents(SkCanvas* canvas)
 {
     const LayerTreeDebugState& debugState = layerTreeImpl()->debug_state();
 
     FrameRateCounter* fpsCounter = layerTreeImpl()->frame_rate_counter();
+    MemoryHistory* memoryHistory = layerTreeImpl()->memory_history();
     PaintTimeCounter* paintTimeCounter = layerTreeImpl()->paint_time_counter();
 
     if (debugState.showPlatformLayerTree) {
         SkPaint paint = createPaint();
         drawGraphBackground(canvas, &paint, SkRect::MakeXYWH(0, 0, bounds().width(), bounds().height()));
     }
 
     int top = 2;
 
     if (debugState.continuousPainting || debugState.showFPSCounter) {
@@ skipping 10 matching lines @@
             m_paintTimeGraph.value = latest.InMillisecondsF();
             m_paintTimeGraph.min = min.InMillisecondsF();
             m_paintTimeGraph.max = max.InMillisecondsF();
 
             m_timeOfLastGraphUpdate = now;
         }
 
         if (debugState.continuousPainting)
             top = drawPaintTimeDisplay(canvas, paintTimeCounter, top);
         // Don't show the FPS display when continuous painting is enabled, because it would show misleading numbers.
-        else if (debugState.showFPSCounter)
+        else if (debugState.showFPSCounter) {
             top = drawFPSDisplay(canvas, fpsCounter, top);
+        }
+        if (debugState.continuousPainting ||
+            debugState.showFPSCounter) {
+            top = drawMemoryDisplay(canvas, memoryHistory, top);
+        }
     }
 
     if (debugState.showPlatformLayerTree && m_fontAtlas) {
         std::string layerTree = layerTreeImpl()->layer_tree_as_text();
         SkPaint paint = createPaint();
         m_fontAtlas->setColor(DebugColors::PlatformLayerTreeTextColor());
         m_fontAtlas->drawText(canvas, &paint, layerTree, gfx::Point(2, top), bounds());
     }
 
     if (debugState.showHudRects())
@@ skipping 59 matching lines @@
 
     SkPaint paint = createPaint();
     drawGraphBackground(canvas, &paint, SkRect::MakeXYWH(left, top, width, height));
 
     SkRect textBounds = SkRect::MakeXYWH(left + padding, top + padding, graphWidth + histogramWidth + gap + 2, fontHeight);
     SkRect graphBounds = SkRect::MakeXYWH(left + padding, textBounds.bottom() + 2 * padding, graphWidth, graphHeight);
     SkRect histogramBounds = SkRect::MakeXYWH(graphBounds.right() + gap, graphBounds.top(), histogramWidth, graphHeight);
 
     if (m_fontAtlas.get())
         m_fontAtlas->setColor(DebugColors::FPSDisplayTextAndGraphColor());
+
     drawTextLeftAligned(canvas, &paint, textBounds, base::StringPrintf("FPS:%5.1f", m_fpsGraph.value));
     drawTextRightAligned(canvas, &paint, textBounds, base::StringPrintf("%.0f-%.0f", m_fpsGraph.min, m_fpsGraph.max));
 
     const double upperBound = Graph::updateUpperBound(&m_fpsGraph);
     drawGraphLines(canvas, &paint, graphBounds, m_fpsGraph);
 
     // Collect graph and histogram data.
     int x = 0;
     SkPath path;
 
@@ skipping 50 matching lines @@
     // Draw FPS graph.
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(1);
 
     canvas->drawPath(path, paint);
 
     return top + height + 2;
 }
 
+int HeadsUpDisplayLayerImpl::drawMemoryDisplay(SkCanvas* canvas, MemoryHistory* memoryHistory, const int& initial_top)
+{
+    // Move up by 2 to create no gap between us and previous counter.
+    int top = initial_top - 2;
+    const int padding = 4;
+    const int fontHeight = m_fontAtlas.get() ? m_fontAtlas->fontHeight() : 0;
+
+    const int width = 181;
+    const int height = 2 * fontHeight + 3 * padding;
+
+    const int left = bounds().width() - width - 2;
+    const double megabyte = static_cast<double>(1024*1024);
+
+    SkPaint paint = createPaint();
+    drawGraphBackground(canvas, &paint, SkRect::MakeXYWH(left, top, width, height));
+
+    SkRect textRun1 = SkRect::MakeXYWH(left + padding, top + padding, width, fontHeight);
+    SkRect textRun2 = SkRect::MakeXYWH(left + padding, top + 2*padding + fontHeight, width, fontHeight);
+
+    if (m_fontAtlas.get())
+        m_fontAtlas->setColor(DebugColors::FPSDisplayTextAndGraphColor());
+
+    std::string text;
+    MemoryHistory::Entry curEntry = memoryHistory->GetEntry(
+        memoryHistory->HistorySize() - 1);
+
+    double curMB = curEntry.bytes_total() / megabyte;
+
+    text = base::StringPrintf(
+        "%6.1f MB used",
+        (curEntry.bytes_unreleasable + curEntry.bytes_allocated) / megabyte);
+    drawTextLeftAligned(canvas, &paint, textRun1, text);
+
+    text = base::StringPrintf(
+        "%6.1f MB over budget",
+        (curEntry.bytes_over) / megabyte);
+    drawTextLeftAligned(canvas, &paint, textRun2, text);
+
+    return top + height + 2;
+}
+
 int HeadsUpDisplayLayerImpl::drawPaintTimeDisplay(SkCanvas* canvas, PaintTimeCounter* paintTimeCounter, const int& top)
 {
     const int padding = 4;
     const int fontHeight = m_fontAtlas.get() ? m_fontAtlas->fontHeight() : 0;
 
     const int graphWidth = paintTimeCounter->HistorySize() * 2 - 1;
     const int graphHeight = 40;
 
     const int width = graphWidth + 2 * padding;
     const int height = fontHeight + graphHeight + 4 * padding + 2 + fontHeight + padding;
@@ skipping 98 matching lines @@
 
     canvas->restore();
 }
 
 const char* HeadsUpDisplayLayerImpl::layerTypeAsString() const
 {
     return "HeadsUpDisplayLayer";
 }
 
 }  // namespace cc