cc/debug/rendering_stats_instrumentation.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/debug/rendering_stats_instrumentation.h"
   6
   7 namespace cc {
   8
   9 // static
  10 scoped_ptr<RenderingStatsInstrumentation>
  11     RenderingStatsInstrumentation::Create() {
  12   return make_scoped_ptr(new RenderingStatsInstrumentation());
  13 }
  14
  15 RenderingStatsInstrumentation::RenderingStatsInstrumentation()
  16     : record_rendering_stats_(false) {
  17 }
  18
  19 RenderingStatsInstrumentation::~RenderingStatsInstrumentation() {}
  20
  21 RenderingStats RenderingStatsInstrumentation::GetRenderingStats() {
  22   base::AutoLock scoped_lock(lock_);
  23   RenderingStats rendering_stats;
  24   rendering_stats.main_stats = main_stats_accu_;
  25   rendering_stats.main_stats.Add(main_stats_);
  26   rendering_stats.impl_stats = impl_stats_accu_;
  27   rendering_stats.impl_stats.Add(impl_stats_);
  28   return rendering_stats;
  29 }
  30
  31 void RenderingStatsInstrumentation::AccumulateAndClearMainThreadStats() {
  32   main_stats_accu_.Add(main_stats_);
  33   main_stats_ = MainThreadRenderingStats();
  34 }
  35
  36 void RenderingStatsInstrumentation::AccumulateAndClearImplThreadStats() {
  37   impl_stats_accu_.Add(impl_stats_);
  38   impl_stats_ = ImplThreadRenderingStats();
  39 }
  40
  41 base::TimeTicks RenderingStatsInstrumentation::StartRecording() const {
  42   if (record_rendering_stats_)
  43     return base::TimeTicks::HighResNow();
  44   return base::TimeTicks();
  45 }
  46
  47 base::TimeDelta RenderingStatsInstrumentation::EndRecording(
  48     base::TimeTicks start_time) const {
  49   if (!start_time.is_null())
  50     return base::TimeTicks::HighResNow() - start_time;
  51   return base::TimeDelta();
  52 }
  53
  54 void RenderingStatsInstrumentation::IncrementAnimationFrameCount() {
  55   if (!record_rendering_stats_)
  56     return;
  57
  58   base::AutoLock scoped_lock(lock_);
  59   main_stats_.animation_frame_count++;
  60 }
  61
  62 void RenderingStatsInstrumentation::IncrementScreenFrameCount(int64 count) {
  63   if (!record_rendering_stats_)
  64     return;
  65
  66   base::AutoLock scoped_lock(lock_);
  67   impl_stats_.screen_frame_count += count;
  68 }
  69
  70 void RenderingStatsInstrumentation::IncrementDroppedFrameCount(int64 count) {
  71   if (!record_rendering_stats_)
  72     return;
  73
  74   base::AutoLock scoped_lock(lock_);
  75   impl_stats_.dropped_frame_count += count;
  76 }
  77
  78 void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
  79   if (!record_rendering_stats_)
  80     return;
  81
  82   base::AutoLock scoped_lock(lock_);
  83   main_stats_.commit_time += duration;
  84   main_stats_.commit_count++;
  85 }
  86
  87 void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
  88                                              int64 pixels) {
  89   if (!record_rendering_stats_)
  90     return;
  91
  92   base::AutoLock scoped_lock(lock_);
  93   main_stats_.paint_time += duration;
  94   main_stats_.painted_pixel_count += pixels;
  95 }
  96
  97 void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
  98                                               int64 pixels) {
  99   if (!record_rendering_stats_)
 100     return;
 101
 102   base::AutoLock scoped_lock(lock_);
 103   main_stats_.record_time += duration;
 104   main_stats_.recorded_pixel_count += pixels;
 105 }
 106
 107 void RenderingStatsInstrumentation::AddRaster(base::TimeDelta total_duration,
 108                                               base::TimeDelta best_duration,
 109                                               int64 pixels,
 110                                               bool is_in_pending_tree_now_bin) {
 111   if (!record_rendering_stats_)
 112     return;
 113
 114   base::AutoLock scoped_lock(lock_);
 115   impl_stats_.rasterize_time += total_duration;
 116   impl_stats_.best_rasterize_time += best_duration;
 117   impl_stats_.rasterized_pixel_count += pixels;
 118
 119   if (is_in_pending_tree_now_bin) {
 120     impl_stats_.rasterize_time_for_now_bins_on_pending_tree +=
 121         total_duration;
 122   }
 123 }
 124
 125 void RenderingStatsInstrumentation::IncrementImplThreadScrolls() {
 126   if (!record_rendering_stats_)
 127     return;
 128
 129   base::AutoLock scoped_lock(lock_);
 130   impl_stats_.impl_thread_scroll_count++;
 131 }
 132
 133 void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
 134   if (!record_rendering_stats_)
 135     return;
 136
 137   base::AutoLock scoped_lock(lock_);
 138   impl_stats_.main_thread_scroll_count++;
 139 }
 140
 141 void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
 142   if (!record_rendering_stats_)
 143     return;
 144
 145   base::AutoLock scoped_lock(lock_);
 146   impl_stats_.drawn_layer_count += amount;
 147 }
 148
 149 void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
 150   if (!record_rendering_stats_)
 151     return;
 152
 153   base::AutoLock scoped_lock(lock_);
 154   impl_stats_.missing_tile_count += amount;
 155 }
 156
 157 void RenderingStatsInstrumentation::AddDeferredImageDecode(
 158     base::TimeDelta duration) {
 159   if (!record_rendering_stats_)
 160     return;
 161
 162   base::AutoLock scoped_lock(lock_);
 163   impl_stats_.deferred_image_decode_time += duration;
 164   impl_stats_.deferred_image_decode_count++;
 165 }
 166
 167 void RenderingStatsInstrumentation::AddImageGathering(
 168     base::TimeDelta duration) {
 169   if (!record_rendering_stats_)
 170     return;
 171
 172   base::AutoLock scoped_lock(lock_);
 173   main_stats_.image_gathering_time += duration;
 174   main_stats_.image_gathering_count++;
 175 }
 176
 177 void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
 178   if (!record_rendering_stats_)
 179     return;
 180
 181   base::AutoLock scoped_lock(lock_);
 182   impl_stats_.deferred_image_cache_hit_count++;
 183 }
 184
 185 void RenderingStatsInstrumentation::AddAnalysisResult(
 186     base::TimeDelta duration,
 187     bool is_solid_color) {
 188   if (!record_rendering_stats_)
 189     return;
 190
 191   base::AutoLock scoped_lock(lock_);
 192   impl_stats_.tile_analysis_count++;
 193   impl_stats_.tile_analysis_time += duration;
 194   if (is_solid_color)
 195     impl_stats_.solid_color_tile_analysis_count++;
 196 }
 197
 198 }  // namespace cc