Enable QUIC support in chromoting

remoting/protocol/jingle_session.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/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/channel_multiplexer.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/pseudotcp_channel_factory.h"
+#include "remoting/protocol/quic_channel_factory.h"
 #include "remoting/protocol/secure_channel_factory.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/stream_channel_factory.h"
 #include "remoting/signaling/iq_sender.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/p2p/base/candidate.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
@@ skipping 39 matching lines @@
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       event_handler_(nullptr),
       state_(INITIALIZING),
       error_(OK),
       weak_factory_(this) {
 }
 
 JingleSession::~JingleSession() {
   channel_multiplexer_.reset();
+  quic_channel_factory_.reset();
   STLDeleteContainerPointers(pending_requests_.begin(),
                              pending_requests_.end());
   STLDeleteContainerPointers(transport_info_requests_.begin(),
                              transport_info_requests_.end());
 
   DCHECK(channels_.empty());
 
   session_manager_->SessionDestroyed(this);
 }
 
@@ skipping 16 matching lines @@
 
   peer_jid_ = peer_jid;
   authenticator_ = authenticator.Pass();
 
   // Generate random session ID. There are usually not more than 1
   // concurrent session per host, so a random 64-bit integer provides
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Int64ToString(base::RandGenerator(kint64max));
 
+  quic_channel_factory_.reset(new QuicChannelFactory(session_id_, false));
+
   // Send session-initiate message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
                         session_id_);
   message.initiator = session_manager_->signal_strategy_->GetLocalJid();
-  message.description.reset(
-      new ContentDescription(session_manager_->protocol_config_->Clone(),
-                             authenticator_->GetNextMessage()));
+  message.description.reset(new ContentDescription(
+      session_manager_->protocol_config_->Clone(),
+      authenticator_->GetNextMessage(),
+      quic_channel_factory_->CreateSessionInitiateConfigMessage()));
   SendMessage(message);
 
   SetState(CONNECTING);
 }
 
 void JingleSession::InitializeIncomingConnection(
     const JingleMessage& initiate_message,
     scoped_ptr<Authenticator> authenticator) {
   DCHECK(CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
 
   peer_jid_ = initiate_message.from;
   authenticator_ = authenticator.Pass();
   session_id_ = initiate_message.sid;
 
   SetState(ACCEPTING);
 
   config_ =
       SessionConfig::SelectCommon(initiate_message.description->config(),
                                   session_manager_->protocol_config_.get());
   if (!config_) {
     LOG(WARNING) << "Rejecting connection from " << peer_jid_
                  << " because no compatible configuration has been found.";
     CloseInternal(INCOMPATIBLE_PROTOCOL);
+    return;
+  }
+
+  if (config_->is_using_quic()) {
+    quic_channel_factory_.reset(new QuicChannelFactory(session_id_, true));
+    if (!quic_channel_factory_->ProcessSessionInitiateConfigMessage(
+            initiate_message.description->quic_config_message())) {
+      CloseInternal(INCOMPATIBLE_PROTOCOL);
+    }
   }
 }
 
 void JingleSession::AcceptIncomingConnection(
     const JingleMessage& initiate_message) {
   DCHECK(config_);
 
   // Process the first authentication message.
   const buzz::XmlElement* first_auth_message =
       initiate_message.description->authenticator_message();
@@ skipping 19 matching lines @@
   }
 
   // Send the session-accept message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
   scoped_ptr<buzz::XmlElement> auth_message;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
     auth_message = authenticator_->GetNextMessage();
 
+  std::string quic_config;
+  if (config_->is_using_quic())
+    quic_config = quic_channel_factory_->CreateSessionAcceptConfigMessage();
   message.description.reset(
       new ContentDescription(CandidateSessionConfig::CreateFrom(*config_),
-                             auth_message.Pass()));
+                             auth_message.Pass(), quic_config));
   SendMessage(message);
 
   // Update state.
   SetState(CONNECTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     OnAuthenticated();
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
     if (authenticator_->started()) {
@@ skipping 19 matching lines @@
 
 StreamChannelFactory* JingleSession::GetMultiplexedChannelFactory() {
   DCHECK(CalledOnValidThread());
   if (!channel_multiplexer_.get()) {
     channel_multiplexer_.reset(
         new ChannelMultiplexer(GetTransportChannelFactory(), kMuxChannelName));
   }
   return channel_multiplexer_.get();
 }
 
+StreamChannelFactory* JingleSession::GetQuicChannelFactory() {
+  DCHECK(CalledOnValidThread());
+  return quic_channel_factory_.get();
+}
+
 void JingleSession::Close() {
   DCHECK(CalledOnValidThread());
 
   CloseInternal(OK);
 }
 
 void JingleSession::AddPendingRemoteTransportInfo(Transport* channel) {
   std::list<JingleMessage::IceCredentials>::iterator credentials =
       pending_remote_ice_credentials_.begin();
   while (credentials != pending_remote_ice_credentials_.end()) {
@@ skipping 234 matching lines @@
     DLOG(WARNING) << "Received session-accept without authentication message ";
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   if (!InitializeConfigFromDescription(message.description.get())) {
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
+  if (config_->is_using_quic()) {
+    if (!quic_channel_factory_->ProcessSessionAcceptConfigMessage(
+            message.description->quic_config_message())) {
+      CloseInternal(INCOMPATIBLE_PROTOCOL);
+      return;
+    }
+  } else {
+    quic_channel_factory_.reset();
+  }
+
   SetState(CONNECTED);
 
   DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
   authenticator_->ProcessMessage(auth_message, base::Bind(
       &JingleSession::ProcessAuthenticationStep,base::Unretained(this)));
 }
 
 void JingleSession::OnSessionInfo(const JingleMessage& message,
                                   const ReplyCallback& reply_callback) {
   if (!message.info.get() ||
@@ skipping 143 matching lines @@
         authenticator_->rejection_reason()));
   }
 }
 
 void JingleSession::OnAuthenticated() {
   pseudotcp_channel_factory_.reset(new PseudoTcpChannelFactory(this));
   secure_channel_factory_.reset(
       new SecureChannelFactory(pseudotcp_channel_factory_.get(),
                                authenticator_.get()));
 
+  if (quic_channel_factory_)
+    quic_channel_factory_->Start(this, authenticator_->GetAuthKey());
+
   SetState(AUTHENTICATED);
 }
 
 void JingleSession::CloseInternal(ErrorCode error) {
   DCHECK(CalledOnValidThread());
 
   if (is_session_active()) {
     // Send session-terminate message with the appropriate error code.
     JingleMessage::Reason reason;
     switch (error) {
@@ skipping 44 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting