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   return rendering_stats_;
  24 }
  25
  26 base::TimeTicks RenderingStatsInstrumentation::StartRecording() const {
  27   if (record_rendering_stats_)
  28     return base::TimeTicks::HighResNow();
  29   return base::TimeTicks();
  30 }
  31
  32 base::TimeDelta RenderingStatsInstrumentation::EndRecording(
  33     base::TimeTicks start_time) const {
  34   if (!start_time.is_null())
  35     return base::TimeTicks::HighResNow() - start_time;
  36   return base::TimeDelta();
  37 }
  38
  39 void RenderingStatsInstrumentation::AddStats(const RenderingStats& other) {
  40   if (!record_rendering_stats_)
  41     return;
  42
  43   base::AutoLock scoped_lock(lock_);
  44   rendering_stats_.Add(other);
  45 }
  46
  47 void RenderingStatsInstrumentation::IncrementAnimationFrameCount() {
  48   if (!record_rendering_stats_)
  49     return;
  50
  51   base::AutoLock scoped_lock(lock_);
  52   rendering_stats_.animation_frame_count++;
  53 }
  54
  55 void RenderingStatsInstrumentation::SetScreenFrameCount(int64 count) {
  56   if (!record_rendering_stats_)
  57     return;
  58
  59   base::AutoLock scoped_lock(lock_);
  60   rendering_stats_.screen_frame_count = count;
  61 }
  62
  63 void RenderingStatsInstrumentation::SetDroppedFrameCount(int64 count) {
  64   if (!record_rendering_stats_)
  65     return;
  66
  67   base::AutoLock scoped_lock(lock_);
  68   rendering_stats_.dropped_frame_count = count;
  69 }
  70
  71 void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
  72   if (!record_rendering_stats_)
  73     return;
  74
  75   base::AutoLock scoped_lock(lock_);
  76   rendering_stats_.total_commit_time += duration;
  77   rendering_stats_.total_commit_count++;
  78 }
  79
  80 void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
  81                                              int64 pixels) {
  82   if (!record_rendering_stats_)
  83     return;
  84
  85   base::AutoLock scoped_lock(lock_);
  86   rendering_stats_.total_paint_time += duration;
  87   rendering_stats_.total_pixels_painted += pixels;
  88 }
  89
  90 void RenderingStatsInstrumentation::AddRaster(base::TimeDelta duration,
  91                                               int64 pixels,
  92                                               bool is_in_pending_tree_now_bin) {
  93   if (!record_rendering_stats_)
  94     return;
  95
  96   base::AutoLock scoped_lock(lock_);
  97   rendering_stats_.total_rasterize_time += duration;
  98   rendering_stats_.total_pixels_rasterized += pixels;
  99
 100   if (is_in_pending_tree_now_bin) {
 101     rendering_stats_.total_rasterize_time_for_now_bins_on_pending_tree +=
 102         duration;
 103   }
 104 }
 105
 106 void RenderingStatsInstrumentation::IncrementImplThreadScrolls() {
 107   if (!record_rendering_stats_)
 108     return;
 109
 110   base::AutoLock scoped_lock(lock_);
 111   rendering_stats_.num_impl_thread_scrolls++;
 112 }
 113
 114 void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
 115   if (!record_rendering_stats_)
 116     return;
 117
 118   base::AutoLock scoped_lock(lock_);
 119   rendering_stats_.num_main_thread_scrolls++;
 120 }
 121
 122 void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
 123   if (!record_rendering_stats_)
 124     return;
 125
 126   base::AutoLock scoped_lock(lock_);
 127   rendering_stats_.num_layers_drawn += amount;
 128 }
 129
 130 void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
 131   if (!record_rendering_stats_)
 132     return;
 133
 134   base::AutoLock scoped_lock(lock_);
 135   rendering_stats_.num_missing_tiles += amount;
 136 }
 137
 138 void RenderingStatsInstrumentation::AddDeferredImageDecode(
 139     base::TimeDelta duration) {
 140   if (!record_rendering_stats_)
 141     return;
 142
 143   base::AutoLock scoped_lock(lock_);
 144   rendering_stats_.total_deferred_image_decode_time += duration;
 145   rendering_stats_.total_deferred_image_decode_count++;
 146 }
 147
 148 void RenderingStatsInstrumentation::AddImageGathering(
 149     base::TimeDelta duration) {
 150   if (!record_rendering_stats_)
 151     return;
 152
 153   base::AutoLock scoped_lock(lock_);
 154   rendering_stats_.total_image_gathering_time += duration;
 155   rendering_stats_.total_image_gathering_count++;
 156 }
 157
 158 void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
 159   if (!record_rendering_stats_)
 160     return;
 161
 162   base::AutoLock scoped_lock(lock_);
 163   rendering_stats_.total_deferred_image_cache_hit_count++;
 164 }
 165
 166 }  // namespace cc