Record histogram of reason for quads not being put in an overlay.

cc/output/dc_layer_overlay.cc

 // Copyright 2017 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/output/dc_layer_overlay.h"
 
+#include "base/metrics/histogram_macros.h"
 #include "cc/base/math_util.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gl/gl_switches.h"
 
 namespace cc {
 
@@ skipping 61 matching lines @@
 
 DCLayerOverlayProcessor::DCLayerResult DCLayerOverlayProcessor::FromDrawQuad(
     ResourceProvider* resource_provider,
     const gfx::RectF& display_rect,
     QuadList::ConstIterator quad_list_begin,
     QuadList::ConstIterator quad,
     DCLayerOverlay* ca_layer_overlay) {
   if (quad->shared_quad_state->blend_mode != SkBlendMode::kSrcOver)
     return DC_LAYER_FAILED_QUAD_BLEND_MODE;
 
-  DCLayerResult result = DC_LAYER_FAILED_UNKNOWN;
+  DCLayerResult result;
   switch (quad->material) {
     case DrawQuad::YUV_VIDEO_CONTENT:
       result =
           FromYUVQuad(resource_provider, YUVVideoDrawQuad::MaterialCast(*quad),
                       ca_layer_overlay);
       break;
     default:
-      return DC_LAYER_FAILED_UNKNOWN;
+      return DC_LAYER_FAILED_UNSUPPORTED_QUAD;
   }
   if (result != DC_LAYER_SUCCESS)
     return result;
 
   scoped_refptr<DCLayerOverlaySharedState> overlay_shared_state(
       new DCLayerOverlaySharedState);
   overlay_shared_state->z_order = 1;
 
   overlay_shared_state->is_clipped = quad->shared_quad_state->is_clipped;
   overlay_shared_state->clip_rect =
@@ skipping 14 matching lines @@
                                       QuadList* quad_list,
                                       gfx::Rect* overlay_damage_rect,
                                       gfx::Rect* damage_rect,
                                       DCLayerOverlayList* ca_layer_overlays) {
   gfx::Rect this_frame_underlay_rect;
   bool display_rect_changed = (display_rect != previous_display_rect_);
   for (auto it = quad_list->begin(); it != quad_list->end(); ++it) {
     DCLayerOverlay ca_layer;
     DCLayerResult result = FromDrawQuad(resource_provider, display_rect,
                                         quad_list->begin(), it, &ca_layer);
-    if (result != DC_LAYER_SUCCESS)
+    if (result != DC_LAYER_SUCCESS) {
+      UMA_HISTOGRAM_ENUMERATION("GPU.DirectComposition.DCLayerResult", result,
+                                DC_LAYER_FAILED_MAX);
       continue;
+    }
 
     if (!it->shared_quad_state->quad_to_target_transform
              .Preserves2dAxisAlignment() &&
         !base::FeatureList::IsEnabled(
             features::kDirectCompositionComplexOverlays)) {
+      UMA_HISTOGRAM_ENUMERATION("GPU.DirectComposition.DCLayerResult",
+                                DC_LAYER_FAILED_COMPLEX_TRANSFORM,
+                                DC_LAYER_FAILED_MAX);

[Ilya Sherman, 2017/05/24 23:52:49]

nit: The UMA_HISTOGRAM macros expand to a fair bit of code, so to help the
compiler avoid duplicating it, I'd recommend extracting out a small wrapper
function that you'd call like so:

  RecordDCLayerResult(DC_LAYER_FAILED_COMPLEX_TRANSFORM);

       continue;
     }
 
     gfx::Rect quad_rectangle = gfx::ToEnclosingRect(ClippedQuadRectangle(*it));
     gfx::RectF occlusion_bounding_box =
         GetOcclusionBounds(gfx::RectF(quad_rectangle), quad_list->begin(), it);
     if (occlusion_bounding_box.IsEmpty()) {
       // The quad is on top, so promote it to an overlay and remove all damage
       // underneath it.
       if (it->shared_quad_state->quad_to_target_transform
               .Preserves2dAxisAlignment() &&
           !display_rect_changed && !it->ShouldDrawWithBlending()) {
         damage_rect->Subtract(quad_rectangle);
       }
       quad_list->EraseAndInvalidateAllPointers(it);
     } else if (!base::FeatureList::IsEnabled(
                    features::kDirectCompositionUnderlays)) {
+      UMA_HISTOGRAM_ENUMERATION("GPU.DirectComposition.DCLayerResult",
+                                DC_LAYER_FAILED_OCCLUDED, DC_LAYER_FAILED_MAX);
       continue;
     } else {
       // The quad is occluded, so replace it with a black solid color quad and
       // place the overlay itself under the quad.
       if (it->shared_quad_state->quad_to_target_transform
               .IsIdentityOrIntegerTranslation()) {
         this_frame_underlay_rect = quad_rectangle;
       }
       ca_layer.shared_state->z_order = -1;
       const SharedQuadState* shared_quad_state = it->shared_quad_state;
@@ skipping 33 matching lines @@
     ca_layer_overlays->push_back(ca_layer);
     // Only allow one overlay for now.
     break;
   }
   damage_rect->Intersect(gfx::ToEnclosingRect(display_rect));
   previous_frame_underlay_rect_ = this_frame_underlay_rect;
   previous_display_rect_ = display_rect;
 }
 
 }  // namespace cc