| // Copyright 2019 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 THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_SCTP_TRANSPORT_PROXY_H_ |
| #define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_SCTP_TRANSPORT_PROXY_H_ |
| |
| #include <memory> |
| |
| #include "base/memory/scoped_refptr.h" |
| #include "base/single_thread_task_runner.h" |
| #include "third_party/blink/renderer/platform/heap/garbage_collected.h" |
| #include "third_party/blink/renderer/platform/heap/persistent.h" |
| #include "third_party/blink/renderer/platform/heap/visitor.h" |
| #include "third_party/webrtc/api/sctp_transport_interface.h" |
| |
| // The SctpTransportProxy class takes care of thread-jumping when |
| // connecting callbacks from a webrtc::SctpTransport to a |
| // blink::RTCSctpTransport object. |
| |
| // Its design is modeled on the IceTransportProxy design, |
| // but does not use so many layers of indirection - there is |
| // no control, and all information is passed via callbacks on the Delegate. |
| |
| // The proxy thread = the Blink main thread |
| // The host thread = the webrtc signalling thread (the one that gets callbacks) |
| |
| namespace blink { |
| |
| class LocalFrame; |
| |
| class SctpTransportProxy : public webrtc::SctpTransportObserverInterface { |
| public: |
| // Delegate class for actions caused by the Proxy, but executed on the |
| // main thread. The Delegate must remain alive until it has observed |
| // the kClosed state, which is the last thing that can happen. |
| class Delegate : public blink::GarbageCollectedMixin { |
| public: |
| virtual ~Delegate() = default; |
| |
| // Called when the Create() function is complete. Sends current state, |
| // but does not indicate a state change. |
| virtual void OnStartCompleted(webrtc::SctpTransportInformation info) = 0; |
| // Called when a state change is signalled from transport. |
| virtual void OnStateChange(webrtc::SctpTransportInformation info) = 0; |
| void Trace(Visitor* visitor) const override {} |
| }; |
| |
| // Constructs a SctpTransportProxy. The caller is responsible for keeping |
| // |sctp_transport| alive until after the SctpTransportProxy is deleted. |
| // The SctpTransportProxy takes a <CrossThreadPersistent> reference to the |
| // Delegate, preventing it from being garbage collected until the |kClosed| |
| // state is reached. |
| // The SctpTransportProxy can only be safely deleted after seeing the state |
| // |kClosed|, since this is the last event that can happen on the transport. |
| static std::unique_ptr<SctpTransportProxy> Create( |
| LocalFrame& frame, |
| scoped_refptr<base::SingleThreadTaskRunner> proxy_thread, |
| scoped_refptr<base::SingleThreadTaskRunner> host_thread, |
| rtc::scoped_refptr<webrtc::SctpTransportInterface> sctp_transport, |
| Delegate* delegate); |
| |
| ~SctpTransportProxy() override {} |
| |
| private: |
| SctpTransportProxy( |
| LocalFrame& frame, |
| scoped_refptr<base::SingleThreadTaskRunner> proxy_thread, |
| scoped_refptr<base::SingleThreadTaskRunner> host_thread, |
| rtc::scoped_refptr<webrtc::SctpTransportInterface> sctp_transport, |
| Delegate* delegate); |
| // Implementation of webrtc::SctpTransportObserver |
| void OnStateChange(webrtc::SctpTransportInformation info) override; |
| |
| // Internal helper for Create() |
| void StartOnHostThread(); |
| |
| const scoped_refptr<base::SingleThreadTaskRunner> proxy_thread_; |
| const scoped_refptr<base::SingleThreadTaskRunner> host_thread_; |
| const rtc::scoped_refptr<webrtc::SctpTransportInterface> sctp_transport_; |
| CrossThreadPersistent<Delegate> delegate_; |
| }; |
| |
| } // namespace blink |
| |
| #endif // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_SCTP_TRANSPORT_PROXY_H_ |