Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(203)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/browser/media/webrtc_browsertest_perf.cc

Issue 2307083002: Cleanup: move WebRTC related files from chrome/browser/media to chrome/browser/media/webrtc/ (Closed)
Patch Set: rebase Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « chrome/browser/media/webrtc_browsertest_perf.h ('k') | chrome/browser/media/webrtc_disable_encryption_flag_browsertest.cc » ('j') | chrome/chrome_tests_unit.gypi » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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 "chrome/browser/media/webrtc_browsertest_perf.h"
6
7 #include <stddef.h>
8
9 #include "base/strings/stringprintf.h"
10 #include "base/values.h"
11 #include "chrome/test/base/in_process_browser_test.h"
12 #include "testing/perf/perf_test.h"
13
14 static std::string Statistic(const std::string& statistic,
15 const std::string& bucket) {
16 // A ssrc stats key will be on the form stats.<bucket>-<key>.values.
17 // This will give a json "path" which will dig into the time series for the
18 // specified statistic. Buckets can be for instance ssrc_1212344, bweforvideo,
19 // and will each contain a bunch of statistics relevant to their nature.
20 // Each peer connection has a number of such buckets.
21 return base::StringPrintf("stats.%s-%s.values", bucket.c_str(),
22 statistic.c_str());
23 }
24
25 static void MaybePrintResultsForAudioReceive(
26 const std::string& ssrc, const base::DictionaryValue& pc_dict,
27 const std::string& modifier) {
28 std::string value;
29 if (!pc_dict.GetString(Statistic("audioOutputLevel", ssrc), &value)) {
30 // Not an audio receive stream.
31 return;
32 }
33
34 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesReceived", ssrc), &value));
35 perf_test::PrintResult(
36 "audio_bytes", modifier, "bytes_recv", value, "bytes", false);
37 EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value));
38 perf_test::PrintResult(
39 "audio_misc", modifier, "packets_lost", value, "frames", false);
40 EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value));
41 perf_test::PrintResult(
42 "audio_rx", modifier, "goog_jitter_recv", value, "ms", false);
43
44 EXPECT_TRUE(pc_dict.GetString(Statistic("googExpandRate", ssrc), &value));
45 perf_test::PrintResult(
46 "audio_rates", modifier, "goog_expand_rate", value, "%", false);
47 EXPECT_TRUE(
48 pc_dict.GetString(Statistic("googSpeechExpandRate", ssrc), &value));
49 perf_test::PrintResult(
50 "audio_rates", modifier, "goog_speech_expand_rate", value, "%", false);
51 EXPECT_TRUE(
52 pc_dict.GetString(Statistic("googSecondaryDecodedRate", ssrc), &value));
53 perf_test::PrintResult(
54 "audio_rates", modifier, "goog_secondary_decoded_rate", value, "%",
55 false);
56 }
57
58 static void MaybePrintResultsForAudioSend(
59 const std::string& ssrc, const base::DictionaryValue& pc_dict,
60 const std::string& modifier) {
61 std::string value;
62 if (!pc_dict.GetString(Statistic("audioInputLevel", ssrc), &value)) {
63 // Not an audio send stream.
64 return;
65 }
66
67 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesSent", ssrc), &value));
68 perf_test::PrintResult(
69 "audio_bytes", modifier, "bytes_sent", value, "bytes", false);
70 EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value));
71 perf_test::PrintResult(
72 "audio_tx", modifier, "goog_jitter_recv", value, "ms", false);
73 EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value));
74 perf_test::PrintResult(
75 "audio_tx", modifier, "goog_rtt", value, "ms", false);
76 EXPECT_TRUE(
77 pc_dict.GetString(Statistic("packetsSentPerSecond", ssrc), &value));
78 perf_test::PrintResult("audio_tx", modifier, "packets_sent_per_second", value,
79 "packets", false);
80 }
81
82 static void MaybePrintResultsForVideoSend(
83 const std::string& ssrc, const base::DictionaryValue& pc_dict,
84 const std::string& modifier) {
85 std::string value;
86 if (!pc_dict.GetString(Statistic("googFrameRateSent", ssrc), &value)) {
87 // Not a video send stream.
88 return;
89 }
90
91 // Graph these by unit: the dashboard expects all stats in one graph to have
92 // the same unit (e.g. ms, fps, etc). Most graphs, like video_fps, will also
93 // be populated by the counterparts on the video receiving side.
94 perf_test::PrintResult(
95 "video_fps", modifier, "goog_frame_rate_sent", value, "fps", false);
96 EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameRateInput", ssrc), &value));
97 perf_test::PrintResult(
98 "video_fps", modifier, "goog_frame_rate_input", value, "fps", false);
99
100 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesSent", ssrc), &value));
101 perf_test::PrintResult(
102 "video_total_bytes", modifier, "bytes_sent", value, "bytes", false);
103
104 EXPECT_TRUE(pc_dict.GetString(Statistic("googFirsReceived", ssrc), &value));
105 perf_test::PrintResult(
106 "video_misc", modifier, "goog_firs_recv", value, "", false);
107 EXPECT_TRUE(pc_dict.GetString(Statistic("googNacksReceived", ssrc), &value));
108 perf_test::PrintResult(
109 "video_misc", modifier, "goog_nacks_recv", value, "", false);
110
111 EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameWidthSent", ssrc), &value));
112 perf_test::PrintResult("video_resolution", modifier, "goog_frame_width_sent",
113 value, "pixels", false);
114 EXPECT_TRUE(
115 pc_dict.GetString(Statistic("googFrameHeightSent", ssrc), &value));
116 perf_test::PrintResult("video_resolution", modifier, "goog_frame_height_sent",
117 value, "pixels", false);
118
119 EXPECT_TRUE(pc_dict.GetString(Statistic("googAvgEncodeMs", ssrc), &value));
120 perf_test::PrintResult(
121 "video_tx", modifier, "goog_avg_encode_ms", value, "ms", false);
122 EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value));
123 perf_test::PrintResult("video_tx", modifier, "goog_rtt", value, "ms", false);
124
125 EXPECT_TRUE(pc_dict.GetString(
126 Statistic("googEncodeUsagePercent", ssrc), &value));
127 perf_test::PrintResult("video_cpu_usage", modifier,
128 "goog_encode_usage_percent", value, "%", false);
129 }
130
131 static void MaybePrintResultsForVideoReceive(
132 const std::string& ssrc, const base::DictionaryValue& pc_dict,
133 const std::string& modifier) {
134 std::string value;
135 if (!pc_dict.GetString(Statistic("googFrameRateReceived", ssrc), &value)) {
136 // Not a video receive stream.
137 return;
138 }
139
140 perf_test::PrintResult(
141 "video_fps", modifier, "goog_frame_rate_recv", value, "fps", false);
142 EXPECT_TRUE(
143 pc_dict.GetString(Statistic("googFrameRateOutput", ssrc), &value));
144 perf_test::PrintResult(
145 "video_fps", modifier, "goog_frame_rate_output", value, "fps", false);
146
147 EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value));
148 perf_test::PrintResult("video_misc", modifier, "packets_lost", value,
149 "frames", false);
150
151 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesReceived", ssrc), &value));
152 perf_test::PrintResult(
153 "video_total_bytes", modifier, "bytes_recv", value, "bytes", false);
154
155 EXPECT_TRUE(
156 pc_dict.GetString(Statistic("googFrameWidthReceived", ssrc), &value));
157 perf_test::PrintResult("video_resolution", modifier, "goog_frame_width_recv",
158 value, "pixels", false);
159 EXPECT_TRUE(
160 pc_dict.GetString(Statistic("googFrameHeightReceived", ssrc), &value));
161 perf_test::PrintResult("video_resolution", modifier, "goog_frame_height_recv",
162 value, "pixels", false);
163
164 EXPECT_TRUE(pc_dict.GetString(Statistic("googCurrentDelayMs", ssrc), &value));
165 perf_test::PrintResult(
166 "video_rx", modifier, "goog_current_delay_ms", value, "ms", false);
167 EXPECT_TRUE(pc_dict.GetString(Statistic("googTargetDelayMs", ssrc), &value));
168 perf_test::PrintResult(
169 "video_rx", modifier, "goog_target_delay_ms", value, "ms", false);
170 EXPECT_TRUE(pc_dict.GetString(Statistic("googDecodeMs", ssrc), &value));
171 perf_test::PrintResult("video_rx", modifier, "goog_decode_ms", value, "ms",
172 false);
173 EXPECT_TRUE(pc_dict.GetString(Statistic("googMaxDecodeMs", ssrc), &value));
174 perf_test::PrintResult(
175 "video_rx", modifier, "goog_max_decode_ms", value, "ms", false);
176 EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterBufferMs", ssrc), &value));
177 perf_test::PrintResult(
178 "video_rx", modifier, "goog_jitter_buffer_ms", value, "ms", false);
179 EXPECT_TRUE(pc_dict.GetString(Statistic("googRenderDelayMs", ssrc), &value));
180 perf_test::PrintResult(
181 "video_rx", modifier, "goog_render_delay_ms", value, "ms", false);
182 }
183
184 static std::string ExtractSsrcIdentifier(const std::string& key) {
185 // Example key: ssrc_1234-someStatName. Grab the part before the dash.
186 size_t key_start_pos = 0;
187 size_t key_end_pos = key.find("-");
188 CHECK(key_end_pos != std::string::npos) << "Could not parse key " << key;
189 return key.substr(key_start_pos, key_end_pos - key_start_pos);
190 }
191
192 // Returns the set of unique ssrc identifiers in the call (e.g. ssrc_1234,
193 // ssrc_12356, etc). |stats_dict| is the .stats dict from one peer connection.
194 static std::set<std::string> FindAllSsrcIdentifiers(
195 const base::DictionaryValue& stats_dict) {
196 std::set<std::string> result;
197 base::DictionaryValue::Iterator stats_iterator(stats_dict);
198
199 while (!stats_iterator.IsAtEnd()) {
200 if (stats_iterator.key().find("ssrc_") != std::string::npos)
201 result.insert(ExtractSsrcIdentifier(stats_iterator.key()));
202 stats_iterator.Advance();
203 }
204 return result;
205 }
206
207 namespace test {
208
209 void PrintBweForVideoMetrics(const base::DictionaryValue& pc_dict,
210 const std::string& modifier,
211 const std::string& video_codec) {
212 std::string video_modifier =
213 video_codec.empty() ? modifier : modifier + "_" + video_codec;
214 const std::string kBweStatsKey = "bweforvideo";
215 std::string value;
216 ASSERT_TRUE(pc_dict.GetString(
217 Statistic("googAvailableSendBandwidth", kBweStatsKey), &value));
218 perf_test::PrintResult("bwe_stats", video_modifier, "available_send_bw",
219 value, "bit/s", false);
220 ASSERT_TRUE(pc_dict.GetString(
221 Statistic("googAvailableReceiveBandwidth", kBweStatsKey), &value));
222 perf_test::PrintResult("bwe_stats", video_modifier, "available_recv_bw",
223 value, "bit/s", false);
224 ASSERT_TRUE(pc_dict.GetString(
225 Statistic("googTargetEncBitrate", kBweStatsKey), &value));
226 perf_test::PrintResult("bwe_stats", video_modifier, "target_enc_bitrate",
227 value, "bit/s", false);
228 ASSERT_TRUE(pc_dict.GetString(
229 Statistic("googActualEncBitrate", kBweStatsKey), &value));
230 perf_test::PrintResult("bwe_stats", video_modifier, "actual_enc_bitrate",
231 value, "bit/s", false);
232 ASSERT_TRUE(pc_dict.GetString(
233 Statistic("googTransmitBitrate", kBweStatsKey), &value));
234 perf_test::PrintResult("bwe_stats", video_modifier, "transmit_bitrate", value,
235 "bit/s", false);
236 }
237
238 void PrintMetricsForAllStreams(const base::DictionaryValue& pc_dict,
239 const std::string& modifier,
240 const std::string& video_codec) {
241 PrintMetricsForSendStreams(pc_dict, modifier, video_codec);
242 PrintMetricsForRecvStreams(pc_dict, modifier, video_codec);
243 }
244
245 void PrintMetricsForSendStreams(const base::DictionaryValue& pc_dict,
246 const std::string& modifier,
247 const std::string& video_codec) {
248 std::string video_modifier =
249 video_codec.empty() ? modifier : modifier + "_" + video_codec;
250 const base::DictionaryValue* stats_dict;
251 ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict));
252 std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict);
253
254 std::set<std::string>::const_iterator ssrc_iterator =
255 ssrc_identifiers.begin();
256 for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) {
257 const std::string& ssrc = *ssrc_iterator;
258 MaybePrintResultsForAudioSend(ssrc, pc_dict, modifier);
259 MaybePrintResultsForVideoSend(ssrc, pc_dict, video_modifier);
260 }
261 }
262
263 void PrintMetricsForRecvStreams(const base::DictionaryValue& pc_dict,
264 const std::string& modifier,
265 const std::string& video_codec) {
266 std::string video_modifier =
267 video_codec.empty() ? modifier : modifier + "_" + video_codec;
268 const base::DictionaryValue* stats_dict;
269 ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict));
270 std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict);
271
272 std::set<std::string>::const_iterator ssrc_iterator =
273 ssrc_identifiers.begin();
274 for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) {
275 const std::string& ssrc = *ssrc_iterator;
276 MaybePrintResultsForAudioReceive(ssrc, pc_dict, modifier);
277 MaybePrintResultsForVideoReceive(ssrc, pc_dict, video_modifier);
278 }
279 }
280
281 } // namespace test
OLDNEW
« no previous file with comments | « chrome/browser/media/webrtc_browsertest_perf.h ('k') | chrome/browser/media/webrtc_disable_encryption_flag_browsertest.cc » ('j') | chrome/chrome_tests_unit.gypi » ('J')

Powered by Google App Engine
This is Rietveld 408576698