Statistics of LayoutBox rare data reasons

cc/benchmarks/rasterize_and_record_benchmark.cc

 // Copyright 2013 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/benchmarks/rasterize_and_record_benchmark.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "cc/base/lap_timer.h"
 #include "cc/benchmarks/rasterize_and_record_benchmark_impl.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/recording_source.h"
 #include "cc/paint/display_item_list.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "skia/ext/analysis_canvas.h"
 #include "ui/gfx/geometry/rect.h"
 
+namespace blink {
+int* paintCounts();
+int* rareDataReasonCounts();
+int* frameCounts();
+}
+
 namespace cc {
 
 namespace {
 
 const int kDefaultRecordRepeatCount = 100;
 
 // Parameters for LapTimer.
 const int kTimeLimitMillis = 1;
 const int kWarmupRuns = 0;
 const int kTimeCheckInterval = 1;
@@ skipping 44 matching lines @@
     return;
 
   if (settings->HasKey("record_repeat_count"))
     settings->GetInteger("record_repeat_count", &record_repeat_count_);
 }
 
 RasterizeAndRecordBenchmark::~RasterizeAndRecordBenchmark() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
+static const int kMaxReason = 58;
+
+static const char* reasonNames[kMaxReason] = {
+    "lo_all",
+    "lo_inFlowSelfPaintingLayer",
+    "lo_inFlowSelfPaintingLayerDiffPC",
+    "lo_previousLocation",
+    "lo_floatLayerBug1",
+    "lo_floatLayerBug2",
+    "lo_svgForeignBug",
+    "li_all",
+    "li_createsLineBoxes",
+    "lt_all",
+    "lt_canUseParentVisualRect",
+    "lt_zeroOrOneLineBox",
+    "lt_zeroOrOneLineBoxCanUse",
+    "lb_all",
+    "lb_rareData",
+    "lb_inlineBoxWrapper",
+    "lb_spannerPlaceholder",
+    "lb_overrideSize",
+    "lb_pageOffset",
+    "lb_paginationStrut",
+    "lb_previousSize",
+    "lb_previousLayoutOverflow",
+    "lb_previousContentBox",
+    "lb_previousContentBoxSizeIfDiff",
+    "lb_positionedContainer",
+    "lb_positionedDiffPC",
+    "lb_percentHeightContainer",
+    "lb_contentBoxDiff",
+    "lb_layoutOverflowDiff",
+    "lbl_all",
+    "lbl_positionedDescendants",
+    "lbl_percentHeightDescendants",
+    "lbf_all",
+    "lbf_rareData",
+    "lbf_paginationStrutFromChild",
+    "lbf_lineBreakToAvoidWidow",
+    "lbf_discardMargin",
+    "lbf_margin",
+    "lbf_multiColumnFlowThread",
+    "lts_all",
+    "lts_composited",
+    "lts_nonComposited",
+    "lts_compositedWithContainerBackground",
+    "ltr_all",
+    "ltr_composited",
+    "ltr_nonComposited",
+    "ltr_compositedWithContainerBackground",
+    "ltc_all",
+    "ltc_invisibleCollapsedBorders",
+    "ltc_collapsedBorders",
+    "ltc_composited",
+    "ltc_nonComposited",
+    "ltc_compositedWithContainerBackground",
+    "lo_object",
+    "lo_box",
+    "lo_text",
+    "lo_inline",
+    "lo_svg",
+};
+
+static const char* paintNames[] = {
+    "p_empty_background", "p_empty_float", "p_empty_foreground",
+    "p_empty_outline",    "p_empty_all",   "p_all",
+    "p_no_background",    "p_no_float",    "p_no_outline",
+};
+
+static const char* frameNames[] = {
+    "frame_all",
+    "frame_remote",
+    "frame_noOwnerLayoutObject",
+    "frame_throttled",
+    "frame_throttledNoOwnerLayoutObject",
+    "frame_noLayoutView",
+    "frame_noView",
+};
+
 void RasterizeAndRecordBenchmark::DidUpdateLayers(
     LayerTreeHost* layer_tree_host) {
   layer_tree_host_ = layer_tree_host;
   LayerTreeHostCommon::CallFunctionForEveryLayer(
       layer_tree_host_,
       [this](Layer* layer) { layer->RunMicroBenchmark(this); });
 
   DCHECK(!results_.get());
   results_ = base::WrapUnique(new base::DictionaryValue);
   results_->SetInteger("pixels_recorded", record_results_.pixels_recorded);
   results_->SetInteger("picture_memory_usage",
                        static_cast<int>(record_results_.bytes_used));
+  int* reason_counts = blink::rareDataReasonCounts();
+  for (int i = 0; i < kMaxReason; ++i) {
+    results_->SetInteger(reasonNames[i], reason_counts[i]);
+    reason_counts[i] = 0;
+  }
+
+  int* paint_counts = blink::paintCounts();
+  for (int i = 0; i < 9; ++i) {
+    results_->SetInteger(paintNames[i], paint_counts[i]);
+    paint_counts[i] = 0;
+  }
+
+  int* frame_counts = blink::frameCounts();
+  for (int i = 0; i < 7; ++i) {
+    results_->SetInteger(frameNames[i], frame_counts[i]);
+  }
 
   for (int i = 0; i < RecordingSource::RECORDING_MODE_COUNT; i++) {
     std::string name = base::StringPrintf("record_time%s_ms", kModeSuffixes[i]);
     results_->SetDouble(name,
                         record_results_.total_best_time[i].InMillisecondsF());
   }
   main_thread_benchmark_done_ = true;
 }
 
 void RasterizeAndRecordBenchmark::RecordRasterResults(
@@ skipping 74 matching lines @@
     record_results_.total_best_time[mode_index] += min_time;
   }
 }
 
 RasterizeAndRecordBenchmark::RecordResults::RecordResults()
     : pixels_recorded(0), bytes_used(0) {}
 
 RasterizeAndRecordBenchmark::RecordResults::~RecordResults() {}
 
 }  // namespace cc