Chromium -> Mojo roll.

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/strings/stringprintf.h"
@@ skipping 205 matching lines @@
   DCHECK(info.colorType() == kN32_SkColorType);
   resource_provider->CopyToResource(resources_.back()->id(),
                                     static_cast<const uint8_t*>(pixels),
                                     internal_content_bounds_);
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseResources() {
   resources_.clear();
 }
 
+gfx::Rect HeadsUpDisplayLayerImpl::GetEnclosingRectInTargetSpace() const {
+  return GetScaledEnclosingRectInTargetSpace(internal_contents_scale_);
+}
+
 void HeadsUpDisplayLayerImpl::UpdateHudContents() {
   const LayerTreeDebugState& debug_state = layer_tree_impl()->debug_state();
 
   // Don't update numbers every frame so text is readable.
   base::TimeTicks now = layer_tree_impl()->CurrentBeginFrameArgs().frame_time;
   if (base::TimeDelta(now - time_of_last_graph_update_).InSecondsF() > 0.25f) {
     time_of_last_graph_update_ = now;
 
     if (debug_state.show_fps_counter) {
       FrameRateCounter* fps_counter = layer_tree_impl()->frame_rate_counter();
@@ skipping 308 matching lines @@
 }
 
 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";
+      status = "on";
       color = SK_ColorGREEN;
       break;
     case GpuRasterizationStatus::ON_FORCED:
-      status = "GPU raster: on (forced)";
+      status = "on (forced)";
       color = SK_ColorGREEN;
       break;
     case GpuRasterizationStatus::OFF_DEVICE:
-      status = "GPU raster: off (device)";
+      status = "off (device)";
       color = SK_ColorRED;
       break;
     case GpuRasterizationStatus::OFF_VIEWPORT:
-      status = "GPU raster: off (viewport)";
+      status = "off (viewport)";
       color = SK_ColorYELLOW;
       break;
     case GpuRasterizationStatus::OFF_CONTENT:
-      status = "GPU raster: off (content)";
+      status = "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 height = 2 * kFontHeight + 3 * 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);
+  SkPoint gpu_status_pos = SkPoint::Make(left + width - kPadding,
+                                         top + 2 * kFontHeight + 2 * kPadding);
 
   paint.setColor(color);
-  DrawText(canvas, &paint, status, SkPaint::kLeft_Align, kFontHeight,
+  DrawText(canvas, &paint, "GPU raster: ", SkPaint::kLeft_Align, kFontHeight,
+           left + kPadding, top + kFontHeight + kPadding);
+  DrawText(canvas, &paint, status, SkPaint::kRight_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 kFontHeight = 14;
 
   const int kGraphWidth = paint_time_counter->HistorySize();
   const int kGraphHeight = 40;
 
   const int width = kGraphWidth + 2 * kPadding;
   const int height =
       kFontHeight + kGraphHeight + 4 * kPadding + 2 + kFontHeight + kPadding;
   const int left = bounds().width() - width - right;
 
   const SkRect area = SkRect::MakeXYWH(left, top, width, height);
@@ skipping 11 matching lines @@
                                          text_bounds2.bottom() + 2 * kPadding,
                                          kGraphWidth,
                                          kGraphHeight);
 
   const std::string value_text =
       base::StringPrintf("%.1f", paint_time_graph_.value);
   const std::string min_max_text = base::StringPrintf(
       "%.1f-%.1f", paint_time_graph_.min, paint_time_graph_.max);
 
   paint.setColor(DebugColors::PaintTimeDisplayTextAndGraphColor());
-  DrawText(canvas, &paint, "Compositor frame time (ms)", SkPaint::kLeft_Align,
+  DrawText(canvas, &paint, "Compositor frame time(ms)", SkPaint::kLeft_Align,
            kFontHeight, text_bounds.left(), text_bounds.bottom());
   DrawText(canvas,
            &paint,
            value_text,
            SkPaint::kLeft_Align,
            kFontHeight,
            text_bounds2.left(),
            text_bounds2.bottom());
   DrawText(canvas,
            &paint,
@@ skipping 189 matching lines @@
   return "cc::HeadsUpDisplayLayerImpl";
 }
 
 void HeadsUpDisplayLayerImpl::AsValueInto(
     base::trace_event::TracedValue* dict) const {
   LayerImpl::AsValueInto(dict);
   dict->SetString("layer_name", "Heads Up Display Layer");
 }
 
 }  // namespace cc