Update from https://crrev.com/306724

cc/layers/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/layers/heads_up_display_layer_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/strings/stringprintf.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/paint_time_counter.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/renderer.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/memory_history.h"
+#include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.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/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 239 matching lines @@
   if (debug_state.continuous_painting) {
     area = DrawPaintTimeDisplay(
         canvas, layer_tree_impl()->paint_time_counter(), 0, 0);
   } else if (debug_state.show_fps_counter) {
     // Don't show the FPS display when continuous painting is enabled, because
     // it would show misleading numbers.
     area =
         DrawFPSDisplay(canvas, layer_tree_impl()->frame_rate_counter(), 0, 0);
   }
 
+  area = DrawGpuRasterizationStatus(canvas, 0, area.bottom(),
+                                    SkMaxScalar(area.width(), 150));
+
   if (debug_state.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,
@@ skipping 233 matching lines @@
 
   if (!memory_entry_.had_enough_memory)
     paint.setColor(SK_ColorRED);
   text = base::StringPrintf("%6.1f MB max ",
                             memory_entry_.total_budget_in_bytes / kMegabyte);
   DrawText(canvas, &paint, text, SkPaint::kRight_Align, kFontHeight, stat2_pos);
 
   return area;
 }
 
+SkRect HeadsUpDisplayLayerImpl::DrawGpuRasterizationStatus(SkCanvas* canvas,
+                                                           int right,
+                                                           int top,
+                                                           int width) const {
+  std::string status;
+  SkColor color = SK_ColorRED;
+  switch (layer_tree_impl()->GetGpuRasterizationStatus()) {
+    case GpuRasterizationStatus::ON:
+      status = "GPU raster: on";
+      color = SK_ColorGREEN;
+      break;
+    case GpuRasterizationStatus::ON_FORCED:
+      status = "GPU raster: on (forced)";
+      color = SK_ColorGREEN;
+      break;
+    case GpuRasterizationStatus::OFF_DEVICE:
+      status = "GPU raster: off (device)";
+      color = SK_ColorRED;
+      break;
+    case GpuRasterizationStatus::OFF_VIEWPORT:
+      status = "GPU raster: off (viewport)";
+      color = SK_ColorYELLOW;
+      break;
+    case GpuRasterizationStatus::OFF_CONTENT:
+      status = "GPU raster: off (content)";
+      color = SK_ColorYELLOW;
+      break;
+  }
+
+  if (status.empty())
+    return SkRect::MakeEmpty();
+
+  const int kPadding = 4;
+  const int kFontHeight = 13;
+
+  const int height = kFontHeight + 2 * kPadding;
+  const int left = bounds().width() - width - right;
+  const SkRect area = SkRect::MakeXYWH(left, top, width, height);
+
+  SkPaint paint = CreatePaint();
+  DrawGraphBackground(canvas, &paint, area);
+
+  SkPoint gpu_status_pos = SkPoint::Make(left + kPadding, top + kFontHeight);
+
+  paint.setColor(color);
+  DrawText(canvas, &paint, status, SkPaint::kLeft_Align, kFontHeight,
+           gpu_status_pos);
+
+  return area;
+}
+
 SkRect HeadsUpDisplayLayerImpl::DrawPaintTimeDisplay(
     SkCanvas* canvas,
     const PaintTimeCounter* paint_time_counter,
     int right,
     int top) const {
   const int kPadding = 4;
   const int kFontHeight = 15;
 
   const int kGraphWidth = paint_time_counter->HistorySize();
   const int kGraphHeight = 40;
@@ skipping 237 matching lines @@
   return "cc::HeadsUpDisplayLayerImpl";
 }
 
 void HeadsUpDisplayLayerImpl::AsValueInto(
     base::debug::TracedValue* dict) const {
   LayerImpl::AsValueInto(dict);
   dict->SetString("layer_name", "Heads Up Display Layer");
 }
 
 }  // namespace cc