Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/p2p/base/dtlstransportinternal.h

+/*
+ *  Copyright 2016 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_DTLSTRANSPORTINTERNAL_H_
+#define WEBRTC_P2P_BASE_DTLSTRANSPORTINTERNAL_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/p2p/base/transportchannelimpl.h"
+#include "webrtc/p2p/base/jseptransport.h"
+#include "webrtc/p2p/base/packettransportinterface.h"
+
+namespace cricket {
+
+// DtlsTransportInternal is an internal interface that does DTLS.
+// Once the public interface is supported,
+// (https://www.w3.org/TR/webrtc/#rtcdtlstransport-interface)
+// the DtlsTransportInterface will be split from this class.
+class DtlsTransportInternal : public rtc::PacketTransportInterface {
+ public:
+  DtlsTransportInternal() {}

[Taylor Brandstetter, 2017/01/03 23:21:59]

nit: I was wrong about the destructor earlier, but I don't think the empty
constructor is needed.

[Zhi Huang, 2017/01/10 18:30:51]

It doesn't compile without it.

I think the macro I add, "RTC_DISALLOW_COPY_AND_ASSIGN", will delete the default
constructor of this class. But I'm not sure. I can make it protected like this
https://cs.chromium.org/chromium/src/third_party/webrtc/base/messagehandler.h...

[Taylor Brandstetter, 2017/01/10 19:43:47]

Does using "RTC_DISALLOW_IMPLICIT_CONSTRUCTORS" instead work?

[Zhi Huang, 2017/01/12 20:04:12]

This macro will declare the default constructor to be deleted constructor. It
doesn't work when constructing the subclasses. The error will be: "error: call
to deleted constructor of 'cricket::DtlsTransportInternal'"

+  virtual ~DtlsTransportInternal() {}
+
+  virtual DtlsTransportState dtls_state() const = 0;
+
+  virtual const std::string& transport_name() const = 0;
+
+  virtual int component() const = 0;
+
+  virtual bool IsDtlsActive() const = 0;
+
+  virtual bool GetSslRole(rtc::SSLRole* role) const = 0;
+
+  virtual bool SetSslRole(rtc::SSLRole role) = 0;
+
+  // Sets up the ciphers to use for DTLS-SRTP.
+  virtual bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) = 0;
+
+  // Keep the original one for backward compatibility until all dependencies
+  // move away. TODO(zhihuang): Remove this function.
+  virtual bool SetSrtpCiphers(const std::vector<std::string>& ciphers) = 0;
+
+  // Finds out which DTLS-SRTP cipher was negotiated.
+  // TODO(zhihuang): Remove this once all dependencies implement this.
+  virtual bool GetSrtpCryptoSuite(int* cipher) = 0;
+
+  // Finds out which DTLS cipher was negotiated.
+  // TODO(zhihuang): Remove this once all dependencies implement this.
+  virtual bool GetSslCipherSuite(int* cipher) = 0;
+
+  // Gets the local RTCCertificate used for DTLS.
+  virtual rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate()
+      const = 0;
+
+  virtual bool SetLocalCertificate(
+      const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) = 0;
+
+  // Gets a copy of the remote side's SSL certificate.
+  virtual std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+      const = 0;
+
+  // Allows key material to be extracted for external encryption.
+  virtual bool ExportKeyingMaterial(const std::string& label,
+                                    const uint8_t* context,
+                                    size_t context_len,
+                                    bool use_context,
+                                    uint8_t* result,
+                                    size_t result_len) = 0;
+
+  // Set DTLS remote fingerprint. Must be after local identity set.
+  virtual bool SetRemoteFingerprint(const std::string& digest_alg,
+                                    const uint8_t* digest,
+                                    size_t digest_len) = 0;
+
+  // Expose the underneath IceTransport.
+  virtual TransportChannelImpl* ice_transport() = 0;
+
+  sigslot::signal2<DtlsTransportInternal*, DtlsTransportState> SignalDtlsState;
+
+  // Emitted whenever the Dtls handshake failed on some transport channel.
+  sigslot::signal1<rtc::SSLHandshakeError> SignalDtlsHandshakeError;
+
+  // Debugging description of this transport.
+  std::string const debug_name() const override {
+    return transport_name() + " " + std::to_string(component());
+  }
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(DtlsTransportInternal);
+};
+
+}  // namespace cricket
+
+#endif  // WEBRTC_P2P_BASE_DTLSTRANSPORTINTERNAL_H_