src/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     if (base::TimeTicks::IsThreadNowSupported())
  44       return base::TimeTicks::ThreadNow();
  45     return base::TimeTicks::HighResNow();
  46   }
  47   return base::TimeTicks();
  48 }
  49
  50 base::TimeDelta RenderingStatsInstrumentation::EndRecording(
  51     base::TimeTicks start_time) const {
  52   if (!start_time.is_null()) {
  53     if (base::TimeTicks::IsThreadNowSupported())
  54       return base::TimeTicks::ThreadNow() - start_time;
  55     return base::TimeTicks::HighResNow() - start_time;
  56   }
  57   return base::TimeDelta();
  58 }
  59
  60 void RenderingStatsInstrumentation::IncrementFrameCount(int64 count,
  61                                                         bool main_thread) {
  62   if (!record_rendering_stats_)
  63     return;
  64
  65   base::AutoLock scoped_lock(lock_);
  66   if (main_thread)
  67     main_stats_.frame_count += count;
  68   else
  69     impl_stats_.frame_count += count;
  70 }
  71
  72 void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
  73                                              int64 pixels) {
  74   if (!record_rendering_stats_)
  75     return;
  76
  77   base::AutoLock scoped_lock(lock_);
  78   main_stats_.paint_time += duration;
  79   main_stats_.painted_pixel_count += pixels;
  80 }
  81
  82 void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
  83                                               int64 pixels) {
  84   if (!record_rendering_stats_)
  85     return;
  86
  87   base::AutoLock scoped_lock(lock_);
  88   main_stats_.record_time += duration;
  89   main_stats_.recorded_pixel_count += pixels;
  90 }
  91
  92 void RenderingStatsInstrumentation::AddRaster(base::TimeDelta duration,
  93                                               int64 pixels) {
  94   if (!record_rendering_stats_)
  95     return;
  96
  97   base::AutoLock scoped_lock(lock_);
  98   impl_stats_.rasterize_time += duration;
  99   impl_stats_.rasterized_pixel_count += pixels;
 100 }
 101
 102 void RenderingStatsInstrumentation::AddAnalysis(base::TimeDelta duration,
 103                                                 int64 pixels) {
 104   if (!record_rendering_stats_)
 105     return;
 106
 107   base::AutoLock scoped_lock(lock_);
 108   impl_stats_.analysis_time += duration;
 109 }
 110
 111 void RenderingStatsInstrumentation::AddVisibleContentArea(int64 area) {
 112   if (!record_rendering_stats_)
 113     return;
 114
 115   base::AutoLock scoped_lock(lock_);
 116   impl_stats_.visible_content_area += area;
 117 }
 118
 119 void RenderingStatsInstrumentation::AddApproximatedVisibleContentArea(
 120     int64 area) {
 121   if (!record_rendering_stats_)
 122     return;
 123
 124   base::AutoLock scoped_lock(lock_);
 125   impl_stats_.approximated_visible_content_area += area;
 126 }
 127
 128 }  // namespace cc