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
7namespace cc {
8
9// static
10scoped_ptr<RenderingStatsInstrumentation>
11    RenderingStatsInstrumentation::Create() {
12  return make_scoped_ptr(new RenderingStatsInstrumentation());
13}
14
15RenderingStatsInstrumentation::RenderingStatsInstrumentation()
16    : record_rendering_stats_(false) {
17}
18
19RenderingStatsInstrumentation::~RenderingStatsInstrumentation() {}
20
21RenderingStats::MainThreadRenderingStats
22RenderingStatsInstrumentation::main_thread_rendering_stats() {
23  base::AutoLock scoped_lock(lock_);
24  return main_thread_rendering_stats_;
25}
26
27RenderingStats::ImplThreadRenderingStats
28RenderingStatsInstrumentation::impl_thread_rendering_stats() {
29  base::AutoLock scoped_lock(lock_);
30  return impl_thread_rendering_stats_;
31}
32
33RenderingStats 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
43void 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
49void 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
55base::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
64base::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
74void 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
86void 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
96void 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
106void 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
116void 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
125void 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
133void 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
142void 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
154void 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
167void 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
181