TransportController refactoring

webrtc/p2p/base/transportcontroller.h

+/*
+ *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_
+#define WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/p2p/base/candidate.h"
+#include "webrtc/p2p/base/transport.h"
+
+namespace rtc {
+class Thread;
+}
+
+namespace cricket {
+
+class TransportController : public sigslot::has_slots<>,
+                            public rtc::MessageHandler {
+ public:
+  TransportController(rtc::Thread* signaling_thread,
+                      rtc::Thread* worker_thread,
+                      PortAllocator* port_allocator);
+
+  virtual ~TransportController();
+
+  rtc::Thread* signaling_thread() const { return signaling_thread_; }
+  rtc::Thread* worker_thread() const { return worker_thread_; }
+
+  PortAllocator* port_allocator() const { return port_allocator_; }
+  bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version);
+
+  void SetIceConnectionReceivingTimeout(int timeout_ms);
+  void SetIceRole(IceRole ice_role);
+  bool GetSslRole(rtc::SSLRole* role);
+
+  // Takes ownership of identity and passes it down to transports.
+  // Can only be called once.
+  bool SetIdentity(rtc::SSLIdentity* identity);
+  // Caller owns returned identity
+  bool GetIdentity(const std::string& transport_name,
+                   rtc::SSLIdentity** identity);
+  // Caller owns returned certificate
+  bool GetRemoteCertificate(const std::string& transport_name,
+                            rtc::SSLCertificate** cert);
+  bool SetLocalTransportDescription(const std::string& transport_name,
+                                    const TransportDescription& tdesc,
+                                    ContentAction action,
+                                    std::string* err);
+  bool SetRemoteTransportDescription(const std::string& transport_name,
+                                     const TransportDescription& tdesc,
+                                     ContentAction action,
+                                     std::string* err);
+  bool AddRemoteCandidates(const std::string& transport_name,
+                           const Candidates& candidates,
+                           std::string* err);
+  bool ReadyForRemoteCandidates(const std::string& transport_name);
+  bool GetStats(const std::string& transport_name, TransportStats* stats);
+
+  virtual TransportChannel* CreateTransportChannel_w(
+      const std::string& transport_name,
+      int component);
+  virtual void DestroyTransportChannel_w(const std::string& transport_name,
+                                         int component);
+
+  // All of these signals are fired on the signalling thread.
+  sigslot::signal1<IceConnectionState> SignalConnectionState;
+  sigslot::signal1<bool> SignalReceiving;
+  sigslot::signal1<IceGatheringState> SignalGatheringState;
+  // (transport_name, candidates)
+  sigslot::signal2<const std::string&, const Candidates&>
+      SignalCandidatesGathered;
+
+ protected:
+  virtual void OnMessage(rtc::Message* pmsg);
+
+  // protected and virtual so we can override it in unit tests.
+  virtual Transport* CreateTransport_w(const std::string& transport_name);
+
+  // for unit tests
+  const std::map<std::string, Transport*>& transports() { return transports_; }
+  Transport* GetTransport_w(const std::string& transport_name);
+
+ private:
+  Transport* GetOrCreateTransport_w(const std::string& transport_name);
+  void DestroyTransport_w(const std::string& transport_name);
+  void DestroyAllTransports_w();
+
+  bool SetSslMaxProtocolVersion_w(rtc::SSLProtocolVersion version);
+  void SetIceConnectionReceivingTimeout_w(int timeout_ms);
+  void SetIceRole_w(IceRole ice_role);
+  bool GetSslRole_w(rtc::SSLRole* role);
+  bool SetIdentity_w(rtc::SSLIdentity* identity);
+  bool GetIdentity_w(const std::string& transport_name,
+                     rtc::SSLIdentity** identity);
+  bool GetRemoteCertificate_w(const std::string& transport_name,
+                              rtc::SSLCertificate** cert);
+  bool SetLocalTransportDescription_w(const std::string& transport_name,
+                                      const TransportDescription& tdesc,
+                                      ContentAction action,
+                                      std::string* err);
+  bool SetRemoteTransportDescription_w(const std::string& transport_name,
+                                       const TransportDescription& tdesc,
+                                       ContentAction action,
+                                       std::string* err);
+  bool AddRemoteCandidates_w(const std::string& transport_name,
+                             const Candidates& candidates,
+                             std::string* err);
+  bool ReadyForRemoteCandidates_w(const std::string& transport_name);
+  bool GetStats_w(const std::string& transport_name, TransportStats* stats);
+
+  // Handlers for signals from Transport.
+  void OnTransportConnecting_w(Transport* transport);
+  void OnTransportWritableState_w(Transport* transport);
+  void OnTransportReceivingState_w(Transport* transport);
+  void OnTransportCompleted_w(Transport* transport);
+  void OnTransportFailed_w(Transport* transport);
+  void OnTransportGatheringState_w(Transport* transport);
+  void OnTransportCandidatesGathered_w(
+      Transport* transport,
+      const std::vector<Candidate>& candidates);
+  void OnTransportRoleConflict_w();
+
+  void UpdateAggregateStates_w();
+
+  rtc::Thread* const signaling_thread_ = nullptr;
+  rtc::Thread* const worker_thread_ = nullptr;
+  typedef std::map<std::string, Transport*> TransportMap;
+  TransportMap transports_;
+
+  PortAllocator* const port_allocator_ = nullptr;
+  rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_10;
+
+  // Aggregate state for Transports
+  IceConnectionState connection_state_ = kIceConnectionConnecting;
+  bool receiving_ = false;
+  IceGatheringState gathering_state_ = kIceGatheringNew;
+
+  // TODO(deadbeef): Move the field below down to the transports themselves
+
+  // Timeout value in milliseconds for which no ICE connection receives
+  // any packets
+  int ice_receiving_timeout_ms_ = -1;
+  IceRole ice_role_ = ICEROLE_CONTROLLING;
+  // Flag which will be set to true after the first role switch
+  bool ice_role_switch_ = false;
+  uint64 ice_tiebreaker_ = rtc::CreateRandomId64();
+  rtc::scoped_ptr<rtc::SSLIdentity> identity_;
+};
+
+}  // namespace cricket
+
+#endif  // WEBRTC_P2P_BASE_TRANSPORTCONTROLLER_H_