Filter send-only and recv-only as appropriate in WebRTC perf tests.

chrome/browser/media/webrtc_browsertest_perf.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/media/webrtc_browsertest_perf.h"
 
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "testing/perf/perf_test.h"
 
 static std::string Statistic(const std::string& statistic,
                              const std::string& bucket) {
   // A ssrc stats key will be on the form stats.<bucket>-<key>.values.
   // This will give a json "path" which will dig into the time series for the
   // specified statistic. Buckets can be for instance ssrc_1212344, bweforvideo,
   // and will each contain a bunch of statistics relevant to their nature.
   // Each peer connection has a number of such buckets.
   return base::StringPrintf("stats.%s-%s.values", bucket.c_str(),
                             statistic.c_str());
 }
 
-static bool MaybePrintResultsForAudioReceive(
+static void MaybePrintResultsForAudioReceive(
     const std::string& ssrc, const base::DictionaryValue& pc_dict,
     const std::string& modifier) {
   std::string value;
   if (!pc_dict.GetString(Statistic("audioOutputLevel", ssrc), &value)) {
     // Not an audio receive stream.
-    return false;
+    return;
   }
 
   EXPECT_TRUE(pc_dict.GetString(Statistic("bytesReceived", ssrc), &value));
   perf_test::PrintResult(
       "audio_bytes", modifier, "bytes_recv", value, "bytes", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value));
   perf_test::PrintResult(
       "audio_misc", modifier, "packets_lost", value, "frames", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value));
   perf_test::PrintResult(
       "audio_rx", modifier, "goog_jitter_recv", value, "ms", false);
 
   EXPECT_TRUE(pc_dict.GetString(Statistic("googExpandRate", ssrc), &value));
   perf_test::PrintResult(
       "audio_rates", modifier, "goog_expand_rate", value, "%", false);
   EXPECT_TRUE(
       pc_dict.GetString(Statistic("googSpeechExpandRate", ssrc), &value));
   perf_test::PrintResult(
       "audio_rates", modifier, "goog_speech_expand_rate", value, "%", false);
   EXPECT_TRUE(
       pc_dict.GetString(Statistic("googSecondaryDecodedRate", ssrc), &value));
   perf_test::PrintResult(
       "audio_rates", modifier, "goog_secondary_decoded_rate", value, "%",
       false);
-
-  return true;
 }
 
-static bool MaybePrintResultsForAudioSend(
+static void MaybePrintResultsForAudioSend(
     const std::string& ssrc, const base::DictionaryValue& pc_dict,
     const std::string& modifier) {
   std::string value;
   if (!pc_dict.GetString(Statistic("audioInputLevel", ssrc), &value)) {
     // Not an audio send stream.
-    return false;
+    return;
   }
 
   EXPECT_TRUE(pc_dict.GetString(Statistic("bytesSent", ssrc), &value));
   perf_test::PrintResult(
       "audio_bytes", modifier, "bytes_sent", value, "bytes", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterReceived", ssrc), &value));
   perf_test::PrintResult(
       "audio_tx", modifier, "goog_jitter_recv", value, "ms", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value));
   perf_test::PrintResult(
       "audio_tx", modifier, "goog_rtt", value, "ms", false);
-  return true;
 }
 
-static bool MaybePrintResultsForVideoSend(
+static void MaybePrintResultsForVideoSend(
     const std::string& ssrc, const base::DictionaryValue& pc_dict,
     const std::string& modifier) {
   std::string value;
   if (!pc_dict.GetString(Statistic("googFrameRateSent", ssrc), &value)) {
     // Not a video send stream.
-    return false;
+    return;
   }
 
   // Graph these by unit: the dashboard expects all stats in one graph to have
   // the same unit (e.g. ms, fps, etc). Most graphs, like video_fps, will also
   // be populated by the counterparts on the video receiving side.
   perf_test::PrintResult(
       "video_fps", modifier, "goog_frame_rate_sent", value, "fps", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googFrameRateInput", ssrc), &value));
   perf_test::PrintResult(
       "video_fps", modifier, "goog_frame_rate_input", value, "fps", false);
@@ skipping 20 matching lines @@
   EXPECT_TRUE(pc_dict.GetString(Statistic("googAvgEncodeMs", ssrc), &value));
   perf_test::PrintResult(
       "video_tx", modifier, "goog_avg_encode_ms", value, "ms", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googRtt", ssrc), &value));
   perf_test::PrintResult("video_tx", modifier, "goog_rtt", value, "ms", false);
 
   EXPECT_TRUE(pc_dict.GetString(
       Statistic("googEncodeUsagePercent", ssrc), &value));
   perf_test::PrintResult("video_cpu_usage", modifier,
                          "goog_encode_usage_percent", value, "%", false);
-  return true;
 }
 
-static bool MaybePrintResultsForVideoReceive(
+static void MaybePrintResultsForVideoReceive(
     const std::string& ssrc, const base::DictionaryValue& pc_dict,
     const std::string& modifier) {
   std::string value;
   if (!pc_dict.GetString(Statistic("googFrameRateReceived", ssrc), &value)) {
     // Not a video receive stream.
-    return false;
+    return;
   }
 
   perf_test::PrintResult(
       "video_fps", modifier, "goog_frame_rate_recv", value, "fps", false);
   EXPECT_TRUE(
       pc_dict.GetString(Statistic("googFrameRateOutput", ssrc), &value));
   perf_test::PrintResult(
       "video_fps", modifier, "goog_frame_rate_output", value, "fps", false);
 
   EXPECT_TRUE(pc_dict.GetString(Statistic("packetsLost", ssrc), &value));
@@ skipping 24 matching lines @@
                          false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googMaxDecodeMs", ssrc), &value));
   perf_test::PrintResult(
       "video_rx", modifier, "goog_max_decode_ms", value, "ms", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googJitterBufferMs", ssrc), &value));
   perf_test::PrintResult(
       "video_rx", modifier, "goog_jitter_buffer_ms", value, "ms", false);
   EXPECT_TRUE(pc_dict.GetString(Statistic("googRenderDelayMs", ssrc), &value));
   perf_test::PrintResult(
       "video_rx", modifier, "goog_render_delay_ms", value, "ms", false);
-
-  return true;
 }
 
 static std::string ExtractSsrcIdentifier(const std::string& key) {
   // Example key: ssrc_1234-someStatName. Grab the part before the dash.
   size_t key_start_pos = 0;
   size_t key_end_pos = key.find("-");
   CHECK(key_end_pos != std::string::npos) << "Could not parse key " << key;
   return key.substr(key_start_pos, key_end_pos - key_start_pos);
 }
 
@@ skipping 39 matching lines @@
                          value, "bit/s", false);
   ASSERT_TRUE(pc_dict.GetString(
       Statistic("googTransmitBitrate", kBweStatsKey), &value));
   perf_test::PrintResult("bwe_stats", video_modifier, "transmit_bitrate", value,
                          "bit/s", false);
 }
 
 void PrintMetricsForAllStreams(const base::DictionaryValue& pc_dict,
                                const std::string& modifier,
                                const std::string& video_codec) {
+  PrintMetricsForSendStreams(pc_dict, modifier, video_codec);
+  PrintMetricsForRecvStreams(pc_dict, modifier, video_codec);
+}
+
+void PrintMetricsForSendStreams(const base::DictionaryValue& pc_dict,
+                                const std::string& modifier,
+                                const std::string& video_codec) {
   std::string video_modifier =
       video_codec.empty() ? modifier : modifier + "_" + video_codec;
   const base::DictionaryValue* stats_dict;
+  ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict));
+  std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict);
+
+  std::set<std::string>::const_iterator ssrc_iterator =
+      ssrc_identifiers.begin();
+  for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) {
+    const std::string& ssrc = *ssrc_iterator;
+    MaybePrintResultsForAudioSend(ssrc, pc_dict, modifier);
+    MaybePrintResultsForVideoSend(ssrc, pc_dict, video_modifier);
+  }
+}
+
+void PrintMetricsForRecvStreams(const base::DictionaryValue& pc_dict,
+                                const std::string& modifier,
+                                const std::string& video_codec) {
+  std::string video_modifier =
+      video_codec.empty() ? modifier : modifier + "_" + video_codec;
+  const base::DictionaryValue* stats_dict;
   ASSERT_TRUE(pc_dict.GetDictionary("stats", &stats_dict));
   std::set<std::string> ssrc_identifiers = FindAllSsrcIdentifiers(*stats_dict);
 
   std::set<std::string>::const_iterator ssrc_iterator =
       ssrc_identifiers.begin();
   for (; ssrc_iterator != ssrc_identifiers.end(); ++ssrc_iterator) {
-    // Figure out which stream type this ssrc represents and print all the
-    // interesting metrics for it.
     const std::string& ssrc = *ssrc_iterator;
-    bool did_recognize_stream_type =
-        MaybePrintResultsForAudioReceive(ssrc, pc_dict, modifier) ||
-        MaybePrintResultsForAudioSend(ssrc, pc_dict, modifier) ||
-        MaybePrintResultsForVideoReceive(ssrc, pc_dict, video_modifier) ||
-        MaybePrintResultsForVideoSend(ssrc, pc_dict, video_modifier);
-    ASSERT_TRUE(did_recognize_stream_type) << "Failed to figure out which "
-                                              "kind of stream SSRC " << ssrc
-                                           << " is. ";
+    MaybePrintResultsForAudioReceive(ssrc, pc_dict, modifier);
+    MaybePrintResultsForVideoReceive(ssrc, pc_dict, video_modifier);
   }
 }
 
 }  // namespace test