Add display list fallback reason histograms for 2D canvas

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 313 matching lines @@
 
 SkCanvas* Canvas2DLayerBridge::canvas()
 {
     if (!m_isDeferralEnabled) {
         SkSurface* s = getOrCreateSurface();
         return s ? s->getCanvas() : nullptr;
     }
     return m_recorder->getRecordingCanvas();
 }
 
-void Canvas2DLayerBridge::disableDeferral()
+void Canvas2DLayerBridge::disableDeferral(DisableDeferralReason reason)
 {
     // Disabling deferral is permanent: once triggered by disableDeferral()
     // we stay in immediate mode indefinitely. This is a performance heuristic
     // that significantly helps a number of use cases. The rationale is that if
     // immediate rendering was needed once, it is likely to be needed at least
     // once per frame, which eliminates the possibility for inter-frame
     // overdraw optimization. Furthermore, in cases where immediate mode is
     // required multiple times per frame, the repeated flushing of deferred
     // commands would cause significant overhead, so it is better to just stop
     // trying to defer altogether.
     if (!m_isDeferralEnabled)
         return;
 
+    Platform::current()->histogramEnumeration("Canvas.GPUAccelerated2DCanvasDisableDeferralReason", reason, DisableDeferralReasonCount);
     CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasDeferralDisabled);
     flushRecordingOnly();
     // Because we will be discarding the recorder, if the flush failed
     // content will be lost -> force m_haveRecordedDrawCommands to false
     m_haveRecordedDrawCommands = false;
 
     m_isDeferralEnabled = false;
     m_recorder.clear();
     // install the current matrix/clip stack onto the immediate canvas
     SkSurface* surface = getOrCreateSurface();
@@ skipping 234 matching lines @@
     if (bitmap) {
         // Using accelerated 2d canvas with software renderer, which
         // should only happen in tests that use fake graphics contexts
         // or in Android WebView in software mode. In this case, we do
         // not care about producing any results for this canvas.
         skipQueuedDrawCommands();
         m_lastImageId = 0;
         return false;
     }
 
-    RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration);
+    RefPtr<SkImage> image = newImageSnapshot(PreferAcceleration, SnapshotReasonUnknown);
     if (!image)
         return false;
 
     WebGraphicsContext3D* webContext = context();
 
     // Early exit if canvas was not drawn to since last prepareMailbox
     GLenum filter = m_filterQuality == kNone_SkFilterQuality ? GL_NEAREST : GL_LINEAR;
     if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
         return false;
     m_lastImageId = image->uniqueID();
@@ skipping 117 matching lines @@
     return m_layer->layer();
 }
 
 void Canvas2DLayerBridge::didDraw(const FloatRect& rect)
 {
     if (m_isDeferralEnabled) {
         m_haveRecordedDrawCommands = true;
         IntRect pixelBounds = enclosingIntRect(rect);
         m_recordingPixelCount += pixelBounds.width() * pixelBounds.height();
         if (m_recordingPixelCount >= (m_size.width() * m_size.height() * ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold)) {
-            disableDeferral();
+            disableDeferral(DisableDeferralReasonExpensiveOverdrawHeuristic);
         }
     }
     if (!m_isRegisteredTaskObserver) {
         Platform::current()->currentThread()->addTaskObserver(this);
         m_isRegisteredTaskObserver = true;
     }
 }
 
 void Canvas2DLayerBridge::prepareSurfaceForPaintingIfNeeded()
 {
@@ skipping 35 matching lines @@
 
     m_renderingTaskCompletedForCurrentFrame = true;
     unregisterTaskObserver();
 }
 
 void Canvas2DLayerBridge::willProcessTask()
 {
     ASSERT_NOT_REACHED();
 }
 
-PassRefPtr<SkImage> Canvas2DLayerBridge::newImageSnapshot(AccelerationHint hint)
+PassRefPtr<SkImage> Canvas2DLayerBridge::newImageSnapshot(AccelerationHint hint, SnapshotReason)
 {
     if (!checkSurfaceValid())
         return nullptr;
     if (!getOrCreateSurface(hint))
         return nullptr;
     flush();
     // A readback operation may alter the texture parameters, which may affect
     // the compositor's behavior. Therefore, we must trigger copy-on-write
     // even though we are not technically writing to the texture, only to its
     // parameters.
@@ skipping 12 matching lines @@
     m_image = other.m_image;
     m_parentLayerBridge = other.m_parentLayerBridge;
 }
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     blink::Platform::current()->histogramEnumeration("Canvas.HibernationEvents", event, HibernationEventCount);
 }
 
 } // namespace blink