Revert change which removes GICE

talk/app/webrtc/peerconnectionendtoend_unittest.cc

 /*
  * libjingle
  * Copyright 2013 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 30 matching lines @@
   }
 
 using webrtc::DataChannelInterface;
 using webrtc::FakeConstraints;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
 
 namespace {
 
+const char kExternalGiceUfrag[] = "1234567890123456";
+const char kExternalGicePwd[] = "123456789012345678901234";
 const size_t kMaxWait = 10000;
 
 void RemoveLinesFromSdp(const std::string& line_start,
                                std::string* sdp) {
   const char kSdpLineEnd[] = "\r\n";
   size_t ssrc_pos = 0;
   while ((ssrc_pos = sdp->find(line_start, ssrc_pos)) !=
       std::string::npos) {
     size_t end_ssrc = sdp->find(kSdpLineEnd, ssrc_pos);
     sdp->erase(ssrc_pos, end_ssrc - ssrc_pos + strlen(kSdpLineEnd));
@@ skipping 28 matching lines @@
       "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
       "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj\r\n";
   const char kDataSdes[] =
       "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
       "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj\r\n";
   InjectAfter("a=mid:audio\r\n", kAudioSdes, sdp);
   InjectAfter("a=mid:video\r\n", kVideoSdes, sdp);
   InjectAfter("a=mid:data\r\n", kDataSdes, sdp);
 }
 
+void UseGice(std::string* sdp) {
+  InjectAfter("t=0 0\r\n", "a=ice-options:google-ice\r\n", sdp);
+
+  std::string ufragline = "a=ice-ufrag:";
+  std::string pwdline = "a=ice-pwd:";
+  RemoveLinesFromSdp(ufragline, sdp);
+  RemoveLinesFromSdp(pwdline, sdp);
+  ufragline.append(kExternalGiceUfrag);
+  ufragline.append("\r\n");
+  pwdline.append(kExternalGicePwd);
+  pwdline.append("\r\n");
+  const std::string ufrag_pwd = ufragline + pwdline;
+
+  InjectAfter("a=mid:audio\r\n", ufrag_pwd, sdp);
+  InjectAfter("a=mid:video\r\n", ufrag_pwd, sdp);
+  InjectAfter("a=mid:data\r\n", ufrag_pwd, sdp);
+}
+
 void RemoveBundle(std::string* sdp) {
   RemoveLinesFromSdp("a=group:BUNDLE", sdp);
 }
 
 }  // namespace
 
 class PeerConnectionEndToEndTest
     : public sigslot::has_slots<>,
       public testing::Test {
  public:
@@ skipping 43 matching lines @@
   void WaitForCallEstablished() {
     caller_->WaitForCallEstablished();
     callee_->WaitForCallEstablished();
   }
 
   void WaitForConnection() {
     caller_->WaitForConnection();
     callee_->WaitForConnection();
   }
 
+  void SetupLegacySdpConverter() {
+    caller_->SignalOnSdpCreated.connect(
+      this, &PeerConnectionEndToEndTest::ConvertToLegacySdp);
+    callee_->SignalOnSdpCreated.connect(
+      this, &PeerConnectionEndToEndTest::ConvertToLegacySdp);
+  }
+
+  void ConvertToLegacySdp(std::string* sdp) {
+    UseExternalSdes(sdp);
+    UseGice(sdp);
+    RemoveBundle(sdp);
+    LOG(LS_INFO) << "ConvertToLegacySdp: " << *sdp;
+  }
+
+  void SetupGiceConverter() {
+    caller_->SignalOnIceCandidateCreated.connect(
+      this, &PeerConnectionEndToEndTest::AddGiceCredsToCandidate);
+    callee_->SignalOnIceCandidateCreated.connect(
+      this, &PeerConnectionEndToEndTest::AddGiceCredsToCandidate);
+  }
+
+  void AddGiceCredsToCandidate(std::string* sdp) {
+    std::string gice_creds = " username ";
+    gice_creds.append(kExternalGiceUfrag);
+    gice_creds.append(" password ");
+    gice_creds.append(kExternalGicePwd);
+    gice_creds.append("\r\n");
+    Replace("\r\n", gice_creds, sdp);
+    LOG(LS_INFO) << "AddGiceCredsToCandidate: " << *sdp;
+  }
+
   void OnCallerAddedDataChanel(DataChannelInterface* dc) {
     caller_signaled_data_channels_.push_back(dc);
   }
 
   void OnCalleeAddedDataChannel(DataChannelInterface* dc) {
     callee_signaled_data_channels_.push_back(dc);
   }
 
   // Tests that |dc1| and |dc2| can send to and receive from each other.
   void TestDataChannelSendAndReceive(
@@ skipping 51 matching lines @@
   Negotiate();
   WaitForCallEstablished();
 }
 
 // Disabled per b/14899892
 TEST_F(PeerConnectionEndToEndTest, DISABLED_CallWithLegacySdp) {
   FakeConstraints pc_constraints;
   pc_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                               false);
   CreatePcs(&pc_constraints);
+  SetupLegacySdpConverter();
+  SetupGiceConverter();
   GetAndAddUserMedia();
   Negotiate();
   WaitForCallEstablished();
 }
 
 // Verifies that a DataChannel created before the negotiation can transition to
 // "OPEN" and transfer data.
 TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
@@ skipping 114 matching lines @@
 
   caller_dc_1->Send(webrtc::DataBuffer(message_1));
   EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait);
 
   caller_dc_2->Send(webrtc::DataBuffer(message_2));
   EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait);
 
   EXPECT_EQ(1U, dc_1_observer->received_message_count());
   EXPECT_EQ(1U, dc_2_observer->received_message_count());
 }