Remove QUIC support from remoting host and client.

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/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/jingle_session_manager.h"
-#include "remoting/protocol/quic_channel_factory.h"
 #include "remoting/protocol/session_config.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 {
 namespace protocol {
 
@@ skipping 28 matching lines @@
 
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       event_handler_(nullptr),
       state_(INITIALIZING),
       error_(OK),
       weak_factory_(this) {
 }
 
 JingleSession::~JingleSession() {
-  quic_channel_factory_.reset();
   transport_.reset();
 
   STLDeleteContainerPointers(pending_requests_.begin(),
                              pending_requests_.end());
   STLDeleteContainerPointers(transport_info_requests_.begin(),
                              transport_info_requests_.end());
 
   session_manager_->SessionDestroyed(this);
 }
 
@@ skipping 17 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::Uint64ToString(base::RandGenerator(kuint64max));
 
   transport_ = session_manager_->transport_factory_->CreateTransport();
-  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(),
-      quic_channel_factory_->CreateSessionInitiateConfigMessage()));
+      authenticator_->GetNextMessage()));
   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.";
     Close(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())) {
-      Close(INCOMPATIBLE_PROTOCOL);
-    }
-  }
-
   transport_ = session_manager_->transport_factory_->CreateTransport();
 }
 
 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 18 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(), quic_config));
+  message.description.reset(new ContentDescription(
+      CandidateSessionConfig::CreateFrom(*config_), auth_message.Pass()));
   SendMessage(message);
 
   // Update state.
   SetState(ACCEPTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     OnAuthenticated();
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
     if (authenticator_->started()) {
@@ skipping 10 matching lines @@
 const SessionConfig& JingleSession::config() {
   DCHECK(CalledOnValidThread());
   return *config_;
 }
 
 Transport* JingleSession::GetTransport() {
   DCHECK(CalledOnValidThread());
   return transport_.get();
 }
 
-StreamChannelFactory* JingleSession::GetQuicChannelFactory() {
-  DCHECK(CalledOnValidThread());
-  return quic_channel_factory_.get();
-}
-
 void JingleSession::Close(protocol::ErrorCode error) {
   DCHECK(CalledOnValidThread());
 
   transport_.reset();
 
   if (is_session_active()) {
     // Send session-terminate message with the appropriate error code.
     JingleMessage::Reason reason;
     switch (error) {
       case OK:
@@ skipping 214 matching lines @@
     DLOG(WARNING) << "Received session-accept without authentication message ";
     Close(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   if (!InitializeConfigFromDescription(message.description.get())) {
     Close(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
-  if (config_->is_using_quic()) {
-    if (!quic_channel_factory_->ProcessSessionAcceptConfigMessage(
-            message.description->quic_config_message())) {
-      Close(INCOMPATIBLE_PROTOCOL);
-      return;
-    }
-  } else {
-    quic_channel_factory_.reset();
-  }
-
   SetState(ACCEPTED);
 
   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 118 matching lines @@
     OnAuthenticated();
   } else if (authenticator_->state() == Authenticator::REJECTED) {
     Close(AuthRejectionReasonToErrorCode(
         authenticator_->rejection_reason()));
   }
 }
 
 void JingleSession::OnAuthenticated() {
   transport_->Start(this, authenticator_.get());
 
-  if (quic_channel_factory_) {
-    quic_channel_factory_->Start(transport_->GetDatagramChannelFactory(),
-                                 authenticator_->GetAuthKey());
-  }
-
   SetState(AUTHENTICATED);
 }
 
 void JingleSession::SetState(State new_state) {
   DCHECK(CalledOnValidThread());
 
   if (new_state != state_) {
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (event_handler_)
       event_handler_->OnSessionStateChange(new_state);
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == ACCEPTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting