Remove remoting::protocol::Transport interface.

remoting/protocol/ice_transport_channel.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2015 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 "remoting/protocol/ice_transport_channel.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
-#include "base/timer/timer.h"
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/protocol/channel_socket_adapter.h"
-#include "remoting/protocol/network_settings.h"
-#include "remoting/signaling/jingle_info_request.h"
 #include "third_party/webrtc/base/network.h"
 #include "third_party/webrtc/p2p/base/constants.h"
 #include "third_party/webrtc/p2p/base/p2ptransportchannel.h"
 #include "third_party/webrtc/p2p/base/port.h"
 #include "third_party/webrtc/p2p/client/httpportallocator.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Try connecting ICE twice with timeout of 15 seconds for each attempt.
 const int kMaxReconnectAttempts = 2;
 const int kReconnectDelaySeconds = 15;
 
-// Get fresh STUN/Relay configuration every hour.
-const int kJingleInfoUpdatePeriodSeconds = 3600;
-
 // Utility function to map a cricket::Candidate string type to a
 // TransportRoute::RouteType enum value.
 TransportRoute::RouteType CandidateTypeToTransportRouteType(
     const std::string& candidate_type) {
   if (candidate_type == "local") {
     return TransportRoute::DIRECT;
   } else if (candidate_type == "stun" || candidate_type == "prflx") {
     return TransportRoute::STUN;
   } else if (candidate_type == "relay") {
     return TransportRoute::RELAY;
   } else {
     LOG(FATAL) << "Unknown candidate type: " << candidate_type;
     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);
-  ~LibjingleTransport() override;
+}  // namespace
 
-  // 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;
-
- private:
-  void DoStart();
-  void NotifyConnected();
-
-  // Signal handlers for cricket::TransportChannel.
-  void OnCandidateGathered(cricket::TransportChannelImpl* channel,
-                           const cricket::Candidate& candidate);
-  void OnRouteChange(cricket::TransportChannel* channel,
-                     const cricket::Candidate& candidate);
-  void OnReceivingState(cricket::TransportChannel* channel);
-  void OnWritableState(cricket::TransportChannel* channel);
-
-  // Callback for 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_;
-
-  std::string name_;
-  EventHandler* event_handler_;
-  Transport::ConnectedCallback callback_;
-  std::string ice_username_fragment_;
-
-  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 reconnect_timer_;
-
-  base::WeakPtrFactory<LibjingleTransport> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(LibjingleTransport);
-};
-
-LibjingleTransport::LibjingleTransport(cricket::PortAllocator* port_allocator,
+IceTransportChannel::IceTransportChannel(cricket::PortAllocator* port_allocator,
                                        const NetworkSettings& network_settings,
                                        TransportRole role)
     : port_allocator_(port_allocator),
       network_settings_(network_settings),
       role_(role),
-      event_handler_(nullptr),
+      delegate_(nullptr),
       ice_username_fragment_(
           rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
       can_start_(false),
       connect_attempts_left_(kMaxReconnectAttempts),
       weak_factory_(this) {
   DCHECK(!ice_username_fragment_.empty());
 }
 
-LibjingleTransport::~LibjingleTransport() {
-  DCHECK(event_handler_);
+IceTransportChannel::~IceTransportChannel() {
+  DCHECK(delegate_);
 
-  event_handler_->OnTransportDeleted(this);
+  delegate_->OnTransportDeleted(this);
 
   if (channel_.get()) {
     base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
         FROM_HERE, channel_.release());
   }
 }
 
-void LibjingleTransport::OnCanStart() {
-  DCHECK(CalledOnValidThread());
+void IceTransportChannel::OnCanStart() {
+  DCHECK(thread_checker_.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()) {
     channel_->AddRemoteCandidate(pending_candidates_.front());
     pending_candidates_.pop_front();
   }
 }
 
-void LibjingleTransport::Connect(
-    const std::string& name,
-    Transport::EventHandler* event_handler,
-    const Transport::ConnectedCallback& callback) {
-  DCHECK(CalledOnValidThread());
+void IceTransportChannel::Connect(const std::string& name,
+                                  Delegate* delegate,
+                                  const ConnectedCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!name.empty());
-  DCHECK(event_handler);
+  DCHECK(delegate);
   DCHECK(!callback.is_null());
 
   DCHECK(name_.empty());
   name_ = name;
-  event_handler_ = event_handler;
+  delegate_ = delegate;
   callback_ = callback;
 
   if (can_start_)
     DoStart();
 }
 
-void LibjingleTransport::DoStart() {
+void IceTransportChannel::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);
   channel_->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
   channel_->SetIceRole((role_ == TransportRole::CLIENT)
                            ? cricket::ICEROLE_CONTROLLING
                            : cricket::ICEROLE_CONTROLLED);
-  event_handler_->OnTransportIceCredentials(this, ice_username_fragment_,
+  delegate_->OnTransportIceCredentials(this, ice_username_fragment_,
                                             ice_password);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password);
   channel_->SignalCandidateGathered.connect(
-      this, &LibjingleTransport::OnCandidateGathered);
+      this, &IceTransportChannel::OnCandidateGathered);
   channel_->SignalRouteChange.connect(
-      this, &LibjingleTransport::OnRouteChange);
+      this, &IceTransportChannel::OnRouteChange);
   channel_->SignalReceivingState.connect(
-      this, &LibjingleTransport::OnReceivingState);
+      this, &IceTransportChannel::OnReceivingState);
   channel_->SignalWritableState.connect(
-      this, &LibjingleTransport::OnWritableState);
+      this, &IceTransportChannel::OnWritableState);
   channel_->set_incoming_only(
       !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING));
 
   channel_->Connect();
   channel_->MaybeStartGathering();
 
   --connect_attempts_left_;
 
   // Start reconnection timer.
   reconnect_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds),
-      this, &LibjingleTransport::TryReconnect);
+      this, &IceTransportChannel::TryReconnect);
 }
 
-void LibjingleTransport::NotifyConnected() {
+void IceTransportChannel::NotifyConnected() {
   // Create P2PDatagramSocket adapter for the P2PTransportChannel.
   scoped_ptr<TransportChannelSocketAdapter> socket(
       new TransportChannelSocketAdapter(channel_.get()));
   socket->SetOnDestroyedCallback(base::Bind(
-      &LibjingleTransport::OnChannelDestroyed, base::Unretained(this)));
+      &IceTransportChannel::OnChannelDestroyed, base::Unretained(this)));
   base::ResetAndReturn(&callback_).Run(socket.Pass());
 }
 
-void LibjingleTransport::SetRemoteCredentials(const std::string& ufrag,
+void IceTransportChannel::SetRemoteCredentials(const std::string& ufrag,
                                               const std::string& password) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_ice_username_fragment_ = ufrag;
   remote_ice_password_ = password;
 
   if (channel_)
     channel_->SetRemoteIceCredentials(ufrag, password);
 }
 
-void LibjingleTransport::AddRemoteCandidate(
+void IceTransportChannel::AddRemoteCandidate(
     const cricket::Candidate& candidate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(thread_checker_.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_) {
     channel_->AddRemoteCandidate(candidate);
   } else {
     pending_candidates_.push_back(candidate);
   }
 }
 
-const std::string& LibjingleTransport::name() const {
-  DCHECK(CalledOnValidThread());
+const std::string& IceTransportChannel::name() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   return name_;
 }
 
-bool LibjingleTransport::is_connected() const {
-  DCHECK(CalledOnValidThread());
+bool IceTransportChannel::is_connected() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   return callback_.is_null();
 }
 
-void LibjingleTransport::OnCandidateGathered(
+void IceTransportChannel::OnCandidateGathered(
     cricket::TransportChannelImpl* channel,
     const cricket::Candidate& candidate) {
-  DCHECK(CalledOnValidThread());
-  event_handler_->OnTransportCandidate(this, candidate);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  delegate_->OnTransportCandidate(this, candidate);
 }
 
-void LibjingleTransport::OnRouteChange(
+void IceTransportChannel::OnRouteChange(
     cricket::TransportChannel* channel,
     const cricket::Candidate& candidate) {
   // Ignore notifications if the channel is not writable.
   if (channel_->writable())
     NotifyRouteChanged();
 }
 
-void LibjingleTransport::OnReceivingState(cricket::TransportChannel* channel) {
+void IceTransportChannel::OnReceivingState(cricket::TransportChannel* channel) {
   DCHECK_EQ(channel, static_cast<cricket::TransportChannel*>(channel_.get()));
 
   if (channel->receiving() && !callback_.is_null())
     NotifyConnected();
 }
 
-void LibjingleTransport::OnWritableState(cricket::TransportChannel* channel) {
+void IceTransportChannel::OnWritableState(cricket::TransportChannel* channel) {
   DCHECK_EQ(channel, static_cast<cricket::TransportChannel*>(channel_.get()));
 
   if (channel->writable()) {
     connect_attempts_left_ = kMaxReconnectAttempts;
     reconnect_timer_.Stop();
 
     // Route change notifications are ignored when the |channel_| is not
     // writable. Notify the event handler about the current route once the
     // channel is writable.
     NotifyRouteChanged();
   } else {
     reconnect_timer_.Reset();
     TryReconnect();
   }
 }
 
-void LibjingleTransport::OnChannelDestroyed() {
+void IceTransportChannel::OnChannelDestroyed() {
   // The connection socket is being deleted, so delete the transport too.
   delete this;
 }
 
-void LibjingleTransport::NotifyRouteChanged() {
+void IceTransportChannel::NotifyRouteChanged() {
   TransportRoute route;
 
   DCHECK(channel_->best_connection());
   const cricket::Connection* connection = channel_->best_connection();
 
   // A connection has both a local and a remote candidate. For our purposes, the
   // route type is determined by the most indirect candidate type. For example:
   // it's possible for the local candidate be a "relay" type, while the remote
   // candidate is "local". In this case, we still want to report a RELAY route
   // type.
   static_assert(TransportRoute::DIRECT < TransportRoute::STUN &&
                 TransportRoute::STUN < TransportRoute::RELAY,
                 "Route type enum values are ordered by 'indirectness'");
   route.type = std::max(
       CandidateTypeToTransportRouteType(connection->local_candidate().type()),
       CandidateTypeToTransportRouteType(connection->remote_candidate().type()));
 
   if (!jingle_glue::SocketAddressToIPEndPoint(
           connection->remote_candidate().address(), &route.remote_address)) {
     LOG(FATAL) << "Failed to convert peer IP address.";
   }
 
   const cricket::Candidate& local_candidate =
       channel_->best_connection()->local_candidate();
   if (!jingle_glue::SocketAddressToIPEndPoint(
           local_candidate.address(), &route.local_address)) {
     LOG(FATAL) << "Failed to convert local IP address.";
   }
 
-  event_handler_->OnTransportRouteChange(this, route);
+  delegate_->OnTransportRouteChange(this, route);
 }
 
-void LibjingleTransport::TryReconnect() {
+void IceTransportChannel::TryReconnect() {
   DCHECK(!channel_->writable());
 
   if (connect_attempts_left_ <= 0) {
     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);
+    delegate_->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_,
+  delegate_->OnTransportIceCredentials(this, ice_username_fragment_,
                                             ice_password);
   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)
-    : signal_strategy_(signal_strategy),
-      port_allocator_(port_allocator.Pass()),
-      network_settings_(network_settings),
-      role_(role) {
-}
-
-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_));
-
-  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 {
-    result->OnCanStart();
-  }
-
-  return result.Pass();
-}
-
-void LibjingleTransportFactory::EnsureFreshJingleInfo() {
-  uint32 stun_or_relay_flags = NetworkSettings::NAT_TRAVERSAL_STUN |
-      NetworkSettings::NAT_TRAVERSAL_RELAY;
-  if (!(network_settings_.flags & stun_or_relay_flags) ||
-      jingle_info_request_) {
-    return;
-  }
-
-  if (last_jingle_info_update_time_.is_null() ||
-      base::TimeTicks::Now() - last_jingle_info_update_time_ >
-          base::TimeDelta::FromSeconds(kJingleInfoUpdatePeriodSeconds)) {
-    jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
-    jingle_info_request_->Send(base::Bind(
-        &LibjingleTransportFactory::OnJingleInfo, base::Unretained(this)));
-  }
-}
-
-void LibjingleTransportFactory::OnJingleInfo(
-    const std::string& relay_token,
-    const std::vector<std::string>& relay_hosts,
-    const std::vector<rtc::SocketAddress>& stun_hosts) {
-  if (!relay_token.empty() && !relay_hosts.empty()) {
-    port_allocator_->SetRelayHosts(relay_hosts);
-    port_allocator_->SetRelayToken(relay_token);
-  }
-  if (!stun_hosts.empty()) {
-    port_allocator_->SetStunHosts(stun_hosts);
-  }
-
-  jingle_info_request_.reset();
-  if ((!relay_token.empty() && !relay_hosts.empty()) || !stun_hosts.empty())
-    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