Remove remoting::protocol::Transport interface.

remoting/protocol/ice_transport_channel.cc

Index: remoting/protocol/ice_transport_channel.cc
diff --git a/remoting/protocol/libjingle_transport_factory.cc b/remoting/protocol/ice_transport_channel.cc
similarity index 51%
rename from remoting/protocol/libjingle_transport_factory.cc
rename to remoting/protocol/ice_transport_channel.cc
index 1adcf30c80203c506d75443a8bc526e3e125b23b..7e47bceaa65396cedbe70afc1f4913792ebd9b6d 100644
--- a/remoting/protocol/libjingle_transport_factory.cc
+++ b/remoting/protocol/ice_transport_channel.cc
@@ -1,8 +1,8 @@
-// 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>
 
@@ -10,12 +10,9 @@
 #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"
@@ -31,9 +28,6 @@ namespace {
 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(
@@ -50,80 +44,15 @@ TransportRoute::RouteType CandidateTypeToTransportRouteType(
   }
 }
 
-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;
-
-  // 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,
+}  // namespace
+
+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),
@@ -132,10 +61,10 @@ LibjingleTransport::LibjingleTransport(cricket::PortAllocator* port_allocator,
   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(
@@ -143,8 +72,8 @@ LibjingleTransport::~LibjingleTransport() {
   }
 }
 
-void LibjingleTransport::OnCanStart() {
-  DCHECK(CalledOnValidThread());
+void IceTransportChannel::OnCanStart() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK(!can_start_);
   can_start_ = true;
@@ -165,25 +94,24 @@ void LibjingleTransport::OnCanStart() {
   }
 }
 
-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.
@@ -195,17 +123,17 @@ void LibjingleTransport::DoStart() {
   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));
 
@@ -217,21 +145,21 @@ void LibjingleTransport::DoStart() {
   // 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;
@@ -240,9 +168,9 @@ void LibjingleTransport::SetRemoteCredentials(const std::string& ufrag,
     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.
@@ -258,24 +186,24 @@ void LibjingleTransport::AddRemoteCandidate(
   }
 }
 
-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.
@@ -283,14 +211,14 @@ void LibjingleTransport::OnRouteChange(
     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()) {
@@ -307,12 +235,12 @@ void LibjingleTransport::OnWritableState(cricket::TransportChannel* channel) {
   }
 }
 
-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());
@@ -342,10 +270,10 @@ void LibjingleTransport::NotifyRouteChanged() {
     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) {
@@ -353,100 +281,17 @@ void LibjingleTransport::TryReconnect() {
 
     // 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