Changed defaults for CreateAnswer in non-constraint mode

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 137 matching lines @@
 };
 
 class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
                                  public SignalingMessageReceiver,
                                  public ObserverInterface {
  public:
   static PeerConnectionTestClient* CreateClientWithDtlsIdentityStore(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
-      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
+      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
+      bool prefer_constraint_apis) {
     PeerConnectionTestClient* client(new PeerConnectionTestClient(id));
-    if (!client->Init(constraints, options, std::move(dtls_identity_store))) {
+    if (!client->Init(constraints, options, std::move(dtls_identity_store),
+                      prefer_constraint_apis)) {
       delete client;
       return nullptr;
     }
     return client;
   }
 
   static PeerConnectionTestClient* CreateClient(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options) {
     rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
 
-    return CreateClientWithDtlsIdentityStore(id, constraints, options,
-                                             std::move(dtls_identity_store));
+    return CreateClientWithDtlsIdentityStore(
+        id, constraints, options, std::move(dtls_identity_store), true);
+  }
+
+  static PeerConnectionTestClient* CreateClientPreferNoConstraints(
+      const std::string& id,
+      const PeerConnectionFactory::Options* options) {
+    rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
+        rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
+                                              : nullptr);
+
+    return CreateClientWithDtlsIdentityStore(
+        id, nullptr, options, std::move(dtls_identity_store), false);
   }
 
   ~PeerConnectionTestClient() {
   }
 
   void Negotiate() { Negotiate(true, true); }
 
   void Negotiate(bool audio, bool video) {
     rtc::scoped_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(offer.use()));
@@ skipping 142 matching lines @@
     signaling_message_receiver_ = signaling_message_receiver;
   }
 
   void EnableVideoDecoderFactory() {
     video_decoder_factory_enabled_ = true;
     fake_video_decoder_factory_->AddSupportedVideoCodecType(
         webrtc::kVideoCodecVP8);
   }
 
   void IceRestart() {
-    session_description_constraints_.SetMandatoryIceRestart(true);
+    offer_answer_constraints_.SetMandatoryIceRestart(true);
+    offer_answer_options_.ice_restart = true;
     SetExpectIceRestart(true);
   }
 
   void SetExpectIceRestart(bool expect_restart) {
     expect_ice_restart_ = expect_restart;
   }
 
   bool ExpectIceRestart() const { return expect_ice_restart_; }
 
   void SetReceiveAudioVideo(bool audio, bool video) {
     SetReceiveAudio(audio);
     SetReceiveVideo(video);
     ASSERT_EQ(audio, can_receive_audio());
     ASSERT_EQ(video, can_receive_video());
   }
 
   void SetReceiveAudio(bool audio) {
     if (audio && can_receive_audio())
       return;
-    session_description_constraints_.SetMandatoryReceiveAudio(audio);
+    offer_answer_constraints_.SetMandatoryReceiveAudio(audio);
+    offer_answer_options_.offer_to_receive_audio = audio ? 1 : 0;
   }
 
   void SetReceiveVideo(bool video) {
     if (video && can_receive_video())
       return;
-    session_description_constraints_.SetMandatoryReceiveVideo(video);
+    offer_answer_constraints_.SetMandatoryReceiveVideo(video);
+    offer_answer_options_.offer_to_receive_video = video ? 1 : 0;
   }
 
   void RemoveMsidFromReceivedSdp(bool remove) { remove_msid_ = remove; }
 
   void RemoveSdesCryptoFromReceivedSdp(bool remove) { remove_sdes_ = remove; }
 
   void RemoveBundleFromReceivedSdp(bool remove) { remove_bundle_ = remove; }
 
   bool can_receive_audio() {
     bool value;
-    if (webrtc::FindConstraint(&session_description_constraints_,
-                               MediaConstraintsInterface::kOfferToReceiveAudio,
-                               &value, nullptr)) {
-      return value;
+    if (prefer_constraint_apis_) {
+      if (webrtc::FindConstraint(
+              &offer_answer_constraints_,
+              MediaConstraintsInterface::kOfferToReceiveAudio, &value,
+              nullptr)) {
+        return value;
+      }
+      return true;
     }
-    return true;
+    return offer_answer_options_.offer_to_receive_audio > 0 ||
+           offer_answer_options_.offer_to_receive_audio ==
+               PeerConnectionInterface::RTCOfferAnswerOptions::kUndefined;
   }
 
   bool can_receive_video() {
     bool value;
-    if (webrtc::FindConstraint(&session_description_constraints_,
-                               MediaConstraintsInterface::kOfferToReceiveVideo,
-                               &value, nullptr)) {
-      return value;
+    if (prefer_constraint_apis_) {
+      if (webrtc::FindConstraint(
+              &offer_answer_constraints_,
+              MediaConstraintsInterface::kOfferToReceiveVideo, &value,
+              nullptr)) {
+        return value;
+      }
+      return true;
     }
-    return true;
+    return offer_answer_options_.offer_to_receive_video > 0 ||
+           offer_answer_options_.offer_to_receive_video ==
+               PeerConnectionInterface::RTCOfferAnswerOptions::kUndefined;
   }
 
   void OnDataChannel(DataChannelInterface* data_channel) override {
     LOG(INFO) << id_ << "OnDataChannel";
     data_channel_ = data_channel;
     data_observer_.reset(new MockDataChannelObserver(data_channel));
   }
 
   void CreateDataChannel() {
     data_channel_ = pc()->CreateDataChannel(kDataChannelLabel, nullptr);
@@ skipping 336 matching lines @@
    private:
     bool completed_;
     std::vector<std::string> tones_;
   };
 
   explicit PeerConnectionTestClient(const std::string& id) : id_(id) {}
 
   bool Init(
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
-      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store) {
+      rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
+      bool prefer_constraint_apis) {
     EXPECT_TRUE(!peer_connection_);
     EXPECT_TRUE(!peer_connection_factory_);
+    if (!prefer_constraint_apis) {
+      EXPECT_TRUE(!constraints);
+    }
+    prefer_constraint_apis_ = prefer_constraint_apis;
+
     rtc::scoped_ptr<cricket::PortAllocator> port_allocator(
         new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr));
     fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
 
     if (fake_audio_capture_module_ == nullptr) {
       return false;
     }
     fake_video_decoder_factory_ = new FakeWebRtcVideoDecoderFactory();
     fake_video_encoder_factory_ = new FakeWebRtcVideoEncoderFactory();
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
@@ skipping 51 matching lines @@
     rtc::scoped_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("answer", msg, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
   }
 
   bool DoCreateOfferAnswer(SessionDescriptionInterface** desc,
                            bool offer) {
     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
-    if (offer) {
-      pc()->CreateOffer(observer, &session_description_constraints_);
+    if (prefer_constraint_apis_) {
+      if (offer) {
+        pc()->CreateOffer(observer, &offer_answer_constraints_);
+      } else {
+        pc()->CreateAnswer(observer, &offer_answer_constraints_);
+      }
     } else {
-      pc()->CreateAnswer(observer, &session_description_constraints_);
+      if (offer) {
+        pc()->CreateOffer(observer, offer_answer_options_);
+      } else {
+        pc()->CreateAnswer(observer, offer_answer_options_);
+      }
     }
     EXPECT_EQ_WAIT(true, observer->called(), kMaxWaitMs);
     *desc = observer->release_desc();
     if (observer->result() && ExpectIceRestart()) {
       EXPECT_EQ(0u, (*desc)->candidates(0)->count());
     }
     return observer->result();
   }
 
   bool DoCreateOffer(SessionDescriptionInterface** desc) {
@@ skipping 52 matching lines @@
       RemoveLinesFromSdp(kSdpSdesCryptoAttribute, sdp);
     }
   }
 
   std::string id_;
 
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
       peer_connection_factory_;
 
+  bool prefer_constraint_apis_ = true;
   bool auto_add_stream_ = true;
 
   typedef std::pair<std::string, std::string> IceUfragPwdPair;
   std::map<int, IceUfragPwdPair> ice_ufrag_pwd_;
   bool expect_ice_restart_ = false;
 
   // Needed to keep track of number of frames sent.
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   // Needed to keep track of number of frames received.
   std::map<std::string, rtc::scoped_ptr<webrtc::FakeVideoTrackRenderer>>
       fake_video_renderers_;
   // Needed to ensure frames aren't received for removed tracks.
   std::vector<rtc::scoped_ptr<webrtc::FakeVideoTrackRenderer>>
       removed_fake_video_renderers_;
   // Needed to keep track of number of frames received when external decoder
   // used.
   FakeWebRtcVideoDecoderFactory* fake_video_decoder_factory_ = nullptr;
   FakeWebRtcVideoEncoderFactory* fake_video_encoder_factory_ = nullptr;
   bool video_decoder_factory_enabled_ = false;
   webrtc::FakeConstraints video_constraints_;
 
   // For remote peer communication.
   SignalingMessageReceiver* signaling_message_receiver_ = nullptr;
 
   // Store references to the video capturers we've created, so that we can stop
   // them, if required.
   std::vector<cricket::VideoCapturer*> video_capturers_;
 
-  webrtc::FakeConstraints session_description_constraints_;
+  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.
 
   rtc::scoped_refptr<DataChannelInterface> data_channel_;
   rtc::scoped_ptr<MockDataChannelObserver> data_observer_;
 };
 
@@ skipping 89 matching lines @@
   }
 
   bool CreateTestClients() { return CreateTestClients(nullptr, nullptr); }
 
   bool CreateTestClients(MediaConstraintsInterface* init_constraints,
                          MediaConstraintsInterface* recv_constraints) {
     return CreateTestClients(init_constraints, nullptr, recv_constraints,
                              nullptr);
   }
 
+  bool CreateTestClientsThatPreferNoConstraints() {
+    initiating_client_.reset(
+        PeerConnectionTestClient::CreateClientPreferNoConstraints("Caller: ",
+                                                                  nullptr));
+    receiving_client_.reset(
+        PeerConnectionTestClient::CreateClientPreferNoConstraints("Callee: ",
+                                                                  nullptr));
+    if (!initiating_client_ || !receiving_client_) {
+      return false;
+    }
+    // Remember the choice for possible later resets of the clients.
+    prefer_constraint_apis_ = false;
+    SetSignalingReceivers();
+    return true;
+  }
+
   void SetSignalingReceivers() {
     initiating_client_->set_signaling_message_receiver(receiving_client_.get());
     receiving_client_->set_signaling_message_receiver(initiating_client_.get());
   }
 
   bool CreateTestClients(MediaConstraintsInterface* init_constraints,
                          PeerConnectionFactory::Options* init_options,
                          MediaConstraintsInterface* recv_constraints,
                          PeerConnectionFactory::Options* recv_options) {
     initiating_client_.reset(PeerConnectionTestClient::CreateClient(
@@ skipping 88 matching lines @@
                                    true);
 
     rtc::scoped_ptr<FakeDtlsIdentityStore> dtls_identity_store(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ? new FakeDtlsIdentityStore()
                                               : nullptr);
     dtls_identity_store->use_alternate_key();
 
     // Make sure the new client is using a different certificate.
     return PeerConnectionTestClient::CreateClientWithDtlsIdentityStore(
         "New Peer: ", &setup_constraints, nullptr,
-        std::move(dtls_identity_store));
+        std::move(dtls_identity_store), prefer_constraint_apis_);
   }
 
   void SendRtpData(webrtc::DataChannelInterface* dc, const std::string& data) {
     // Messages may get lost on the unreliable DataChannel, so we send multiple
     // times to avoid test flakiness.
     static const size_t kSendAttempts = 5;
 
     for (size_t i = 0; i < kSendAttempts; ++i) {
       dc->Send(DataBuffer(data));
     }
@@ skipping 24 matching lines @@
     receiving_client_.reset(client);
     return old;
   }
 
  private:
   rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
   rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::scoped_ptr<PeerConnectionTestClient> initiating_client_;
   rtc::scoped_ptr<PeerConnectionTestClient> receiving_client_;
+  bool prefer_constraint_apis_ = true;
 };
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 #if !defined(THREAD_SANITIZER)
 
 // This test sets up a Jsep call between two parties and test Dtmf.
 // TODO(holmer): Disabled due to sometimes crashing on buildbots.
 // See issue webrtc/2378.
 TEST_F(P2PTestConductor, DISABLED_LocalP2PTestDtmf) {
@@ skipping 46 matching lines @@
 }
 
 // This test sets up an one-way call, with media only from initiator to
 // responder.
 TEST_F(P2PTestConductor, OneWayMediaCall) {
   ASSERT_TRUE(CreateTestClients());
   receiving_client()->set_auto_add_stream(false);
   LocalP2PTest();
 }
 
+TEST_F(P2PTestConductor, OneWayMediaCallWithoutConstraints) {
+  ASSERT_TRUE(CreateTestClientsThatPreferNoConstraints());
+  receiving_client()->set_auto_add_stream(false);
+  LocalP2PTest();
+}
+
 // This test sets up a audio call initially and then upgrades to audio/video,
 // using DTLS.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsRenegotiate) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->SetReceiveAudioVideo(true, false);
   LocalP2PTest();
@@ skipping 782 matching lines @@
   server.urls.push_back("turn:hostname2");
   servers.push_back(server);
   EXPECT_TRUE(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