Use standard ICE in Chromoting.

remoting/protocol/jingle_session_unittest.cc

 // Copyright (c) 2012 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 "remoting/protocol/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 87 matching lines @@
     message_loop_.reset(new base::MessageLoopForIO());
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   }
 
   // Helper method that handles OnIncomingSession().
   void SetHostSession(Session* session) {
     DCHECK(session);
     host_session_.reset(session);
     host_session_->SetEventHandler(&host_session_event_handler_);
 
-    session->set_config(SessionConfig::ForTest());
+    session->set_config(standard_ice_ ? SessionConfig::ForTest()
+                                      : SessionConfig::WithLegacyIceForTest());
   }
 
   void DeleteSession() {
     host_session_.reset();
   }
 
   void OnClientChannelCreated(scoped_ptr<net::StreamSocket> socket) {
     client_channel_callback_.OnDone(socket.get());
     client_socket_ = socket.Pass();
   }
@@ skipping 27 matching lines @@
                                 client_signal_strategy_.get());
 
     EXPECT_CALL(host_server_listener_, OnSessionManagerReady())
         .Times(1);
 
     NetworkSettings network_settings(NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     scoped_ptr<TransportFactory> host_transport(new LibjingleTransportFactory(
         nullptr,
         ChromiumPortAllocator::Create(nullptr, network_settings).Pass(),
-        network_settings));
+        network_settings, TransportRole::SERVER));
     host_server_.reset(new JingleSessionManager(host_transport.Pass()));
     host_server_->Init(host_signal_strategy_.get(), &host_server_listener_);
 
     scoped_ptr<AuthenticatorFactory> factory(
         new FakeHostAuthenticatorFactory(auth_round_trips,
           messages_till_start, auth_action, true));
     host_server_->set_authenticator_factory(factory.Pass());
 
     EXPECT_CALL(client_server_listener_, OnSessionManagerReady())
         .Times(1);
     scoped_ptr<TransportFactory> client_transport(new LibjingleTransportFactory(
         nullptr,
         ChromiumPortAllocator::Create(nullptr, network_settings).Pass(),
-        network_settings));
+        network_settings, TransportRole::CLIENT));
     client_server_.reset(
         new JingleSessionManager(client_transport.Pass()));
     client_server_->Init(client_signal_strategy_.get(),
                          &client_server_listener_);
   }
 
   void CreateSessionManagers(int auth_round_trips,
                              FakeAuthenticator::Action auth_action) {
     CreateSessionManagers(auth_round_trips, 0, auth_action);
   }
@@ skipping 102 matching lines @@
     EXPECT_CALL(host_session_event_handler_,
                 OnSessionRouteChange(channel_name, _))
         .Times(AtLeast(1));
     EXPECT_CALL(client_session_event_handler_,
                 OnSessionRouteChange(channel_name, _))
         .Times(AtLeast(1));
   }
 
   scoped_ptr<base::MessageLoopForIO> message_loop_;
 
+  bool standard_ice_ = true;
+
   scoped_ptr<FakeSignalStrategy> host_signal_strategy_;
   scoped_ptr<FakeSignalStrategy> client_signal_strategy_;
 
   scoped_ptr<JingleSessionManager> host_server_;
   MockSessionManagerListener host_server_listener_;
   scoped_ptr<JingleSessionManager> client_server_;
   MockSessionManagerListener client_server_listener_;
 
   scoped_ptr<Session> host_session_;
   MockSessionEventHandler host_session_event_handler_;
@@ skipping 42 matching lines @@
 // Verify that we can connect two endpoints with single-step authentication.
 TEST_F(JingleSessionTest, Connect) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
 
   // Verify that the client specified correct initiator value.
   ASSERT_GT(host_signal_strategy_->received_messages().size(), 0U);
   const buzz::XmlElement* initiate_xml =
       host_signal_strategy_->received_messages().front();
   const buzz::XmlElement* jingle_element =
-      initiate_xml->FirstNamed(buzz::QName(kJingleNamespace, "jingle"));
+      initiate_xml->FirstNamed(buzz::QName("urn:xmpp:jingle:1", "jingle"));
   ASSERT_TRUE(jingle_element);
   ASSERT_EQ(kClientJid,
             jingle_element->Attr(buzz::QName(std::string(), "initiator")));
 }
 
 // Verify that we can connect two endpoints with multi-step authentication.
 TEST_F(JingleSessionTest, ConnectWithMultistep) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
   InitiateConnection(3, FakeAuthenticator::ACCEPT, false);
 }
@@ skipping 18 matching lines @@
 
   ASSERT_NO_FATAL_FAILURE(CreateChannel());
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
+// Verify that we can still connect using legacy GICE transport.
+TEST_F(JingleSessionTest, TestLegacyIceConnection) {
+  standard_ice_ = false;
+
+  CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
+  ASSERT_NO_FATAL_FAILURE(
+      InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
+
+  ASSERT_NO_FATAL_FAILURE(CreateChannel());
+
+  StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
+                                kMessageSize, kMessages);
+  tester.Start();
+  message_loop_->Run();
+  tester.CheckResults();
+}
+
 TEST_F(JingleSessionTest, DeleteSessionOnIncomingConnection) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(DoAll(
           WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
           SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::CONNECTED))
@@ skipping 142 matching lines @@
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, 1);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
 }  // namespace protocol
 }  // namespace remoting