Revert of Use standard ICE in Chromoting.

remoting/protocol/libjingle_transport_factory.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/libjingle_transport_factory.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 39 matching lines @@
     return TransportRoute::DIRECT;
   }
 }
 
 class LibjingleTransport
     : public Transport,
       public base::SupportsWeakPtr<LibjingleTransport>,
       public sigslot::has_slots<> {
  public:
   LibjingleTransport(cricket::PortAllocator* port_allocator,
-                     const NetworkSettings& network_settings,
-                     TransportRole role);
+                     const NetworkSettings& network_settings);
   ~LibjingleTransport() override;
 
   // Called by JingleTransportFactory when it has fresh Jingle info.
   void OnCanStart();
 
   // Transport interface.
   void Connect(const std::string& name,
                Transport::EventHandler* event_handler,
                const Transport::ConnectedCallback& callback) override;
-  void SetRemoteCredentials(const std::string& ufrag,
-                            const std::string& password) override;
   void AddRemoteCandidate(const cricket::Candidate& candidate) override;
   const std::string& name() const override;
   bool is_connected() const override;
-  void SetUseStandardIce(bool use_standard_ice) override;
 
  private:
   void DoStart();
   void NotifyConnected();
 
   // Signal handlers for cricket::TransportChannel.
   void OnRequestSignaling(cricket::TransportChannelImpl* channel);
   void OnCandidateReady(cricket::TransportChannelImpl* channel,
                         const cricket::Candidate& candidate);
   void OnRouteChange(cricket::TransportChannel* channel,
                      const cricket::Candidate& candidate);
   void OnWritableState(cricket::TransportChannel* channel);
 
   // Callback for jingle_glue::TransportChannelSocketAdapter to notify when the
   // socket is destroyed.
   void OnChannelDestroyed();
 
   void NotifyRouteChanged();
 
   // Tries to connect by restarting ICE. Called by |reconnect_timer_|.
   void TryReconnect();
 
   cricket::PortAllocator* port_allocator_;
   NetworkSettings network_settings_;
-  TransportRole role_;
-
-  bool use_standard_ice_ = true;
 
   std::string name_;
   EventHandler* event_handler_;
   Transport::ConnectedCallback callback_;
   std::string ice_username_fragment_;
+  std::string ice_password_;
 
   bool can_start_;
 
-  std::string remote_ice_username_fragment_;
-  std::string remote_ice_password_;
   std::list<cricket::Candidate> pending_candidates_;
   scoped_ptr<cricket::P2PTransportChannel> channel_;
   int connect_attempts_left_;
   base::RepeatingTimer<LibjingleTransport> reconnect_timer_;
 
   base::WeakPtrFactory<LibjingleTransport> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LibjingleTransport);
 };
 
 LibjingleTransport::LibjingleTransport(cricket::PortAllocator* port_allocator,
-                                       const NetworkSettings& network_settings,
-                                       TransportRole role)
+                                       const NetworkSettings& network_settings)
     : port_allocator_(port_allocator),
       network_settings_(network_settings),
-      role_(role),
       event_handler_(nullptr),
       ice_username_fragment_(
           rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
+      ice_password_(rtc::CreateRandomString(cricket::ICE_PWD_LENGTH)),
       can_start_(false),
       connect_attempts_left_(kMaxReconnectAttempts),
       weak_factory_(this) {
   DCHECK(!ice_username_fragment_.empty());
+  DCHECK(!ice_password_.empty());
 }
 
 LibjingleTransport::~LibjingleTransport() {
   DCHECK(event_handler_);
 
   event_handler_->OnTransportDeleted(this);
 
   if (channel_.get()) {
     base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
         FROM_HERE, channel_.release());
   }
 }
 
 void LibjingleTransport::OnCanStart() {
   DCHECK(CalledOnValidThread());
 
   DCHECK(!can_start_);
   can_start_ = true;
 
   // If Connect() has been called then start connection.
   if (!callback_.is_null())
     DoStart();
 
-  // Pass pending ICE credentials and candidates to the channel.
-  if (!remote_ice_username_fragment_.empty()) {
-    channel_->SetRemoteIceCredentials(remote_ice_username_fragment_,
-                                      remote_ice_password_);
-  }
-
   while (!pending_candidates_.empty()) {
-    if (!use_standard_ice_) {
-      channel_->SetRemoteIceCredentials(pending_candidates_.front().username(),
-                                        pending_candidates_.front().password());
-    }
+    channel_->SetRemoteIceCredentials(pending_candidates_.front().username(),
+                                      pending_candidates_.front().password());
     channel_->OnCandidate(pending_candidates_.front());
     pending_candidates_.pop_front();
   }
 }
 
 void LibjingleTransport::Connect(
     const std::string& name,
     Transport::EventHandler* event_handler,
     const Transport::ConnectedCallback& callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 10 matching lines @@
     DoStart();
 }
 
 void LibjingleTransport::DoStart() {
   DCHECK(!channel_.get());
 
   // Create P2PTransportChannel, attach signal handlers and connect it.
   // TODO(sergeyu): Specify correct component ID for the channel.
   channel_.reset(new cricket::P2PTransportChannel(
       std::string(), 0, nullptr, port_allocator_));
-  std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
-  if (use_standard_ice_) {
-    channel_->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
-    channel_->SetIceRole((role_ == TransportRole::CLIENT)
-                             ? cricket::ICEROLE_CONTROLLING
-                             : cricket::ICEROLE_CONTROLLED);
-    event_handler_->OnTransportIceCredentials(this, ice_username_fragment_,
-                                              ice_password);
-  } else {
-    channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE);
-  }
-  channel_->SetIceCredentials(ice_username_fragment_, ice_password);
+  channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE);
+  channel_->SetIceCredentials(ice_username_fragment_, ice_password_);
   channel_->SignalRequestSignaling.connect(
       this, &LibjingleTransport::OnRequestSignaling);
   channel_->SignalCandidateReady.connect(
       this, &LibjingleTransport::OnCandidateReady);
   channel_->SignalRouteChange.connect(
       this, &LibjingleTransport::OnRouteChange);
   channel_->SignalWritableState.connect(
       this, &LibjingleTransport::OnWritableState);
   channel_->set_incoming_only(
       !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING));
@@ skipping 14 matching lines @@
 
 void LibjingleTransport::NotifyConnected() {
   // Create net::Socket adapter for the P2PTransportChannel.
   scoped_ptr<jingle_glue::TransportChannelSocketAdapter> socket(
       new jingle_glue::TransportChannelSocketAdapter(channel_.get()));
   socket->SetOnDestroyedCallback(base::Bind(
       &LibjingleTransport::OnChannelDestroyed, base::Unretained(this)));
   base::ResetAndReturn(&callback_).Run(socket.Pass());
 }
 
-void LibjingleTransport::SetRemoteCredentials(const std::string& ufrag,
-                                              const std::string& password) {
-  DCHECK(CalledOnValidThread());
-
-  remote_ice_username_fragment_ = ufrag;
-  remote_ice_password_ = password;
-
-  if (channel_)
-    channel_->SetRemoteIceCredentials(ufrag, password);
-}
-
 void LibjingleTransport::AddRemoteCandidate(
     const cricket::Candidate& candidate) {
   DCHECK(CalledOnValidThread());
 
   // To enforce the no-relay setting, it's not enough to not produce relay
   // candidates. It's also necessary to discard remote relay candidates.
   bool relay_allowed = (network_settings_.flags &
                         NetworkSettings::NAT_TRAVERSAL_RELAY) != 0;
   if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE)
     return;
 
   if (channel_) {
-    if (!use_standard_ice_) {
-      channel_->SetRemoteIceCredentials(candidate.username(),
-                                        candidate.password());
-    }
+    channel_->SetRemoteIceCredentials(candidate.username(),
+                                      candidate.password());
     channel_->OnCandidate(candidate);
   } else {
     pending_candidates_.push_back(candidate);
   }
 }
 
 const std::string& LibjingleTransport::name() const {
   DCHECK(CalledOnValidThread());
   return name_;
 }
 
 bool LibjingleTransport::is_connected() const {
   DCHECK(CalledOnValidThread());
   return callback_.is_null();
 }
 
-void LibjingleTransport::SetUseStandardIce(bool use_standard_ice) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!channel_);
-  use_standard_ice_ = use_standard_ice;
-}
-
 void LibjingleTransport::OnRequestSignaling(
     cricket::TransportChannelImpl* channel) {
   DCHECK(CalledOnValidThread());
   channel_->OnSignalingReady();
 }
 
 void LibjingleTransport::OnCandidateReady(
     cricket::TransportChannelImpl* channel,
     const cricket::Candidate& candidate) {
   DCHECK(CalledOnValidThread());
@@ skipping 71 matching lines @@
     reconnect_timer_.Stop();
 
     // Notify the caller that ICE connection has failed - normally that will
     // terminate Jingle connection (i.e. the transport will be destroyed).
     event_handler_->OnTransportFailed(this);
     return;
   }
   --connect_attempts_left_;
 
   // Restart ICE by resetting ICE password.
-  std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
-  event_handler_->OnTransportIceCredentials(this, ice_username_fragment_,
-                                            ice_password);
-  channel_->SetIceCredentials(ice_username_fragment_, ice_password);
+  ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
+  channel_->SetIceCredentials(ice_username_fragment_, ice_password_);
 }
 
 }  // namespace
 
 LibjingleTransportFactory::LibjingleTransportFactory(
     SignalStrategy* signal_strategy,
     scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator,
-    const NetworkSettings& network_settings,
-    TransportRole role)
+    const NetworkSettings& network_settings)
     : signal_strategy_(signal_strategy),
       port_allocator_(port_allocator.Pass()),
-      network_settings_(network_settings),
-      role_(role) {
+      network_settings_(network_settings) {
 }
 
 LibjingleTransportFactory::~LibjingleTransportFactory() {
   // This method may be called in response to a libjingle signal, so
   // libjingle objects must be deleted asynchronously.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       base::ThreadTaskRunnerHandle::Get();
   task_runner->DeleteSoon(FROM_HERE, port_allocator_.release());
 }
 
 void LibjingleTransportFactory::PrepareTokens() {
   EnsureFreshJingleInfo();
 }
 
 scoped_ptr<Transport> LibjingleTransportFactory::CreateTransport() {
   scoped_ptr<LibjingleTransport> result(
-      new LibjingleTransport(port_allocator_.get(), network_settings_, role_));
+      new LibjingleTransport(port_allocator_.get(), network_settings_));
 
   EnsureFreshJingleInfo();
 
   // If there is a pending |jingle_info_request_| delay starting the new
   // transport until the request is finished.
   if (jingle_info_request_) {
     on_jingle_info_callbacks_.push_back(
         base::Bind(&LibjingleTransport::OnCanStart,
                    result->AsWeakPtr()));
   } else {
@@ skipping 36 matching lines @@
     last_jingle_info_update_time_ = base::TimeTicks::Now();
 
   while (!on_jingle_info_callbacks_.empty()) {
     on_jingle_info_callbacks_.begin()->Run();
     on_jingle_info_callbacks_.pop_front();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting