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 "base/strings/stringprintf.h" 8 #include "base/values.h" 9 #include "chrome/test/base/in_process_browser_test.h" 10 #include "testing/perf/perf_test.h" 11 12 static std::string Statistic(const std::string& statistic, 13 const std::string& bucket) { 14 // A ssrc stats key will be on the form stats.<bucket>-<key>.values. 15 // This will give a json "path" which will dig into the time series for the 16 // specified statistic. Buckets can be for instance ssrc_1212344, bweforvideo, 17 // and will each contain a bunch of statistics relevant to their nature. 18 // Each peer connection has a number of such buckets. 19 return base::StringPrintf("stats.%s-%s.values", bucket.c_str(), 20 statistic.c_str()); 21 } 22 23 static bool MaybePrintResultsForAudioReceive( 24 const std::string& ssrc, const base::DictionaryValue& pc_dict) { 25 std::string value; 26 if (!pc_dict.GetString(Statistic("audioOutputLevel", ssrc), &value)) { 27 // Not an audio receive stream. 28 return false; 29 } 30 31 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesReceived", ssrc), &value)); 32 perf_test::PrintResult( 33 "audio_bytes", "", "bytes_recv", value, "bytes", false); 34 EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value)); 35 perf_test::PrintResult( 36 "audio_misc", "", "packets_lost", value, "", false); 37 38 return true; 39 } 40 41 static bool MaybePrintResultsForAudioSend( 42 const std::string& ssrc, const base::DictionaryValue& pc_dict) { 43 std::string value; 44 if (!pc_dict.GetString(Statistic("audioInputLevel", ssrc), &value)) { 45 // Not an audio send stream. 46 return false; 47 } 48 49 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesSent", ssrc), &value)); 50 perf_test::PrintResult( 51 "audio_bytes", "", "bytes_sent", value, "bytes", false); 52 EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value)); 53 perf_test::PrintResult( 54 "audio_tx", "", "goog_jitter_recv", value, "ms", false); 55 EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value)); 56 perf_test::PrintResult( 57 "audio_tx", "", "goog_rtt", value, "ms", false); 58 return true; 59 } 60 61 static bool MaybePrintResultsForVideoSend( 62 const std::string& ssrc, const base::DictionaryValue& pc_dict) { 63 std::string value; 64 if (!pc_dict.GetString(Statistic("googFrameRateSent", ssrc), &value)) { 65 // Not a video send stream. 66 return false; 67 } 68 69 // Graph these by unit: the dashboard expects all stats in one graph to have 70 // the same unit (e.g. ms, fps, etc). Most graphs, like video_fps, will also 71 // be populated by the counterparts on the video receiving side. 72 perf_test::PrintResult( 73 "video_fps", "", "goog_frame_rate_sent", value, "fps", false); 74 EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameRateInput", ssrc), &value)); 75 perf_test::PrintResult( 76 "video_fps", "", "goog_frame_rate_input", value, "fps", false); 77 78 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesSent", ssrc), &value)); 79 perf_test::PrintResult( 80 "video_total_bytes", "", "bytes_sent", value, "bytes", false); 81 82 EXPECT_TRUE(pc_dict.GetString(Statistic("googFirsReceived", ssrc), &value)); 83 perf_test::PrintResult( 84 "video_misc", "", "goog_firs_recv", value, "", false); 85 EXPECT_TRUE(pc_dict.GetString(Statistic("googNacksReceived", ssrc), &value)); 86 perf_test::PrintResult( 87 "video_misc", "", "goog_nacks_recv", value, "", false); 88 89 EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameWidthSent", ssrc), &value)); 90 perf_test::PrintResult( 91 "video_resolution", "", "goog_frame_width_sent", value, "pixels", false); 92 EXPECT_TRUE( 93 pc_dict.GetString(Statistic("googFrameHeightSent", ssrc), &value)); 94 perf_test::PrintResult( 95 "video_resolution", "", "goog_frame_height_sent", value, "pixels", false); 96 97 EXPECT_TRUE(pc_dict.GetString( 98 Statistic("googCaptureJitterMs", ssrc), &value)); 99 perf_test::PrintResult( 100 "video_tx", "", "goog_capture_jitter_ms", value, "ms", false); 101 EXPECT_TRUE(pc_dict.GetString( 102 Statistic("googCaptureQueueDelayMsPerS", ssrc), &value)); 103 perf_test::PrintResult( 104 "video_tx", "", "goog_capture_queue_delay_ms_per_s", 105 value, "ms/s", false); 106 EXPECT_TRUE(pc_dict.GetString(Statistic("googAvgEncodeMs", ssrc), &value)); 107 perf_test::PrintResult( 108 "video_tx", "", "goog_avg_encode_ms", value, "ms", false); 109 EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value)); 110 perf_test::PrintResult("video_tx", "", "goog_rtt", value, "ms", false); 111 112 EXPECT_TRUE(pc_dict.GetString( 113 Statistic("googEncodeUsagePercent", ssrc), &value)); 114 perf_test::PrintResult( 115 "video_cpu_usage", "", "goog_encode_usage_percent", value, "%", false); 116 return true; 117 } 118 119 static bool MaybePrintResultsForVideoReceive( 120 const std::string& ssrc, const base::DictionaryValue& pc_dict) { 121 std::string value; 122 if (!pc_dict.GetString(Statistic("googFrameRateReceived", ssrc), &value)) { 123 // Not a video receive stream. 124 return false; 125 } 126 127 perf_test::PrintResult( 128 "video_fps", "", "goog_frame_rate_recv", value, "fps", false); 129 EXPECT_TRUE( 130 pc_dict.GetString(Statistic("googFrameRateOutput", ssrc), &value)); 131 perf_test::PrintResult( 132 "video_fps", "", "goog_frame_rate_output", value, "fps", false); 133 134 EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value)); 135 perf_test::PrintResult("video_misc", "", "packets_lost", value, "", false); 136 137 EXPECT_TRUE(pc_dict.GetString(Statistic("bytesReceived", ssrc), &value)); 138 perf_test::PrintResult( 139 "video_total_bytes", "", "bytes_recv", value, "bytes", false); 140 141 EXPECT_TRUE( 142 pc_dict.GetString(Statistic("googFrameWidthReceived", ssrc), &value)); 143 perf_test::PrintResult( 144 "video_resolution", "", "goog_frame_width_recv", value, "pixels", false); 145 EXPECT_TRUE( 146 pc_dict.GetString(Statistic("googFrameHeightReceived", ssrc), &value)); 147 perf_test::PrintResult( 148 "video_resolution", "", "goog_frame_height_recv", value, "pixels", false); 149 150 EXPECT_TRUE(pc_dict.GetString(Statistic("googCurrentDelayMs", ssrc), &value)); 151 perf_test::PrintResult( 152 "video_rx", "", "goog_current_delay_ms", value, "ms", false); 153 EXPECT_TRUE(pc_dict.GetString(Statistic("googTargetDelayMs", ssrc), &value)); 154 perf_test::PrintResult( 155 "video_rx", "", "goog_target_delay_ms", value, "ms", false); 156 EXPECT_TRUE(pc_dict.GetString(Statistic("googDecodeMs", ssrc), &value)); 157 perf_test::PrintResult("video_rx", "", "goog_decode_ms", value, "ms", false); 158 EXPECT_TRUE(pc_dict.GetString(Statistic("googMaxDecodeMs", ssrc), &value)); 159 perf_test::PrintResult( 160 "video_rx", "", "goog_max_decode_ms", value, "ms", false); 161 EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterBufferMs", ssrc), &value)); 162 perf_test::PrintResult( 163 "video_rx", "", "goog_jitter_buffer_ms", value, "ms", false); 164 EXPECT_TRUE(pc_dict.GetString(Statistic("googRenderDelayMs", ssrc), &value)); 165 perf_test::PrintResult( 166 "video_rx", "", "goog_render_delay_ms", value, "ms", false); 167 168 return true; 169 } 170 171 static std::string ExtractSsrcIdentifier(const std::string& key) { 172 // Example key: ssrc_1234-someStatName. Grab the part before the dash. 173 size_t key_start_pos = 0; 174 size_t key_end_pos = key.find("-"); 175 CHECK(key_end_pos != std::string::npos) << "Could not parse key " << key; 176 return key.substr(key_start_pos, key_end_pos - key_start_pos); 177 } 178 179 // Returns the set of unique ssrc identifiers in the call (e.g. ssrc_1234, 180 // ssrc_12356, etc). |stats_dict| is the .stats dict from one peer connection. 181 static std::set<std::string> FindAllSsrcIdentifiers( 182 const base::DictionaryValue& stats_dict) { 183 std::set<std::string> result; 184 base::DictionaryValue::Iterator stats_iterator(stats_dict); 185 186 while (!stats_iterator.IsAtEnd()) { 187 if (stats_iterator.key().find("ssrc_") != std::string::npos) 188 result.insert(ExtractSsrcIdentifier(stats_iterator.key())); 189 stats_iterator.Advance(); 190 } 191 return result; 192 } 193 194 namespace test { 195 196 void PrintBweForVideoMetrics(const base::DictionaryValue& pc_dict) { 197 const std::string kBweStatsKey = "bweforvideo"; 198 std::string value; 199 ASSERT_TRUE(pc_dict.GetString( 200 Statistic("googAvailableSendBandwidth", kBweStatsKey), &value)); 201 perf_test::PrintResult( 202 "bwe_stats", "", "available_send_bw", value, "bit/s", false); 203 ASSERT_TRUE(pc_dict.GetString( 204 Statistic("googAvailableReceiveBandwidth", kBweStatsKey), &value)); 205 perf_test::PrintResult( 206 "bwe_stats", "", "available_recv_bw", value, "bit/s", false); 207 ASSERT_TRUE(pc_dict.GetString( 208 Statistic("googTargetEncBitrate", kBweStatsKey), &value)); 209 perf_test::PrintResult( 210 "bwe_stats", "", "target_enc_bitrate", value, "bit/s", false); 211 ASSERT_TRUE(pc_dict.GetString( 212 Statistic("googActualEncBitrate", kBweStatsKey), &value)); 213 perf_test::PrintResult( 214 "bwe_stats", "", "actual_enc_bitrate", value, "bit/s", false); 215 ASSERT_TRUE(pc_dict.GetString( 216 Statistic("googTransmitBitrate", kBweStatsKey), &value)); 217 perf_test::PrintResult( 218 "bwe_stats", "", "transmit_bitrate", value, "bit/s",false); 219 } 220 221 void PrintMetricsForAllStreams(const base::DictionaryValue& pc_dict) { 222 const base::DictionaryValue* stats_dict; 223 ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict)); 224 std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict); 225 226 std::set<std::string>::const_iterator ssrc_iterator = 227 ssrc_identifiers.begin(); 228 for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) { 229 // Figure out which stream type this ssrc represents and print all the 230 // interesting metrics for it. 231 const std::string& ssrc = *ssrc_iterator; 232 bool did_recognize_stream_type = 233 MaybePrintResultsForAudioReceive(ssrc, pc_dict) || 234 MaybePrintResultsForAudioSend(ssrc, pc_dict) || 235 MaybePrintResultsForVideoReceive(ssrc, pc_dict) || 236 MaybePrintResultsForVideoSend(ssrc, pc_dict); 237 ASSERT_TRUE(did_recognize_stream_type) << "Failed to figure out which " 238 "kind of stream SSRC " << ssrc 239 << " is. "; 240 } 241 } 242 243 } // namespace test 244
