Accept SDP with TRANSPORT attributes missing from bundled m= sections.

webrtc/api/peerconnection_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 507 matching lines @@
   }
 
   void RemoveMsidFromReceivedSdp(bool remove) { remove_msid_ = remove; }
 
   void RemoveSdesCryptoFromReceivedSdp(bool remove) { remove_sdes_ = remove; }
 
   void RemoveBundleFromReceivedSdp(bool remove) { remove_bundle_ = remove; }
 
   void RemoveCvoFromReceivedSdp(bool remove) { remove_cvo_ = remove; }
 
+  void MakeRealMaxBundleOfferFromReceivedSdp(bool real) {
+    make_real_max_bundle_offer_ = real;

[pthatcher1, 2017/02/17 19:17:32]

A better name might be:

modify_remote_offers_to_spec_compliant_bundle_

and 

ModifyRemoteOffersToSpecCompliantBundle

[Taylor Brandstetter, 2017/02/17 21:49:14]

Replaced "real" with "spec compliant".

+  }
+
   bool can_receive_audio() {
     bool value;
     if (prefer_constraint_apis_) {
       if (webrtc::FindConstraint(
               &offer_answer_constraints_,
               MediaConstraintsInterface::kOfferToReceiveAudio, &value,
               nullptr)) {
         return value;
       }
       return true;
@@ skipping 511 matching lines @@
   }
 
   void HandleIncomingOffer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingOffer ";
     if (NumberOfLocalMediaStreams() == 0 && auto_add_stream_) {
       // If we are not sending any streams ourselves it is time to add some.
       AddMediaStream(true, true);
     }
     std::unique_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("offer", msg, nullptr));
+
+    // Do the equivalent of setting the port to 0, adding a=bundle-only, and
+    // removing a=ice-ufrag, a=ice-pwd, a=fingerprint and a=setup from all but
+    // the first m= section.
+    if (make_real_max_bundle_offer_) {
+      bool first = true;
+      for (cricket::ContentInfo& content : desc->description()->contents()) {
+        if (first) {
+          first = false;
+          continue;
+        }
+        content.bundle_only = true;
+      }
+      first = true;
+      for (cricket::TransportInfo& transport :
+           desc->description()->transport_infos()) {
+        if (first) {
+          first = false;
+          continue;
+        }
+        transport.description.ice_ufrag.clear();
+        transport.description.ice_pwd.clear();
+        transport.description.connection_role = cricket::CONNECTIONROLE_NONE;
+        transport.description.identity_fingerprint.reset(nullptr);
+      }
+    }
+
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
     // Set the RtpReceiverObserver after receivers are created.
     SetRtpReceiverObservers();
     std::unique_ptr<SessionDescriptionInterface> answer;
     EXPECT_TRUE(DoCreateAnswer(&answer));
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     EXPECT_TRUE(DoSetLocalDescription(answer.release()));
     SendSdpMessage(webrtc::SessionDescriptionInterface::kAnswer, sdp);
   }
@@ skipping 140 matching lines @@
   webrtc::FakeConstraints offer_answer_constraints_;
   PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
   bool remove_msid_ = false;  // True if MSID should be removed in received SDP.
   bool remove_bundle_ =
       false;  // True if bundle should be removed in received SDP.
   bool remove_sdes_ =
       false;  // True if a=crypto should be removed in received SDP.
   // |remove_cvo_| is true if extension urn:3gpp:video-orientation should be
   // removed in the received SDP.
   bool remove_cvo_ = false;
+  // See LocalP2PTestWithRealMaxBundleOffer.
+  bool make_real_max_bundle_offer_ = false;
 
   rtc::scoped_refptr<DataChannelInterface> data_channel_;
   std::unique_ptr<MockDataChannelObserver> data_observer_;
 
   std::vector<std::unique_ptr<MockRtpReceiverObserver>> rtp_receiver_observers_;
 };
 
 class P2PTestConductor : public testing::Test {
  public:
   P2PTestConductor()
@@ skipping 627 matching lines @@
   FakeConstraints constraint;
   constraint.SetOptionalMaxWidth(320);
   SetVideoConstraints(constraint, constraint);
   initializing_client()->AddMediaStream(true, true);
   initializing_client()->AddMediaStream(false, true);
   ASSERT_EQ(2u, initializing_client()->NumberOfLocalMediaStreams());
   LocalP2PTest();
   EXPECT_EQ(2u, receiving_client()->number_of_remote_streams());
 }
 
+// Test that if applying a true "max bundle" offer, which uses ports of 0,
+// "a=bundle-only", omitting "a=fingerprint", "a=setup", "a=ice-ufrag" and
+// "a=ice-pwd" for all but the audio "m=" section, negotiation still completes
+// successfully and media flows.
+// TODO(deadbeef): Update this test to also omit "a=rtcp-mux", once that works.
+// TODO(deadbeef): Won't need this test once we start generating actual
+// standards-compliant SDP.
+TEST_F(P2PTestConductor, LocalP2PTestWithRealMaxBundleOffer) {

[pthatcher1, 2017/02/17 19:17:32]

A better test name might be IncomingOfferWithSpecCompliantBundle

+  ASSERT_TRUE(CreateTestClients());
+  receiving_client()->MakeRealMaxBundleOfferFromReceivedSdp(true);
+  LocalP2PTest();
+}
+
 // Test that we can receive the audio output level from a remote audio track.
 TEST_F(P2PTestConductor, GetAudioOutputLevelStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* remote_streams =
       initializing_client()->remote_streams();
   ASSERT_GT(remote_streams->count(), 0u);
   ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* remote_audio_track =
@@ skipping 959 matching lines @@
   servers.push_back(server);
   EXPECT_EQ(webrtc::RTCErrorType::NONE,
             webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
   EXPECT_EQ(2U, turn_servers_.size());
   EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority);
 }
 
 #endif // if !defined(THREAD_SANITIZER)
 
 }  // namespace