zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup of pc/proxy.h

Browse Source 
Avoid implicit conversion from rtc::scoped_refptr to raw pointer, when
calling the MethodCall and ConstMethodCall constructors. Fixed by
defining a private accessor T* c() which always returns a raw pointer,
with different implementation for BEGIN_PROXY_MAP and
BEGIN_OWNED_PROXY_MAP.

Avoid using the same name for macro argument and function argument
within the macro definition, like `c` in:

```
#define PRIMARY_PROXY_MAP_BOILERPLATE(c) \
 protected: \
  c##ProxyWithInternal(rtc::Thread* primary_thread, INTERNAL_CLASS* c) \
      : primary_thread_(primary_thread), c_(c) {} \
```

Fixed by using `class_name` as the macro argument throughout.

Bug: webrtc:13464
Change-Id: I9faf095b004afd5225f5ec09fb782ef4b5c9dc5d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/249089
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35794}
This commit is contained in:
Niels Möller
2022-01-25 16:18:53 +01:00
committed by WebRTC LUCI CQ
parent a36f10bd73
commit 7f761573b3
1 changed files with 166 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
pc/proxy.h
View File

@ -202,41 +202,44 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_STRINGIZE(x) PROXY_STRINGIZE_IMPL(x)
// Helper macros to reduce code duplication.
#define PROXY_MAP_BOILERPLATE(c) \
#define PROXY_MAP_BOILERPLATE(class_name) \
template <class INTERNAL_CLASS> \
class c##ProxyWithInternal; \
typedef c##ProxyWithInternal<c##Interface> c##Proxy; \
class class_name##ProxyWithInternal; \
typedef class_name##ProxyWithInternal<class_name##Interface> \
class_name##Proxy; \
template <class INTERNAL_CLASS> \
class c##ProxyWithInternal : public c##Interface { \
class class_name##ProxyWithInternal : public class_name##Interface { \
protected: \
static constexpr char proxy_name_[] = #c "Proxy"; \
typedef c##Interface C; \
static constexpr char proxy_name_[] = #class_name "Proxy"; \
typedef class_name##Interface C; \
\
public: \
const INTERNAL_CLASS* internal() const { return c_; } \
INTERNAL_CLASS* internal() { return c_; }
const INTERNAL_CLASS* internal() const { return c(); } \
INTERNAL_CLASS* internal() { return c(); }
// clang-format off
// clang-format would put the semicolon alone,
// leading to a presubmit error (cpplint.py)
#define END_PROXY_MAP(c) \
#define END_PROXY_MAP(class_name) \
}; \
template <class INTERNAL_CLASS> \
constexpr char c##ProxyWithInternal<INTERNAL_CLASS>::proxy_name_[];
constexpr char class_name##ProxyWithInternal<INTERNAL_CLASS>::proxy_name_[];
// clang-format on
#define PRIMARY_PROXY_MAP_BOILERPLATE(c) \
#define PRIMARY_PROXY_MAP_BOILERPLATE(class_name) \
protected: \
c##ProxyWithInternal(rtc::Thread* primary_thread, INTERNAL_CLASS* c) \
class_name##ProxyWithInternal(rtc::Thread* primary_thread, \
INTERNAL_CLASS* c) \
: primary_thread_(primary_thread), c_(c) {} \
\
private: \
mutable rtc::Thread* primary_thread_;
#define SECONDARY_PROXY_MAP_BOILERPLATE(c) \
#define SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
protected: \
c##ProxyWithInternal(rtc::Thread* primary_thread, \
rtc::Thread* secondary_thread, INTERNAL_CLASS* c) \
class_name##ProxyWithInternal(rtc::Thread* primary_thread, \
rtc::Thread* secondary_thread, \
INTERNAL_CLASS* c) \
: primary_thread_(primary_thread), \
secondary_thread_(secondary_thread), \
c_(c) {} \
@ -247,15 +250,17 @@ class ConstMethodCall : public QueuedTask {
// Note that the destructor is protected so that the proxy can only be
// destroyed via RefCountInterface.
#define REFCOUNTED_PROXY_MAP_BOILERPLATE(c) \
#define REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name) \
protected: \
~c##ProxyWithInternal() { \
MethodCall<c##ProxyWithInternal, void> call( \
this, &c##ProxyWithInternal::DestroyInternal); \
~class_name##ProxyWithInternal() { \
MethodCall<class_name##ProxyWithInternal, void> call( \
this, &class_name##ProxyWithInternal::DestroyInternal); \
call.Marshal(RTC_FROM_HERE, destructor_thread()); \
} \
\
private: \
const INTERNAL_CLASS* c() const { return c_.get(); } \
INTERNAL_CLASS* c() { return c_.get(); } \
void DestroyInternal() { c_ = nullptr; } \
rtc::scoped_refptr<INTERNAL_CLASS> c_;
@ -264,50 +269,54 @@ class ConstMethodCall : public QueuedTask {
// this proxy object. If relying on a unique_ptr to delete the object, its
// inner pointer would be set to null before this reentrant callback would have
// a chance to run, resulting in a segfault.
#define OWNED_PROXY_MAP_BOILERPLATE(c) \
#define OWNED_PROXY_MAP_BOILERPLATE(class_name) \
public: \
~c##ProxyWithInternal() { \
MethodCall<c##ProxyWithInternal, void> call( \
this, &c##ProxyWithInternal::DestroyInternal); \
~class_name##ProxyWithInternal() { \
MethodCall<class_name##ProxyWithInternal, void> call( \
this, &class_name##ProxyWithInternal::DestroyInternal); \
call.Marshal(RTC_FROM_HERE, destructor_thread()); \
} \
\
private: \
const INTERNAL_CLASS* c() const { return c_; } \
INTERNAL_CLASS* c() { return c_; } \
void DestroyInternal() { delete c_; } \
INTERNAL_CLASS* c_;
#define BEGIN_PRIMARY_PROXY_MAP(c) \
PROXY_MAP_BOILERPLATE(c) \
PRIMARY_PROXY_MAP_BOILERPLATE(c) \
REFCOUNTED_PROXY_MAP_BOILERPLATE(c) \
#define BEGIN_PRIMARY_PROXY_MAP(class_name) \
PROXY_MAP_BOILERPLATE(class_name) \
PRIMARY_PROXY_MAP_BOILERPLATE(class_name) \
REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name) \
public: \
static rtc::scoped_refptr<c##ProxyWithInternal> Create( \
static rtc::scoped_refptr<class_name##ProxyWithInternal> Create( \
rtc::Thread* primary_thread, INTERNAL_CLASS* c) { \
return rtc::make_ref_counted<c##ProxyWithInternal>(primary_thread, c); \
return rtc::make_ref_counted<class_name##ProxyWithInternal>( \
primary_thread, c); \
}
#define BEGIN_PROXY_MAP(c) \
PROXY_MAP_BOILERPLATE(c) \
SECONDARY_PROXY_MAP_BOILERPLATE(c) \
REFCOUNTED_PROXY_MAP_BOILERPLATE(c) \
#define BEGIN_PROXY_MAP(class_name) \
PROXY_MAP_BOILERPLATE(class_name) \
SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name) \
public: \
static rtc::scoped_refptr<c##ProxyWithInternal> Create( \
static rtc::scoped_refptr<class_name##ProxyWithInternal> Create( \
rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \
INTERNAL_CLASS* c) { \
return rtc::make_ref_counted<c##ProxyWithInternal>(primary_thread, \
secondary_thread, c); \
return rtc::make_ref_counted<class_name##ProxyWithInternal>( \
primary_thread, secondary_thread, c); \
}
#define BEGIN_OWNED_PROXY_MAP(c) \
PROXY_MAP_BOILERPLATE(c) \
SECONDARY_PROXY_MAP_BOILERPLATE(c) \
OWNED_PROXY_MAP_BOILERPLATE(c) \
#define BEGIN_OWNED_PROXY_MAP(class_name) \
PROXY_MAP_BOILERPLATE(class_name) \
SECONDARY_PROXY_MAP_BOILERPLATE(class_name) \
OWNED_PROXY_MAP_BOILERPLATE(class_name) \
public: \
static std::unique_ptr<c##Interface> Create( \
static std::unique_ptr<class_name##Interface> Create( \
rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \
std::unique_ptr<INTERNAL_CLASS> c) { \
return std::unique_ptr<c##Interface>(new c##ProxyWithInternal( \
primary_thread, secondary_thread, c.release())); \
return std::unique_ptr<class_name##Interface>( \
new class_name##ProxyWithInternal(primary_thread, secondary_thread, \
c.release())); \
}
#define PROXY_PRIMARY_THREAD_DESTRUCTOR() \
@ -339,35 +348,35 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_METHOD0(r, method) \
r method() override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r> call(c_, &C::method); \
MethodCall<C, r> call(c(), &C::method); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
}
#define PROXY_CONSTMETHOD0(r, method) \
r method() const override { \
TRACE_BOILERPLATE(method); \
ConstMethodCall<C, r> call(c_, &C::method); \
ConstMethodCall<C, r> call(c(), &C::method); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
}
#define PROXY_METHOD1(r, method, t1) \
r method(t1 a1) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
MethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
}
#define PROXY_CONSTMETHOD1(r, method, t1) \
r method(t1 a1) const override { \
TRACE_BOILERPLATE(method); \
ConstMethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
ConstMethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
}
#define PROXY_METHOD2(r, method, t1, t2) \
r method(t1 a1, t2 a2) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
MethodCall<C, r, t1, t2> call(c(), &C::method, std::move(a1), \
std::move(a2)); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
}
@ -375,7 +384,7 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_METHOD3(r, method, t1, t2, t3) \
r method(t1 a1, t2 a2, t3 a3) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
MethodCall<C, r, t1, t2, t3> call(c(), &C::method, std::move(a1), \
std::move(a2), std::move(a3)); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
}
@ -383,7 +392,7 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_METHOD4(r, method, t1, t2, t3, t4) \
r method(t1 a1, t2 a2, t3 a3, t4 a4) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1, t2, t3, t4> call(c_, &C::method, std::move(a1), \
MethodCall<C, r, t1, t2, t3, t4> call(c(), &C::method, std::move(a1), \
std::move(a2), std::move(a3), \
std::move(a4)); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
@ -392,7 +401,7 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5) \
r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1, t2, t3, t4, t5> call(c_, &C::method, std::move(a1), \
MethodCall<C, r, t1, t2, t3, t4, t5> call(c(), &C::method, std::move(a1), \
std::move(a2), std::move(a3), \
std::move(a4), std::move(a5)); \
return call.Marshal(RTC_FROM_HERE, primary_thread_); \
@ -402,35 +411,35 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_SECONDARY_METHOD0(r, method) \
r method() override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r> call(c_, &C::method); \
MethodCall<C, r> call(c(), &C::method); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
#define PROXY_SECONDARY_CONSTMETHOD0(r, method) \
r method() const override { \
TRACE_BOILERPLATE(method); \
ConstMethodCall<C, r> call(c_, &C::method); \
ConstMethodCall<C, r> call(c(), &C::method); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
#define PROXY_SECONDARY_METHOD1(r, method, t1) \
r method(t1 a1) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
MethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
#define PROXY_SECONDARY_CONSTMETHOD1(r, method, t1) \
r method(t1 a1) const override { \
TRACE_BOILERPLATE(method); \
ConstMethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
ConstMethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
#define PROXY_SECONDARY_METHOD2(r, method, t1, t2) \
r method(t1 a1, t2 a2) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
MethodCall<C, r, t1, t2> call(c(), &C::method, std::move(a1), \
std::move(a2)); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
@ -438,7 +447,7 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_SECONDARY_CONSTMETHOD2(r, method, t1, t2) \
r method(t1 a1, t2 a2) const override { \
TRACE_BOILERPLATE(method); \
ConstMethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
ConstMethodCall<C, r, t1, t2> call(c(), &C::method, std::move(a1), \
std::move(a2)); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
@ -446,7 +455,7 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_SECONDARY_METHOD3(r, method, t1, t2, t3) \
r method(t1 a1, t2 a2, t3 a3) override { \
TRACE_BOILERPLATE(method); \
MethodCall<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
MethodCall<C, r, t1, t2, t3> call(c(), &C::method, std::move(a1), \
std::move(a2), std::move(a3)); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}
@ -454,7 +463,7 @@ class ConstMethodCall : public QueuedTask {
#define PROXY_SECONDARY_CONSTMETHOD3(r, method, t1, t2) \
r method(t1 a1, t2 a2, t3 a3) const override { \
TRACE_BOILERPLATE(method); \
ConstMethodCall<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
ConstMethodCall<C, r, t1, t2, t3> call(c(), &C::method, std::move(a1), \
std::move(a2), std::move(a3)); \
return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
}