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::MainThreadRenderingStats
  22 RenderingStatsInstrumentation::main_thread_rendering_stats() {
  23   base::AutoLock scoped_lock(lock_);
  24   return main_thread_rendering_stats_;
  25 }
  26
  27 RenderingStats::ImplThreadRenderingStats
  28 RenderingStatsInstrumentation::impl_thread_rendering_stats() {
  29   base::AutoLock scoped_lock(lock_);
  30   return impl_thread_rendering_stats_;
  31 }
  32
  33 RenderingStats RenderingStatsInstrumentation::GetRenderingStats() {
  34   base::AutoLock scoped_lock(lock_);
  35   RenderingStats rendering_stats;
  36   rendering_stats.main_stats = main_thread_rendering_stats_accu_;
  37   rendering_stats.main_stats.Add(main_thread_rendering_stats_);
  38   rendering_stats.impl_stats = impl_thread_rendering_stats_accu_;
  39   rendering_stats.impl_stats.Add(impl_thread_rendering_stats_);
  40   return rendering_stats;
  41 }
  42
  43 void RenderingStatsInstrumentation::AccumulateAndClearMainThreadStats() {
  44   base::AutoLock scoped_lock(lock_);
  45   main_thread_rendering_stats_accu_.Add(main_thread_rendering_stats_);
  46   main_thread_rendering_stats_ = RenderingStats::MainThreadRenderingStats();
  47 }
  48
  49 void RenderingStatsInstrumentation::AccumulateAndClearImplThreadStats() {
  50   base::AutoLock scoped_lock(lock_);
  51   impl_thread_rendering_stats_accu_.Add(impl_thread_rendering_stats_);
  52   impl_thread_rendering_stats_ = RenderingStats::ImplThreadRenderingStats();
  53 }
  54
  55 base::TimeTicks RenderingStatsInstrumentation::StartRecording() const {
  56   if (record_rendering_stats_) {
  57     if (base::TimeTicks::IsThreadNowSupported())
  58       return base::TimeTicks::ThreadNow();
  59     return base::TimeTicks::HighResNow();
  60   }
  61   return base::TimeTicks();
  62 }
  63
  64 base::TimeDelta RenderingStatsInstrumentation::EndRecording(
  65     base::TimeTicks start_time) const {
  66   if (!start_time.is_null()) {
  67     if (base::TimeTicks::IsThreadNowSupported())
  68       return base::TimeTicks::ThreadNow() - start_time;
  69     return base::TimeTicks::HighResNow() - start_time;
  70   }
  71   return base::TimeDelta();
  72 }
  73
  74 void RenderingStatsInstrumentation::IncrementFrameCount(int64 count,
  75                                                         bool main_thread) {
  76   if (!record_rendering_stats_)
  77     return;
  78
  79   base::AutoLock scoped_lock(lock_);
  80   if (main_thread)
  81     main_thread_rendering_stats_.frame_count += count;
  82   else
  83     impl_thread_rendering_stats_.frame_count += count;
  84 }
  85
  86 void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
  87                                              int64 pixels) {
  88   if (!record_rendering_stats_)
  89     return;
  90
  91   base::AutoLock scoped_lock(lock_);
  92   main_thread_rendering_stats_.paint_time += duration;
  93   main_thread_rendering_stats_.painted_pixel_count += pixels;
  94 }
  95
  96 void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
  97                                               int64 pixels) {
  98   if (!record_rendering_stats_)
  99     return;
 100
 101   base::AutoLock scoped_lock(lock_);
 102   main_thread_rendering_stats_.record_time += duration;
 103   main_thread_rendering_stats_.recorded_pixel_count += pixels;
 104 }
 105
 106 void RenderingStatsInstrumentation::AddRaster(base::TimeDelta duration,
 107                                               int64 pixels) {
 108   if (!record_rendering_stats_)
 109     return;
 110
 111   base::AutoLock scoped_lock(lock_);
 112   impl_thread_rendering_stats_.rasterize_time += duration;
 113   impl_thread_rendering_stats_.rasterized_pixel_count += pixels;
 114 }
 115
 116 void RenderingStatsInstrumentation::AddAnalysis(base::TimeDelta duration,
 117                                                 int64 pixels) {
 118   if (!record_rendering_stats_)
 119     return;
 120
 121   base::AutoLock scoped_lock(lock_);
 122   impl_thread_rendering_stats_.analysis_time += duration;
 123 }
 124
 125 void RenderingStatsInstrumentation::AddVisibleContentArea(int64 area) {
 126   if (!record_rendering_stats_)
 127     return;
 128
 129   base::AutoLock scoped_lock(lock_);
 130   impl_thread_rendering_stats_.visible_content_area += area;
 131 }
 132
 133 void RenderingStatsInstrumentation::AddApproximatedVisibleContentArea(
 134     int64 area) {
 135   if (!record_rendering_stats_)
 136     return;
 137
 138   base::AutoLock scoped_lock(lock_);
 139   impl_thread_rendering_stats_.approximated_visible_content_area += area;
 140 }
 141
 142 void RenderingStatsInstrumentation::AddDrawDuration(
 143     base::TimeDelta draw_duration,
 144     base::TimeDelta draw_duration_estimate) {
 145   if (!record_rendering_stats_)
 146     return;
 147
 148   base::AutoLock scoped_lock(lock_);
 149   impl_thread_rendering_stats_.draw_duration.Append(draw_duration);
 150   impl_thread_rendering_stats_.draw_duration_estimate.Append(
 151       draw_duration_estimate);
 152 }
 153
 154 void RenderingStatsInstrumentation::AddBeginMainFrameToCommitDuration(
 155     base::TimeDelta begin_main_frame_to_commit_duration,
 156     base::TimeDelta begin_main_frame_to_commit_duration_estimate) {
 157   if (!record_rendering_stats_)
 158     return;
 159
 160   base::AutoLock scoped_lock(lock_);
 161   impl_thread_rendering_stats_.begin_main_frame_to_commit_duration.Append(
 162       begin_main_frame_to_commit_duration);
 163   impl_thread_rendering_stats_.begin_main_frame_to_commit_duration_estimate
 164       .Append(begin_main_frame_to_commit_duration_estimate);
 165 }
 166
 167 void RenderingStatsInstrumentation::AddCommitToActivateDuration(
 168     base::TimeDelta commit_to_activate_duration,
 169     base::TimeDelta commit_to_activate_duration_estimate) {
 170   if (!record_rendering_stats_)
 171     return;
 172
 173   base::AutoLock scoped_lock(lock_);
 174   impl_thread_rendering_stats_.commit_to_activate_duration.Append(
 175       commit_to_activate_duration);
 176   impl_thread_rendering_stats_.commit_to_activate_duration_estimate.Append(
 177       commit_to_activate_duration_estimate);
 178 }
 179
 180 }  // namespace cc