mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-12 21:30:45 +01:00
3ba809d6a6
Access to `internal_dtls_transport_` only occurs on the network thread and doesn't require locking. Access to `info_` still requires a lock but writing to it only occurs on the network thread. If reading from the network thread is needed, that could be done without requiring the lock. The scope of holding the lock is much smaller now. Bug: none Change-Id: Ic284df04196dfcf8b77c66a48e484ca6893de050 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/325283 Reviewed-by: Harald Alvestrand <hta@webrtc.org> Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org> Cr-Commit-Position: refs/heads/main@{#41387}
88 lines
2.8 KiB
C++
88 lines
2.8 KiB
C++
/*
|
|
* Copyright 2018 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 PC_DTLS_TRANSPORT_H_
|
|
#define PC_DTLS_TRANSPORT_H_
|
|
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
#include "api/dtls_transport_interface.h"
|
|
#include "api/ice_transport_interface.h"
|
|
#include "api/scoped_refptr.h"
|
|
#include "p2p/base/dtls_transport.h"
|
|
#include "p2p/base/dtls_transport_internal.h"
|
|
#include "pc/ice_transport.h"
|
|
#include "rtc_base/synchronization/mutex.h"
|
|
#include "rtc_base/thread.h"
|
|
#include "rtc_base/thread_annotations.h"
|
|
|
|
namespace webrtc {
|
|
|
|
class IceTransportWithPointer;
|
|
|
|
// This implementation wraps a cricket::DtlsTransport, and takes
|
|
// ownership of it.
|
|
class DtlsTransport : public DtlsTransportInterface {
|
|
public:
|
|
// This object must be constructed and updated on a consistent thread,
|
|
// the same thread as the one the cricket::DtlsTransportInternal object
|
|
// lives on.
|
|
// The Information() function can be called from a different thread,
|
|
// such as the signalling thread.
|
|
explicit DtlsTransport(
|
|
std::unique_ptr<cricket::DtlsTransportInternal> internal);
|
|
|
|
rtc::scoped_refptr<IceTransportInterface> ice_transport() override;
|
|
|
|
// Currently called from the signaling thread and potentially Chromium's
|
|
// JS thread.
|
|
DtlsTransportInformation Information() override;
|
|
|
|
void RegisterObserver(DtlsTransportObserverInterface* observer) override;
|
|
void UnregisterObserver() override;
|
|
void Clear();
|
|
|
|
cricket::DtlsTransportInternal* internal() {
|
|
RTC_DCHECK_RUN_ON(owner_thread_);
|
|
return internal_dtls_transport_.get();
|
|
}
|
|
|
|
const cricket::DtlsTransportInternal* internal() const {
|
|
RTC_DCHECK_RUN_ON(owner_thread_);
|
|
return internal_dtls_transport_.get();
|
|
}
|
|
|
|
protected:
|
|
~DtlsTransport();
|
|
|
|
private:
|
|
void OnInternalDtlsState(cricket::DtlsTransportInternal* transport,
|
|
DtlsTransportState state);
|
|
void UpdateInformation();
|
|
|
|
// Called when changing `info_`. We only change the values from the
|
|
// `owner_thread_` (a.k.a. the network thread).
|
|
void set_info(DtlsTransportInformation&& info) RTC_RUN_ON(owner_thread_) {
|
|
MutexLock lock(&lock_);
|
|
info_ = std::move(info);
|
|
}
|
|
|
|
DtlsTransportObserverInterface* observer_ = nullptr;
|
|
rtc::Thread* owner_thread_;
|
|
mutable Mutex lock_;
|
|
DtlsTransportInformation info_ RTC_GUARDED_BY(lock_);
|
|
std::unique_ptr<cricket::DtlsTransportInternal> internal_dtls_transport_
|
|
RTC_GUARDED_BY(owner_thread_);
|
|
const rtc::scoped_refptr<IceTransportWithPointer> ice_transport_;
|
|
};
|
|
|
|
} // namespace webrtc
|
|
#endif // PC_DTLS_TRANSPORT_H_
|