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"
@@ skipping 222 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);

[kjellander_chromium, 2016/03/29 12:52:26]

Shouldn't we continue to check the result of these methods as in the previous
implementation?

[phoglund_chromium, 2016/03/29 14:02:09]

That would be nice, but it seemed clunky to implement. In that case the two new
Print methods would need to coordinate among each other since one knows about
recv and one send. I didn't think it was worth it. I don't know if we care if a
new SSRC comes along, anyway. We do care if ssrc types disappear though, but
that's caught by data stoppage alerts.

[kjellander_chromium, 2016/03/29 14:10:31]

OK, but if we now never look at the result from the Maybe* methods, I suggest
removing the returning of the boolean value from them.

[phoglund_chromium, 2016/03/29 14:37:24]

Good point. Done

+    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