Add TransportContext class.

remoting/protocol/ice_transport_channel.h

 // 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.
 
 #ifndef REMOTING_PROTOCOL_ICE_TRANSPORT_CHANNEL_H_
 #define REMOTING_PROTOCOL_ICE_TRANSPORT_CHANNEL_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/transport.h"
 #include "third_party/webrtc/base/sigslot.h"
 
 namespace cricket {
 class Candidate;
 class P2PTransportChannel;
 class PortAllocator;
 class TransportChannel;
 class TransportChannelImpl;
 }  // namespace cricket
 
 namespace remoting {
 namespace protocol {
 
+class TransportContext;
+
 class IceTransportChannel : public sigslot::has_slots<> {
  public:
   class Delegate {
    public:
     Delegate() {};
     virtual ~Delegate() {};
 
     // Called to pass ICE credentials to the session. Used only for STANDARD
     // version of ICE, see SetIceVersion().
     virtual void OnTransportIceCredentials(IceTransportChannel* transport,
@@ skipping 13 matching lines @@
 
     // Called when when the transport has failed to connect or reconnect.
     virtual void OnTransportFailed(IceTransportChannel* transport) = 0;
 
     // Called when the transport is about to be deleted.
     virtual void OnTransportDeleted(IceTransportChannel* transport) = 0;
   };
 
   typedef base::Callback<void(scoped_ptr<P2PDatagramSocket>)> ConnectedCallback;
 
-  IceTransportChannel(cricket::PortAllocator* port_allocator,
-                      const NetworkSettings& network_settings,
-                      TransportRole role);
+  explicit IceTransportChannel(
+      scoped_refptr<TransportContext> transport_context);
   ~IceTransportChannel() override;
 
-  // Called by IceTransport when it has fresh Jingle info.
-  void OnCanStart();
-
   // Connects the channel and calls the |callback| after that.
   void Connect(const std::string& name,
                Delegate* delegate,
                const ConnectedCallback& callback);
 
   // Sets remote ICE credentials.
   void SetRemoteCredentials(const std::string& ufrag,
                             const std::string& password);
 
   // Adds |candidate| received from the peer.
   void AddRemoteCandidate(const cricket::Candidate& candidate);
 
   // Name of the channel. Used to identify the channel and disambiguate
   // candidates it generates from candidates generated by parallel connections.
   const std::string& name() const;
 
   // Returns true if the channel is already connected.
   bool is_connected() const;
 
  private:
-  void DoStart();
+  void OnPortAllocatorCreated(
+      scoped_ptr<cricket::PortAllocator> port_allocator);
+
   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_;
+  scoped_refptr<TransportContext> transport_context_;
 
   std::string name_;
-  Delegate* delegate_;
+  Delegate* delegate_ = nullptr;
   ConnectedCallback callback_;
   std::string ice_username_fragment_;
 
-  bool can_start_;
+  scoped_ptr<cricket::PortAllocator> port_allocator_;
 
   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::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<IceTransportChannel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IceTransportChannel);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_ICE_TRANSPORT_CHANNEL_H_