Merging BaseSession code into WebRtcSession.

talk/app/webrtc/webrtcsession_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 50 matching lines @@
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(feature())) {                               \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
-using cricket::BaseSession;
 using cricket::DF_PLAY;
 using cricket::DF_SEND;
 using cricket::FakeVoiceMediaChannel;
 using cricket::TransportInfo;
 using rtc::SocketAddress;
 using rtc::scoped_ptr;
 using rtc::Thread;
 using webrtc::CreateSessionDescription;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::CreateSessionDescriptionRequest;
 using webrtc::DtlsIdentityStoreInterface;
 using webrtc::FakeConstraints;
 using webrtc::FakeMetricsObserver;
 using webrtc::IceCandidateCollection;
 using webrtc::JsepIceCandidate;
 using webrtc::JsepSessionDescription;
 using webrtc::PeerConnectionFactoryInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::SessionDescriptionInterface;
+using webrtc::SessionStats;
 using webrtc::StreamCollection;
 using webrtc::WebRtcSession;
 using webrtc::kBundleWithoutRtcpMux;
 using webrtc::kCreateChannelFailed;
 using webrtc::kInvalidSdp;
 using webrtc::kMlineMismatch;
 using webrtc::kPushDownTDFailed;
 using webrtc::kSdpWithoutIceUfragPwd;
 using webrtc::kSdpWithoutDtlsFingerprint;
 using webrtc::kSdpWithoutSdesCrypto;
@@ skipping 650 matching lines @@
     SessionDescriptionInterface* offer = CreateRemoteOffer();
     SetRemoteDescriptionWithoutError(offer);
     SessionDescriptionInterface* answer = CreateAnswer(NULL);
     SetLocalDescriptionWithoutError(answer);
   }
   void SetLocalDescriptionWithoutError(SessionDescriptionInterface* desc) {
     EXPECT_TRUE(session_->SetLocalDescription(desc, NULL));
     session_->MaybeStartGathering();
   }
   void SetLocalDescriptionExpectState(SessionDescriptionInterface* desc,
-                                      BaseSession::State expected_state) {
+                                      WebRtcSession::State expected_state) {
     SetLocalDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
   }
   void SetLocalDescriptionExpectError(const std::string& action,
                                       const std::string& expected_error,
                                       SessionDescriptionInterface* desc) {
     std::string error;
     EXPECT_FALSE(session_->SetLocalDescription(desc, &error));
     std::string sdp_type = "local ";
     sdp_type.append(action);
     EXPECT_NE(std::string::npos, error.find(sdp_type));
     EXPECT_NE(std::string::npos, error.find(expected_error));
   }
   void SetLocalDescriptionOfferExpectError(const std::string& expected_error,
                                            SessionDescriptionInterface* desc) {
     SetLocalDescriptionExpectError(SessionDescriptionInterface::kOffer,
                                    expected_error, desc);
   }
   void SetLocalDescriptionAnswerExpectError(const std::string& expected_error,
                                             SessionDescriptionInterface* desc) {
     SetLocalDescriptionExpectError(SessionDescriptionInterface::kAnswer,
                                    expected_error, desc);
   }
   void SetRemoteDescriptionWithoutError(SessionDescriptionInterface* desc) {
     EXPECT_TRUE(session_->SetRemoteDescription(desc, NULL));
   }
   void SetRemoteDescriptionExpectState(SessionDescriptionInterface* desc,
-                                       BaseSession::State expected_state) {
+                                       WebRtcSession::State expected_state) {
     SetRemoteDescriptionWithoutError(desc);
     EXPECT_EQ(expected_state, session_->state());
   }
   void SetRemoteDescriptionExpectError(const std::string& action,
                                        const std::string& expected_error,
                                        SessionDescriptionInterface* desc) {
     std::string error;
     EXPECT_FALSE(session_->SetRemoteDescription(desc, &error));
     std::string sdp_type = "remote ";
     sdp_type.append(action);
@@ skipping 1027 matching lines @@
   SessionDescriptionInterface* offer2 = CreateOffer();
   SetRemoteDescriptionWithoutError(offer2);
 }
 
 TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteOffer) {
   Init();
   mediastream_signaling_.SendNothing();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
   offer = CreateOffer();
-  SetRemoteDescriptionOfferExpectError(
-      "Called in wrong state: STATE_SENTINITIATE", offer);
+  SetRemoteDescriptionOfferExpectError("Called in wrong state: STATE_SENTOFFER",
+                                       offer);
 }
 
 TEST_F(WebRtcSessionTest, TestSetRemoteAndLocalOffer) {
   Init();
   mediastream_signaling_.SendNothing();
   SessionDescriptionInterface* offer = CreateOffer();
   SetRemoteDescriptionWithoutError(offer);
   offer = CreateOffer();
   SetLocalDescriptionOfferExpectError(
-      "Called in wrong state: STATE_RECEIVEDINITIATE", offer);
+      "Called in wrong state: STATE_RECEIVEDOFFER", offer);
 }
 
 TEST_F(WebRtcSessionTest, TestSetLocalPrAnswer) {
   Init();
   mediastream_signaling_.SendNothing();
   SessionDescriptionInterface* offer = CreateRemoteOffer();
-  SetRemoteDescriptionExpectState(offer, BaseSession::STATE_RECEIVEDINITIATE);
+  SetRemoteDescriptionExpectState(offer, WebRtcSession::STATE_RECEIVEDOFFER);
 
   JsepSessionDescription* pranswer = static_cast<JsepSessionDescription*>(
       CreateAnswer(NULL));
   pranswer->set_type(SessionDescriptionInterface::kPrAnswer);
-  SetLocalDescriptionExpectState(pranswer, BaseSession::STATE_SENTPRACCEPT);
+  SetLocalDescriptionExpectState(pranswer, WebRtcSession::STATE_SENTPRANSWER);
 
   mediastream_signaling_.SendAudioVideoStream1();
   JsepSessionDescription* pranswer2 = static_cast<JsepSessionDescription*>(
       CreateAnswer(NULL));
   pranswer2->set_type(SessionDescriptionInterface::kPrAnswer);
 
-  SetLocalDescriptionExpectState(pranswer2, BaseSession::STATE_SENTPRACCEPT);
+  SetLocalDescriptionExpectState(pranswer2, WebRtcSession::STATE_SENTPRANSWER);
 
   mediastream_signaling_.SendAudioVideoStream2();
   SessionDescriptionInterface* answer = CreateAnswer(NULL);
-  SetLocalDescriptionExpectState(answer, BaseSession::STATE_SENTACCEPT);
+  SetLocalDescriptionExpectState(answer, WebRtcSession::STATE_INPROGRESS);
 }
 
 TEST_F(WebRtcSessionTest, TestSetRemotePrAnswer) {
   Init();
   mediastream_signaling_.SendNothing();
   SessionDescriptionInterface* offer = CreateOffer();
-  SetLocalDescriptionExpectState(offer, BaseSession::STATE_SENTINITIATE);
+  SetLocalDescriptionExpectState(offer, WebRtcSession::STATE_SENTOFFER);
 
   JsepSessionDescription* pranswer =
       CreateRemoteAnswer(session_->local_description());
   pranswer->set_type(SessionDescriptionInterface::kPrAnswer);
 
   SetRemoteDescriptionExpectState(pranswer,
-                                  BaseSession::STATE_RECEIVEDPRACCEPT);
+                                  WebRtcSession::STATE_RECEIVEDPRANSWER);
 
   mediastream_signaling_.SendAudioVideoStream1();
   JsepSessionDescription* pranswer2 =
       CreateRemoteAnswer(session_->local_description());
   pranswer2->set_type(SessionDescriptionInterface::kPrAnswer);
 
   SetRemoteDescriptionExpectState(pranswer2,
-                                  BaseSession::STATE_RECEIVEDPRACCEPT);
+                                  WebRtcSession::STATE_RECEIVEDPRANSWER);
 
   mediastream_signaling_.SendAudioVideoStream2();
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(session_->local_description());
-  SetRemoteDescriptionExpectState(answer, BaseSession::STATE_RECEIVEDACCEPT);
+  SetRemoteDescriptionExpectState(answer, WebRtcSession::STATE_INPROGRESS);
 }
 
 TEST_F(WebRtcSessionTest, TestSetLocalAnswerWithoutOffer) {
   Init();
   mediastream_signaling_.SendNothing();
   rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(offer.get());
   SetLocalDescriptionAnswerExpectError("Called in wrong state: STATE_INIT",
@@ skipping 12 matching lines @@
 }
 
 TEST_F(WebRtcSessionTest, TestAddRemoteCandidate) {
   Init();
   mediastream_signaling_.SendAudioVideoStream1();
 
   cricket::Candidate candidate;
   candidate.set_component(1);
   JsepIceCandidate ice_candidate1(kMediaContentName0, 0, candidate);
 
-  // Fail since we have not set a offer description.
+  // Fail since we have not set a remote description.
   EXPECT_FALSE(session_->ProcessIceMessage(&ice_candidate1));
 
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
-  // Candidate should be allowed to add before remote description.

[Taylor Brandstetter, 2015/10/09 23:02:07]

It's odd that this test says "candidate can be added before remote description".
Because even though it's added, as I explained earlier, it wasn't being pushed
down to the transports.

[pthatcher1, 2015/10/10 00:07:27]

It's weird that we explicitly expected this behavior before.  Can you send a
quick email to Justin and Harald to double-check that we don't want to support
this?  I just want to make sure we don't break something unwittingly.  

[Taylor Brandstetter, 2015/10/10 00:30:15]

Email sent; CC'd you.

+
+  // Fail since we have not set a remote description.
+  EXPECT_FALSE(session_->ProcessIceMessage(&ice_candidate1));
+
+  SessionDescriptionInterface* answer = CreateRemoteAnswer(
+      session_->local_description());
+  SetRemoteDescriptionWithoutError(answer);
+
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate1));
   candidate.set_component(2);
   JsepIceCandidate ice_candidate2(kMediaContentName0, 0, candidate);
   EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate2));
 
-  SessionDescriptionInterface* answer = CreateRemoteAnswer(
-      session_->local_description());
-  SetRemoteDescriptionWithoutError(answer);
-
   // Verifying the candidates are copied properly from internal vector.
   const SessionDescriptionInterface* remote_desc =
       session_->remote_description();
   ASSERT_TRUE(remote_desc != NULL);
   ASSERT_EQ(2u, remote_desc->number_of_mediasections());
   const IceCandidateCollection* candidates =
       remote_desc->candidates(kMediaContentIndex0);
   ASSERT_EQ(2u, candidates->count());
   EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
   EXPECT_EQ(kMediaContentName0, candidates->at(0)->sdp_mid());
@@ skipping 156 matching lines @@
 }
 
 // Verifies TransportProxy and media channels are created with content names
 // present in the SessionDescription.
 TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
   Init();
   mediastream_signaling_.SendAudioVideoStream1();
   rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer());
 
   // CreateOffer creates session description with the content names "audio" and
-  // "video". Goal is to modify these content names and verify transport channel
-  // proxy in the BaseSession, as proxies are created with the content names
+  // "video". Goal is to modify these content names and verify transport
+  // channels
+  // in the WebRtcSession, as channels are created with the content names
   // present in SDP.
   std::string sdp;
   EXPECT_TRUE(offer->ToString(&sdp));
   const std::string kAudioMid = "a=mid:audio";
   const std::string kAudioMidReplaceStr = "a=mid:audio_content_name";
   const std::string kVideoMid = "a=mid:video";
   const std::string kVideoMidReplaceStr = "a=mid:video_content_name";
 
   // Replacing |audio| with |audio_content_name|.
   rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
@@ skipping 559 matching lines @@
   sdp.clear();
   ModifyIceUfragPwdLines(offer.get(), "0123456789012444",
                          "abcdefghijklmnopqrstuvyz", &sdp);
   SessionDescriptionInterface* offer4 =
       CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
   SetRemoteDescriptionWithoutError(offer4);
   EXPECT_EQ(0, session_->remote_description()->candidates(0)->count());
 }
 
 // Test that candidates sent to the "video" transport do not get pushed down to
-// the "audio" transport channel when bundling using TransportProxy.
+// the "audio" transport channel when bundling.
 TEST_F(WebRtcSessionTest, TestIgnoreCandidatesForUnusedTransportWhenBundling) {
   AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
 
   InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
   mediastream_signaling_.SendAudioVideoStream1();
 
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.use_rtp_mux = true;
 
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
 
   SessionDescriptionInterface* answer = CreateAnswer(NULL);
   SetLocalDescriptionWithoutError(answer);
 
   EXPECT_EQ(session_->voice_rtp_transport_channel(),
             session_->video_rtp_transport_channel());
 
   cricket::BaseChannel* voice_channel = session_->voice_channel();
   ASSERT(voice_channel != NULL);
 
   // Checks if one of the transport channels contains a connection using a given
   // port.
   auto connection_with_remote_port = [this, voice_channel](int port) {
-    cricket::SessionStats stats;
+    SessionStats stats;
     session_->GetChannelTransportStats(voice_channel, &stats);
     for (auto& kv : stats.transport_stats) {
       for (auto& chan_stat : kv.second.channel_stats) {
         for (auto& conn_info : chan_stat.connection_infos) {
           if (conn_info.remote_candidate.address().port() == port) {
             return true;
           }
         }
       }
     }
@@ skipping 499 matching lines @@
   ASSERT_EQ(3U, channel->dtmf_info_queue().size());
   const uint32_t send_ssrc = channel->send_streams()[0].first_ssrc();
   EXPECT_TRUE(CompareDtmfInfo(channel->dtmf_info_queue()[0], send_ssrc, 0,
                               expected_duration, expected_flags));
   EXPECT_TRUE(CompareDtmfInfo(channel->dtmf_info_queue()[1], send_ssrc, 1,
                               expected_duration, expected_flags));
   EXPECT_TRUE(CompareDtmfInfo(channel->dtmf_info_queue()[2], send_ssrc, 2,
                               expected_duration, expected_flags));
 }
 
-// This test verifies the |initiator| flag when session initiates the call.
+// This test verifies the |initial_offerer| flag when session initiates the
+// call.
 TEST_F(WebRtcSessionTest, TestInitiatorFlagAsOriginator) {
   Init();
-  EXPECT_FALSE(session_->initiator());
+  EXPECT_FALSE(session_->initial_offerer());
   SessionDescriptionInterface* offer = CreateOffer();
   SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
   SetLocalDescriptionWithoutError(offer);
-  EXPECT_TRUE(session_->initiator());
+  EXPECT_TRUE(session_->initial_offerer());
   SetRemoteDescriptionWithoutError(answer);
-  EXPECT_TRUE(session_->initiator());
+  EXPECT_TRUE(session_->initial_offerer());
 }
 
-// This test verifies the |initiator| flag when session receives the call.
+// This test verifies the |initial_offerer| flag when session receives the call.
 TEST_F(WebRtcSessionTest, TestInitiatorFlagAsReceiver) {
   Init();
-  EXPECT_FALSE(session_->initiator());
+  EXPECT_FALSE(session_->initial_offerer());
   SessionDescriptionInterface* offer = CreateRemoteOffer();
   SetRemoteDescriptionWithoutError(offer);
   SessionDescriptionInterface* answer = CreateAnswer(NULL);
 
-  EXPECT_FALSE(session_->initiator());
+  EXPECT_FALSE(session_->initial_offerer());
   SetLocalDescriptionWithoutError(answer);
-  EXPECT_FALSE(session_->initiator());
+  EXPECT_FALSE(session_->initial_offerer());
 }
 
 // Verifing local offer and remote answer have matching m-lines as per RFC 3264.
 TEST_F(WebRtcSessionTest, TestIncorrectMLinesInRemoteAnswer) {
   Init();
   mediastream_signaling_.SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
   SetLocalDescriptionWithoutError(offer);
   rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateRemoteAnswer(session_->local_description()));
@@ skipping 191 matching lines @@
   Init();
   mediastream_signaling_.SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer();
   const std::string session_id_orig = offer->session_id();
   const std::string session_version_orig = offer->session_version();
   SetLocalDescriptionWithoutError(offer);
 
   video_channel_ = media_engine_->GetVideoChannel(0);
   video_channel_->set_fail_set_send_codecs(true);
 
-  mediastream_signaling_.SendAudioVideoStream2();
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(session_->local_description());
   SetRemoteDescriptionAnswerExpectError("ERROR_CONTENT", answer);
+
+  // Test that after a content error, setting any description will
+  // result in an error.
+  video_channel_->set_fail_set_send_codecs(false);
+  answer = CreateRemoteAnswer(session_->local_description());
+  SetRemoteDescriptionExpectError("", "ERROR_CONTENT", answer);
+  offer = CreateRemoteOffer();
+  SetLocalDescriptionExpectError("", "ERROR_CONTENT", offer);
 }
 
 // Runs the loopback call test with BUNDLE and STUN disabled.
 TEST_F(WebRtcSessionTest, TestIceStatesBasic) {
   // Lets try with only UDP ports.
   allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
                         cricket::PORTALLOCATOR_DISABLE_STUN |
                         cricket::PORTALLOCATOR_DISABLE_RELAY);
   TestLoopbackCall();
 }
@@ skipping 13 matching lines @@
   TestLoopbackCall(config);
 }
 
 // Runs the loopback call test with BUNDLE and STUN enabled.
 TEST_F(WebRtcSessionTest, TestIceStatesBundle) {
   allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
                         cricket::PORTALLOCATOR_DISABLE_RELAY);
   TestLoopbackCall();
 }
 
-TEST_F(WebRtcSessionTest, SetSdpFailedOnSessionError) {
-  Init();
-  cricket::MediaSessionOptions options;
-  options.recv_video = true;
-
-  cricket::BaseSession::Error error_code = cricket::BaseSession::ERROR_CONTENT;
-  std::string error_code_str = "ERROR_CONTENT";
-  std::string error_desc = "Fake session error description.";
-  session_->SetError(error_code, error_desc);
-
-  SessionDescriptionInterface* offer = CreateRemoteOffer(options);
-  SessionDescriptionInterface* answer =
-      CreateRemoteAnswer(offer, options);
-
-  std::string action;
-  std::ostringstream session_error_msg;
-  session_error_msg << kSessionError << error_code_str << ". ";
-  session_error_msg << kSessionErrorDesc << error_desc << ".";
-  SetRemoteDescriptionExpectError(action, session_error_msg.str(), offer);
-  SetLocalDescriptionExpectError(action, session_error_msg.str(), answer);
-}
-
 TEST_F(WebRtcSessionTest, TestRtpDataChannel) {
   constraints_.reset(new FakeConstraints());
   constraints_->AddOptional(
       webrtc::MediaConstraintsInterface::kEnableRtpDataChannels, true);
   Init();
 
   SetLocalDescriptionWithDataChannel();
   EXPECT_EQ(cricket::DCT_RTP, data_engine_->last_channel_type());
 }
 
@@ skipping 482 matching lines @@
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));