mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Enable the clang style plugin in rtc_base/

Browse source 
Enabled the plugin and cleaned up all issues it found.

Bug: webrtc:163
Change-Id: Id63f0deb7b335690157ab157c35177b7836688da
Reviewed-on: https://webrtc-review.googlesource.com/14660
Commit-Queue: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20401}
This commit is contained in:
Steve Anton 2017-10-23 14:56:38 -07:00 committed by Commit Bot
parent c5ee987d26
commit af551a1956
35 changed files with 497 additions and 353 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
rtc_base/BUILD.gn
View file

@ -716,10 +716,6 @@ rtc_static_library("rtc_base_generic") {
defines += [ "timezone=_timezone" ]
sources -= [ "ifaddrs_converter.cc" ]
}
if (is_win && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
rtc_source_set("gtest_prod") {
@ -752,6 +748,7 @@ rtc_source_set("rtc_base_tests_utils") {
"fakeclock.cc",
"fakeclock.h",
"fakenetwork.h",
"fakesslidentity.cc",
"fakesslidentity.h",
"firewallsocketserver.cc",
"firewallsocketserver.h",
@ -782,7 +779,9 @@ rtc_source_set("rtc_base_tests_utils") {
"testbase64.h",
"testclient.cc",
"testclient.h",
"testechoserver.cc",
"testechoserver.h",
"testutils.cc",
"testutils.h",
"timedelta.h",
"virtualsocketserver.cc",
@ -799,11 +798,6 @@ rtc_source_set("rtc_base_tests_utils") {
"//testing/gmock",
"//testing/gtest",
]
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
if (rtc_include_tests) {
@ -825,11 +819,6 @@ if (rtc_include_tests) {
"//testing/gmock",
"//testing/gtest",
]
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
rtc_source_set("rtc_base_nonparallel_tests") {
@ -862,11 +851,6 @@ if (rtc_include_tests) {
if (is_win) {
sources += [ "win32socketserver_unittest.cc" ]
}
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
rtc_source_set("rtc_base_approved_unittests") {
@ -931,10 +915,6 @@ if (rtc_include_tests) {
"../system_wrappers:system_wrappers",
"../test:test_support",
]
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
rtc_source_set("rtc_task_queue_unittests") {
@ -957,10 +937,6 @@ if (rtc_include_tests) {
":rtc_task_queue",
"../test:test_support",
]
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
}
rtc_source_set("sequenced_task_checker_unittests") {
@ -1096,10 +1072,6 @@ if (rtc_include_tests) {
":rtc_base",
]
configs += [ ":rtc_base_unittests_config" ]
if (!build_with_chromium && is_clang) {
# Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
if (build_with_chromium) {
include_dirs = [ "../../boringssl/src/include" ]
}

4
rtc_base/buffer_unittest.cc
View file

@ -359,14 +359,14 @@ TEST(BufferTest, TestBracketWrite) {
TEST(BufferTest, TestBeginEnd) {
const Buffer cbuf(kTestData);
Buffer buf(kTestData);
auto b1 = cbuf.begin();
auto* b1 = cbuf.begin();
for (auto& x : buf) {
EXPECT_EQ(*b1, x);
++b1;
++x;
}
EXPECT_EQ(cbuf.end(), b1);
auto b2 = buf.begin();
auto* b2 = buf.begin();
for (auto& y : cbuf) {
EXPECT_EQ(*b2, y + 1);
++b2;

118
rtc_base/fakesslidentity.cc Normal file
View file

@ -0,0 +1,118 @@
/*
* Copyright 2017 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.
*/
#include "rtc_base/fakesslidentity.h"
#include <algorithm>
#include <string>
#include <utility>
#include "rtc_base/checks.h"
#include "rtc_base/messagedigest.h"
#include "rtc_base/ptr_util.h"
namespace rtc {
FakeSSLCertificate::FakeSSLCertificate(const std::string& data)
: data_(data), digest_algorithm_(DIGEST_SHA_1), expiration_time_(-1) {}
FakeSSLCertificate::FakeSSLCertificate(const std::vector<std::string>& certs)
: data_(certs.front()),
digest_algorithm_(DIGEST_SHA_1),
expiration_time_(-1) {
std::vector<std::string>::const_iterator it;
// Skip certs[0].
for (it = certs.begin() + 1; it != certs.end(); ++it) {
certs_.push_back(FakeSSLCertificate(*it));
}
}
FakeSSLCertificate::FakeSSLCertificate(const FakeSSLCertificate&) = default;
FakeSSLCertificate::~FakeSSLCertificate() = default;
FakeSSLCertificate* FakeSSLCertificate::GetReference() const {
return new FakeSSLCertificate(*this);
}
std::string FakeSSLCertificate::ToPEMString() const {
return data_;
}
void FakeSSLCertificate::ToDER(Buffer* der_buffer) const {
std::string der_string;
RTC_CHECK(SSLIdentity::PemToDer(kPemTypeCertificate, data_, &der_string));
der_buffer->SetData(der_string.c_str(), der_string.size());
}
int64_t FakeSSLCertificate::CertificateExpirationTime() const {
return expiration_time_;
}
void FakeSSLCertificate::SetCertificateExpirationTime(int64_t expiration_time) {
expiration_time_ = expiration_time;
}
void FakeSSLCertificate::set_digest_algorithm(const std::string& algorithm) {
digest_algorithm_ = algorithm;
}
bool FakeSSLCertificate::GetSignatureDigestAlgorithm(
std::string* algorithm) const {
*algorithm = digest_algorithm_;
return true;
}
bool FakeSSLCertificate::ComputeDigest(const std::string& algorithm,
unsigned char* digest,
size_t size,
size_t* length) const {
*length =
rtc::ComputeDigest(algorithm, data_.c_str(), data_.size(), digest, size);
return (*length != 0);
}
std::unique_ptr<SSLCertChain> FakeSSLCertificate::GetChain() const {
if (certs_.empty())
return nullptr;
std::vector<std::unique_ptr<SSLCertificate>> new_certs(certs_.size());
std::transform(certs_.begin(), certs_.end(), new_certs.begin(), DupCert);
return MakeUnique<SSLCertChain>(std::move(new_certs));
}
FakeSSLIdentity::FakeSSLIdentity(const std::string& data) : cert_(data) {}
FakeSSLIdentity::FakeSSLIdentity(const FakeSSLCertificate& cert)
: cert_(cert) {}
FakeSSLIdentity* FakeSSLIdentity::GetReference() const {
return new FakeSSLIdentity(*this);
}
const FakeSSLCertificate& FakeSSLIdentity::certificate() const {
return cert_;
}
std::string FakeSSLIdentity::PrivateKeyToPEMString() const {
RTC_NOTREACHED(); // Not implemented.
return "";
}
std::string FakeSSLIdentity::PublicKeyToPEMString() const {
RTC_NOTREACHED(); // Not implemented.
return "";
}
bool FakeSSLIdentity::operator==(const SSLIdentity& other) const {
RTC_NOTREACHED(); // Not implemented.
return false;
}
} // namespace rtc

102
rtc_base/fakesslidentity.h
View file

@ -11,13 +11,9 @@
#ifndef RTC_BASE_FAKESSLIDENTITY_H_
#define RTC_BASE_FAKESSLIDENTITY_H_
#include <algorithm>
#include <memory>
#include <vector>
#include "rtc_base/checks.h"
#include "rtc_base/messagedigest.h"
#include "rtc_base/ptr_util.h"
#include "rtc_base/sslidentity.h"
namespace rtc {
@ -26,57 +22,28 @@ class FakeSSLCertificate : public rtc::SSLCertificate {
public:
// SHA-1 is the default digest algorithm because it is available in all build
// configurations used for unit testing.
explicit FakeSSLCertificate(const std::string& data)
: data_(data), digest_algorithm_(DIGEST_SHA_1), expiration_time_(-1) {}
explicit FakeSSLCertificate(const std::vector<std::string>& certs)
: data_(certs.front()),
digest_algorithm_(DIGEST_SHA_1),
expiration_time_(-1) {
std::vector<std::string>::const_iterator it;
// Skip certs[0].
for (it = certs.begin() + 1; it != certs.end(); ++it) {
certs_.push_back(FakeSSLCertificate(*it));
}
}
FakeSSLCertificate* GetReference() const override {
return new FakeSSLCertificate(*this);
}
std::string ToPEMString() const override {
return data_;
}
void ToDER(Buffer* der_buffer) const override {
std::string der_string;
RTC_CHECK(SSLIdentity::PemToDer(kPemTypeCertificate, data_, &der_string));
der_buffer->SetData(der_string.c_str(), der_string.size());
}
int64_t CertificateExpirationTime() const override {
return expiration_time_;
}
void SetCertificateExpirationTime(int64_t expiration_time) {
expiration_time_ = expiration_time;
}
void set_digest_algorithm(const std::string& algorithm) {
digest_algorithm_ = algorithm;
}
bool GetSignatureDigestAlgorithm(std::string* algorithm) const override {
*algorithm = digest_algorithm_;
return true;
}
explicit FakeSSLCertificate(const std::string& data);
explicit FakeSSLCertificate(const std::vector<std::string>& certs);
FakeSSLCertificate(const FakeSSLCertificate&);
~FakeSSLCertificate() override;
// SSLCertificate implementation.
FakeSSLCertificate* GetReference() const override;
std::string ToPEMString() const override;
void ToDER(Buffer* der_buffer) const override;
int64_t CertificateExpirationTime() const override;
bool GetSignatureDigestAlgorithm(std::string* algorithm) const override;
bool ComputeDigest(const std::string& algorithm,
unsigned char* digest,
size_t size,
size_t* length) const override {
*length = rtc::ComputeDigest(algorithm, data_.c_str(), data_.size(),
digest, size);
return (*length != 0);
}
std::unique_ptr<SSLCertChain> GetChain() const override {
if (certs_.empty())
return nullptr;
std::vector<std::unique_ptr<SSLCertificate>> new_certs(certs_.size());
std::transform(certs_.begin(), certs_.end(), new_certs.begin(), DupCert);
return MakeUnique<SSLCertChain>(std::move(new_certs));
}
size_t* length) const override;
std::unique_ptr<SSLCertChain> GetChain() const override;
void SetCertificateExpirationTime(int64_t expiration_time);
void set_digest_algorithm(const std::string& algorithm);
private:
static std::unique_ptr<SSLCertificate> DupCert(FakeSSLCertificate cert) {
@ -92,24 +59,19 @@ class FakeSSLCertificate : public rtc::SSLCertificate {
class FakeSSLIdentity : public rtc::SSLIdentity {
public:
explicit FakeSSLIdentity(const std::string& data) : cert_(data) {}
explicit FakeSSLIdentity(const FakeSSLCertificate& cert) : cert_(cert) {}
virtual FakeSSLIdentity* GetReference() const {
return new FakeSSLIdentity(*this);
}
virtual const FakeSSLCertificate& certificate() const { return cert_; }
virtual std::string PrivateKeyToPEMString() const {
RTC_NOTREACHED(); // Not implemented.
return "";
}
virtual std::string PublicKeyToPEMString() const {
RTC_NOTREACHED(); // Not implemented.
return "";
}
virtual bool operator==(const SSLIdentity& other) const {
RTC_NOTREACHED(); // Not implemented.
return false;
}
explicit FakeSSLIdentity(const std::string& data);
explicit FakeSSLIdentity(const FakeSSLCertificate& cert);
// SSLIdentity implementation.
FakeSSLIdentity* GetReference() const override;
const FakeSSLCertificate& certificate() const override;
// Not implemented.
std::string PrivateKeyToPEMString() const override;
// Not implemented.
std::string PublicKeyToPEMString() const override;
// Not implemented.
virtual bool operator==(const SSLIdentity& other) const;
private:
FakeSSLCertificate cert_;
};

2
rtc_base/filerotatingstream_unittest.cc
View file

@ -224,7 +224,7 @@ class MAYBE_CallSessionFileRotatingStreamTest : public ::testing::Test {
new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
}
virtual void TearDown() {
void TearDown() override {
// On windows, open files can't be removed.
stream_->Close();
CleanupLogDirectory(*stream_);

9
rtc_base/httpbase_unittest.cc
View file

@ -56,14 +56,13 @@ public:
};
HttpBaseTest() : mem(nullptr), obtain_stream(false), http_stream(nullptr) {}
virtual void SetUp() { }
virtual void TearDown() {
void TearDown() override {
delete http_stream;
// Avoid an ASSERT, in case a test doesn't clean up properly
base.abort(HE_NONE);
}
virtual HttpError onHttpHeaderComplete(bool chunked, size_t& data_size) {
HttpError onHttpHeaderComplete(bool chunked, size_t& data_size) override {
LOG_F(LS_VERBOSE) << "chunked: " << chunked << " size: " << data_size;
Event e = { E_HEADER_COMPLETE, chunked, data_size, HM_NONE, HE_NONE};
events.push_back(e);
@ -72,12 +71,12 @@ public:
}
return HE_NONE;
}
virtual void onHttpComplete(HttpMode mode, HttpError err) {
void onHttpComplete(HttpMode mode, HttpError err) override {
LOG_F(LS_VERBOSE) << "mode: " << mode << " err: " << err;
Event e = { E_COMPLETE, false, 0, mode, err };
events.push_back(e);
}
virtual void onHttpClosed(HttpError err) {
void onHttpClosed(HttpError err) override {
LOG_F(LS_VERBOSE) << "err: " << err;
Event e = { E_CLOSED, false, 0, HM_NONE, err };
events.push_back(e);

2
rtc_base/httpcommon.cc
View file

@ -703,7 +703,7 @@ struct NegotiateAuthContext : public HttpAuthContext {
specified_credentials(false)
{ }
virtual ~NegotiateAuthContext() {
~NegotiateAuthContext() override {
DeleteSecurityContext(&ctx);
FreeCredentialsHandle(&cred);
}

7
rtc_base/messagequeue_unittest.cc
View file

@ -101,10 +101,9 @@ TEST_F(MessageQueueTest, DisposeNotLocked) {
class DeletedMessageHandler : public MessageHandler {
public:
explicit DeletedMessageHandler(bool* deleted) : deleted_(deleted) { }
~DeletedMessageHandler() {
*deleted_ = true;
}
void OnMessage(Message* msg) { }
~DeletedMessageHandler() override { *deleted_ = true; }
void OnMessage(Message* msg) override {}
private:
bool* deleted_;
};

2
rtc_base/network.cc
View file

@ -907,6 +907,8 @@ Network::Network(const std::string& name,
type_(type),
preference_(0) {}
Network::Network(const Network&) = default;
Network::~Network() = default;
// Sets the addresses of this network. Returns true if the address set changed.

1
rtc_base/network.h
View file

@ -288,6 +288,7 @@ class Network {
const IPAddress& prefix,
int prefix_length,
AdapterType type);
Network(const Network&);
~Network();
sigslot::signal1<const Network*> SignalTypeChanged;

2
rtc_base/network_unittest.cc
View file

@ -1096,7 +1096,7 @@ TEST_F(NetworkTest, MAYBE_DefaultLocalAddress) {
std::vector<Network*> networks;
manager.GetNetworks(&networks);
EXPECT_TRUE(!networks.empty());
for (auto& network : networks) {
for (const auto* network : networks) {
if (network->GetBestIP().family() == AF_INET) {
EXPECT_TRUE(manager.QueryDefaultLocalAddress(AF_INET) != IPAddress());
} else if (network->GetBestIP().family() == AF_INET6 &&

7
rtc_base/nullsocketserver_unittest.cc
View file

@ -18,12 +18,9 @@ static const uint32_t kTimeout = 5000U;
class NullSocketServerTest
: public testing::Test,
public MessageHandler {
public:
NullSocketServerTest() {}
protected:
virtual void OnMessage(Message* message) {
ss_.WakeUp();
}
void OnMessage(Message* message) override { ss_.WakeUp(); }
NullSocketServer ss_;
};

20
rtc_base/physicalsocketserver.cc
View file

@ -1152,7 +1152,7 @@ class EventDispatcher : public Dispatcher {
}
}
~EventDispatcher() {
~EventDispatcher() override {
if (hev_ != nullptr) {
ss_->Remove(this);
WSACloseEvent(hev_);
@ -1165,23 +1165,19 @@ class EventDispatcher : public Dispatcher {
WSASetEvent(hev_);
}
virtual uint32_t GetRequestedEvents() { return 0; }
uint32_t GetRequestedEvents() override { return 0; }
virtual void OnPreEvent(uint32_t ff) { WSAResetEvent(hev_); }
void OnPreEvent(uint32_t ff) override { WSAResetEvent(hev_); }
virtual void OnEvent(uint32_t ff, int err) {}
void OnEvent(uint32_t ff, int err) override {}
virtual WSAEVENT GetWSAEvent() {
return hev_;
}
WSAEVENT GetWSAEvent() override { return hev_; }
virtual SOCKET GetSocket() {
return INVALID_SOCKET;
}
SOCKET GetSocket() override { return INVALID_SOCKET; }
virtual bool CheckSignalClose() { return false; }
bool CheckSignalClose() override { return false; }
private:
private:
PhysicalSocketServer* ss_;
WSAEVENT hev_;
};

8
rtc_base/physicalsocketserver_unittest.cc
View file

@ -506,11 +506,9 @@ class PosixSignalDeliveryTest : public testing::Test {
}
protected:
void SetUp() {
ss_.reset(new PhysicalSocketServer());
}
void SetUp() override { ss_.reset(new PhysicalSocketServer()); }
void TearDown() {
void TearDown() override {
ss_.reset(nullptr);
signals_received_.clear();
signaled_thread_ = nullptr;
@ -584,7 +582,7 @@ TEST_F(PosixSignalDeliveryTest, SignalDuringWait) {
}
class RaiseSigTermRunnable : public Runnable {
void Run(Thread *thread) {
void Run(Thread* thread) override {
thread->socketserver()->Wait(1000, false);
// Allow SIGTERM. This will be the only thread with it not masked so it will

1
rtc_base/proxy_unittest.cc
View file

@ -37,7 +37,6 @@ class ProxyTest : public testing::Test {
https_.reset(new rtc::HttpListenServer());
https_->Listen(kHttpsProxyIntAddr);
}
~ProxyTest() {}
rtc::SocketServer* ss() { return ss_.get(); }

4
rtc_base/rtccertificate_unittest.cc
View file

@ -30,10 +30,6 @@ static const char* kTestCertCommonName = "RTCCertificateTest's certificate";
} // namespace
class RTCCertificateTest : public testing::Test {
public:
RTCCertificateTest() {}
~RTCCertificateTest() {}
protected:
scoped_refptr<RTCCertificate> GenerateECDSA() {
std::unique_ptr<SSLIdentity> identity(

1
rtc_base/rtccertificategenerator_unittest.cc
View file

@ -72,7 +72,6 @@ class RTCCertificateGeneratorTest
public:
RTCCertificateGeneratorTest()
: fixture_(new RefCountedObject<RTCCertificateGeneratorFixture>()) {}
~RTCCertificateGeneratorTest() {}
protected:
static const int kGenerationTimeoutMs = 10000;

18
rtc_base/signalthread_unittest.cc
View file

@ -26,7 +26,7 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
public:
SlowSignalThread(SignalThreadTest* harness) : harness_(harness) {}
virtual ~SlowSignalThread() {
~SlowSignalThread() override {
EXPECT_EQ(harness_->main_thread_, Thread::Current());
++harness_->thread_deleted_;
}
@ -34,26 +34,26 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
const SignalThreadTest* harness() { return harness_; }
protected:
virtual void OnWorkStart() {
void OnWorkStart() override {
ASSERT_TRUE(harness_ != nullptr);
++harness_->thread_started_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_FALSE(worker()->RunningForTest()); // not started yet
}
virtual void OnWorkStop() {
void OnWorkStop() override {
++harness_->thread_stopped_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_TRUE(worker()->RunningForTest()); // not stopped yet
}
virtual void OnWorkDone() {
void OnWorkDone() override {
++harness_->thread_done_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_TRUE(worker()->RunningForTest()); // not stopped yet
}
virtual void DoWork() {
void DoWork() override {
EXPECT_NE(harness_->main_thread_, Thread::Current());
EXPECT_EQ(worker(), Thread::Current());
Thread::Current()->socketserver()->Wait(250, false);
@ -75,7 +75,7 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
}
}
virtual void SetUp() {
void SetUp() override {
main_thread_ = Thread::Current();
thread_ = new SlowSignalThread(this);
thread_->SignalWorkDone.connect(this, &SignalThreadTest::OnWorkComplete);
@ -87,8 +87,6 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
thread_deleted_ = 0;
}
virtual void TearDown() {}
void ExpectState(int started,
int done,
int completed,
@ -130,9 +128,9 @@ class OwnerThread : public Thread, public sigslot::has_slots<> {
explicit OwnerThread(SignalThreadTest* harness)
: harness_(harness), has_run_(false) {}
virtual ~OwnerThread() { Stop(); }
~OwnerThread() override { Stop(); }
virtual void Run() {
void Run() override {
SignalThreadTest::SlowSignalThread* signal_thread =
new SignalThreadTest::SlowSignalThread(harness_);
signal_thread->SignalWorkDone.connect(this, &OwnerThread::OnWorkDone);

4
rtc_base/sigslot_unittest.cc
View file

@ -125,7 +125,7 @@ class SigslotMTLockTest : public SigslotMTLockBase {
protected:
SigslotMTLockTest() {}
virtual void SetUp() {
void SetUp() override {
EXPECT_EQ(0, SlotLockCount());
SigslotMTLockBase::SetUp();
// Connects to two signals (ST and MT). However,
@ -134,7 +134,7 @@ class SigslotMTLockTest : public SigslotMTLockBase {
// keep track of their own count).
EXPECT_EQ(1, SlotLockCount());
}
virtual void TearDown() {
void TearDown() override {
const int previous_lock_count = SlotLockCount();
SigslotMTLockBase::TearDown();
// Disconnects from two signals. Note analogous to SetUp().

9
rtc_base/socket_unittest.cc
View file

@ -41,6 +41,10 @@ using webrtc::testing::StreamSink;
// Data size to be used in TcpInternal tests.
static const size_t kTcpInternalDataSize = 1024 * 1024; // bytes
void SocketTest::SetUp() {
ss_ = Thread::Current()->socketserver();
}
void SocketTest::TestConnectIPv4() {
ConnectInternal(kIPv4Loopback);
}
@ -637,10 +641,7 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
class Sleeper : public MessageHandler {
public:
Sleeper() {}
void OnMessage(Message* msg) {
Thread::Current()->SleepMs(500);
}
void OnMessage(Message* msg) override { Thread::Current()->SleepMs(500); }
};
void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {

2
rtc_base/socket_unittest.h
View file

@ -24,7 +24,7 @@ class SocketTest : public testing::Test {
SocketTest() : kIPv4Loopback(INADDR_LOOPBACK),
kIPv6Loopback(in6addr_loopback),
ss_(nullptr) {}
virtual void SetUp() { ss_ = Thread::Current()->socketserver(); }
void SetUp() override;
void TestConnectIPv4();
void TestConnectIPv6();
void TestConnectWithDnsLookupIPv4();

9
rtc_base/sslidentity_unittest.cc
View file

@ -207,12 +207,7 @@ IdentityAndInfo CreateFakeIdentityAndInfoFromDers(
class SSLIdentityTest : public testing::Test {
public:
SSLIdentityTest() {}
~SSLIdentityTest() {
}
virtual void SetUp() {
void SetUp() override {
identity_rsa1_.reset(SSLIdentity::Generate("test1", rtc::KT_RSA));
identity_rsa2_.reset(SSLIdentity::Generate("test2", rtc::KT_RSA));
identity_ecdsa1_.reset(SSLIdentity::Generate("test3", rtc::KT_ECDSA));
@ -499,7 +494,7 @@ class SSLIdentityExpirationTest : public testing::Test {
// Set use of the test RNG to get deterministic expiration timestamp.
rtc::SetRandomTestMode(true);
}
~SSLIdentityExpirationTest() {
~SSLIdentityExpirationTest() override {
// Put it back for the next test.
rtc::SetRandomTestMode(false);
}

2
rtc_base/sslstreamadapter_unittest.cc
View file

@ -241,7 +241,7 @@ class SSLStreamAdapterTestBase : public testing::Test,
rtc::SetRandomTestMode(true);
}
~SSLStreamAdapterTestBase() {
~SSLStreamAdapterTestBase() override {
// Put it back for the next test.
rtc::SetRandomTestMode(false);
}

35
rtc_base/stream_unittest.cc
View file

@ -21,9 +21,12 @@ class TestStream : public StreamInterface {
public:
TestStream() : pos_(0) { }
virtual StreamState GetState() const { return SS_OPEN; }
virtual StreamResult Read(void* buffer, size_t buffer_len,
size_t* read, int* error) {
StreamState GetState() const override { return SS_OPEN; }
StreamResult Read(void* buffer,
size_t buffer_len,
size_t* read,
int* error) override {
unsigned char* uc_buffer = static_cast<unsigned char*>(buffer);
for (size_t i = 0; i < buffer_len; ++i) {
uc_buffer[i] = static_cast<unsigned char>(pos_++);
@ -32,27 +35,31 @@ class TestStream : public StreamInterface {
*read = buffer_len;
return SR_SUCCESS;
}
virtual StreamResult Write(const void* data, size_t data_len,
size_t* written, int* error) {
StreamResult Write(const void* data,
size_t data_len,
size_t* written,
int* error) override {
if (error)
*error = -1;
return SR_ERROR;
}
virtual void Close() { }
virtual bool SetPosition(size_t position) {
void Close() override {}
bool SetPosition(size_t position) override {
pos_ = position;
return true;
}
virtual bool GetPosition(size_t* position) const {
bool GetPosition(size_t* position) const override {
if (position) *position = pos_;
return true;
}
virtual bool GetSize(size_t* size) const {
return false;
}
virtual bool GetAvailable(size_t* size) const {
return false;
}
bool GetSize(size_t* size) const override { return false; }
bool GetAvailable(size_t* size) const override { return false; }
private:
size_t pos_;

30
rtc_base/testechoserver.cc Normal file
View file

@ -0,0 +1,30 @@
/*
* Copyright 2017 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.
*/
#include "rtc_base/testechoserver.h"
namespace rtc {
TestEchoServer::TestEchoServer(Thread* thread, const SocketAddress& addr)
: server_socket_(thread->socketserver()->CreateAsyncSocket(addr.family(),
SOCK_STREAM)) {
server_socket_->Bind(addr);
server_socket_->Listen(5);
server_socket_->SignalReadEvent.connect(this, &TestEchoServer::OnAccept);
}
TestEchoServer::~TestEchoServer() {
for (ClientList::iterator it = client_sockets_.begin();
it != client_sockets_.end(); ++it) {
delete *it;
}
}
} // namespace rtc

17
rtc_base/testechoserver.h
View file

@ -13,9 +13,9 @@
#include <list>
#include <memory>
#include "rtc_base/asynctcpsocket.h"
#include "rtc_base/constructormagic.h"
#include "rtc_base/sigslot.h"
#include "rtc_base/socketaddress.h"
#include "rtc_base/thread.h"
@ -25,19 +25,8 @@ namespace rtc {
// Useful for unit tests.
class TestEchoServer : public sigslot::has_slots<> {
public:
TestEchoServer(Thread* thread, const SocketAddress& addr)
: server_socket_(thread->socketserver()->CreateAsyncSocket(addr.family(),
SOCK_STREAM)) {
server_socket_->Bind(addr);
server_socket_->Listen(5);
server_socket_->SignalReadEvent.connect(this, &TestEchoServer::OnAccept);
}
~TestEchoServer() {
for (ClientList::iterator it = client_sockets_.begin();
it != client_sockets_.end(); ++it) {
delete *it;
}
}
TestEchoServer(Thread* thread, const SocketAddress& addr);
~TestEchoServer() override;
SocketAddress address() const { return server_socket_->GetLocalAddress(); }

117
rtc_base/testutils.cc Normal file
View file

@ -0,0 +1,117 @@
/*
* Copyright 2007 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.
*/
#include "rtc_base/testutils.h"
namespace webrtc {
namespace testing {
StreamSink::StreamSink() = default;
StreamSink::~StreamSink() = default;
StreamSource::StreamSource() {
Clear();
}
StreamSource::~StreamSource() = default;
StreamState StreamSource::GetState() const {
return state_;
}
StreamResult StreamSource::Read(void* buffer,
size_t buffer_len,
size_t* read,
int* error) {
if (SS_CLOSED == state_) {
if (error)
*error = -1;
return SR_ERROR;
}
if ((SS_OPENING == state_) || (readable_data_.size() <= read_block_)) {
return SR_BLOCK;
}
size_t count = std::min(buffer_len, readable_data_.size() - read_block_);
memcpy(buffer, &readable_data_[0], count);
size_t new_size = readable_data_.size() - count;
// Avoid undefined access beyond the last element of the vector.
// This only happens when new_size is 0.
if (count < readable_data_.size()) {
memmove(&readable_data_[0], &readable_data_[count], new_size);
}
readable_data_.resize(new_size);
if (read)
*read = count;
return SR_SUCCESS;
}
StreamResult StreamSource::Write(const void* data,
size_t data_len,
size_t* written,
int* error) {
if (SS_CLOSED == state_) {
if (error)
*error = -1;
return SR_ERROR;
}
if (SS_OPENING == state_) {
return SR_BLOCK;
}
if (SIZE_UNKNOWN != write_block_) {
if (written_data_.size() >= write_block_) {
return SR_BLOCK;
}
if (data_len > (write_block_ - written_data_.size())) {
data_len = write_block_ - written_data_.size();
}
}
if (written)
*written = data_len;
const char* cdata = static_cast<const char*>(data);
written_data_.insert(written_data_.end(), cdata, cdata + data_len);
return SR_SUCCESS;
}
void StreamSource::Close() {
state_ = SS_CLOSED;
}
SocketTestClient::SocketTestClient() {
Init(nullptr, AF_INET);
}
SocketTestClient::SocketTestClient(AsyncSocket* socket) {
Init(socket, socket->GetLocalAddress().family());
}
SocketTestClient::SocketTestClient(const SocketAddress& address) {
Init(nullptr, address.family());
socket_->Connect(address);
}
SocketTestClient::~SocketTestClient() = default;
SocketTestServer::SocketTestServer(const SocketAddress& address)
: socket_(
Thread::Current()->socketserver()->CreateAsyncSocket(address.family(),
SOCK_STREAM)) {
socket_->SignalReadEvent.connect(this, &SocketTestServer::OnReadEvent);
socket_->Bind(address);
socket_->Listen(5);
}
SocketTestServer::~SocketTestServer() {
clear();
}
} // namespace testing
} // namespace webrtc

124
rtc_base/testutils.h
View file

@ -60,6 +60,9 @@ enum StreamSinkEvent {
class StreamSink : public sigslot::has_slots<> {
public:
StreamSink();
~StreamSink() override;
void Monitor(StreamInterface* stream) {
stream->SignalEvent.connect(this, &StreamSink::OnEvent);
events_.erase(stream);
@ -159,16 +162,15 @@ class StreamSink : public sigslot::has_slots<> {
class StreamSource : public StreamInterface {
public:
StreamSource() {
Clear();
}
StreamSource();
~StreamSource() override;
void Clear() {
readable_data_.clear();
written_data_.clear();
state_ = SS_CLOSED;
read_block_ = 0;
write_block_ = SIZE_UNKNOWN;
void Clear() {
readable_data_.clear();
written_data_.clear();
state_ = SS_CLOSED;
read_block_ = 0;
write_block_ = SIZE_UNKNOWN;
}
void QueueString(const char* data) {
QueueData(data, strlen(data));
@ -217,53 +219,18 @@ public:
// Will cause Write to block when there are pos bytes in the write queue.
void SetWriteBlock(size_t pos) { write_block_ = pos; }
virtual StreamState GetState() const { return state_; }
virtual StreamResult Read(void* buffer, size_t buffer_len,
size_t* read, int* error) {
if (SS_CLOSED == state_) {
if (error) *error = -1;
return SR_ERROR;
}
if ((SS_OPENING == state_) || (readable_data_.size() <= read_block_)) {
return SR_BLOCK;
}
size_t count = std::min(buffer_len, readable_data_.size() - read_block_);
memcpy(buffer, &readable_data_[0], count);
size_t new_size = readable_data_.size() - count;
// Avoid undefined access beyond the last element of the vector.
// This only happens when new_size is 0.
if (count < readable_data_.size()) {
memmove(&readable_data_[0], &readable_data_[count], new_size);
}
readable_data_.resize(new_size);
if (read) *read = count;
return SR_SUCCESS;
}
virtual StreamResult Write(const void* data, size_t data_len,
size_t* written, int* error) {
if (SS_CLOSED == state_) {
if (error) *error = -1;
return SR_ERROR;
}
if (SS_OPENING == state_) {
return SR_BLOCK;
}
if (SIZE_UNKNOWN != write_block_) {
if (written_data_.size() >= write_block_) {
return SR_BLOCK;
}
if (data_len > (write_block_ - written_data_.size())) {
data_len = write_block_ - written_data_.size();
}
}
if (written) *written = data_len;
const char* cdata = static_cast<const char*>(data);
written_data_.insert(written_data_.end(), cdata, cdata + data_len);
return SR_SUCCESS;
}
virtual void Close() { state_ = SS_CLOSED; }
StreamState GetState() const override;
StreamResult Read(void* buffer,
size_t buffer_len,
size_t* read,
int* error) override;
StreamResult Write(const void* data,
size_t data_len,
size_t* written,
int* error) override;
void Close() override;
private:
private:
typedef std::vector<char> Buffer;
Buffer readable_data_, written_data_;
StreamState state_;
@ -277,28 +244,22 @@ private:
class SocketTestClient : public sigslot::has_slots<> {
public:
SocketTestClient() { Init(nullptr, AF_INET); }
SocketTestClient(AsyncSocket* socket) {
Init(socket, socket->GetLocalAddress().family());
}
SocketTestClient(const SocketAddress& address) {
Init(nullptr, address.family());
socket_->Connect(address);
}
SocketTestClient();
SocketTestClient(AsyncSocket* socket);
SocketTestClient(const SocketAddress& address);
~SocketTestClient() override;
AsyncSocket* socket() { return socket_.get(); }
AsyncSocket* socket() { return socket_.get(); }
void QueueString(const char* data) {
QueueData(data, strlen(data));
}
void QueueStringF(const char* format, ...) {
va_list args;
va_start(args, format);
char buffer[1024];
size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
RTC_CHECK(len < sizeof(buffer) - 1);
va_end(args);
QueueData(buffer, len);
void QueueString(const char* data) { QueueData(data, strlen(data)); }
void QueueStringF(const char* format, ...) {
va_list args;
va_start(args, format);
char buffer[1024];
size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
RTC_CHECK(len < sizeof(buffer) - 1);
va_end(args);
QueueData(buffer, len);
}
void QueueData(const char* data, size_t len) {
send_buffer_.insert(send_buffer_.end(), data, data + len);
@ -382,17 +343,8 @@ private:
class SocketTestServer : public sigslot::has_slots<> {
public:
SocketTestServer(const SocketAddress& address)
: socket_(Thread::Current()->socketserver()
->CreateAsyncSocket(address.family(), SOCK_STREAM))
{
socket_->SignalReadEvent.connect(this, &SocketTestServer::OnReadEvent);
socket_->Bind(address);
socket_->Listen(5);
}
virtual ~SocketTestServer() {
clear();
}
SocketTestServer(const SocketAddress& address);
~SocketTestServer() override;
size_t size() const { return clients_.size(); }
SocketTestClient* client(size_t index) const { return clients_[index]; }

17
rtc_base/thread_unittest.cc
View file

@ -44,7 +44,6 @@ class TestGenerator {
struct TestMessage : public MessageData {
explicit TestMessage(int v) : value(v) {}
virtual ~TestMessage() {}
int value;
};
@ -60,9 +59,7 @@ class SocketClient : public TestGenerator, public sigslot::has_slots<> {
socket_->SignalReadPacket.connect(this, &SocketClient::OnPacket);
}
~SocketClient() {
delete socket_;
}
~SocketClient() override { delete socket_; }
SocketAddress address() const { return socket_->GetLocalAddress(); }
@ -90,11 +87,9 @@ class MessageClient : public MessageHandler, public TestGenerator {
: socket_(socket) {
}
virtual ~MessageClient() {
delete socket_;
}
~MessageClient() override { delete socket_; }
virtual void OnMessage(Message *pmsg) {
void OnMessage(Message* pmsg) override {
TestMessage* msg = static_cast<TestMessage*>(pmsg->pdata);
int result = Next(msg->value);
EXPECT_GE(socket_->Send(&result, sizeof(result)), 0);
@ -109,7 +104,7 @@ class CustomThread : public rtc::Thread {
public:
CustomThread()
: Thread(std::unique_ptr<SocketServer>(new rtc::NullSocketServer())) {}
virtual ~CustomThread() { Stop(); }
~CustomThread() override { Stop(); }
bool Start() { return false; }
bool WrapCurrent() {
@ -129,12 +124,12 @@ class SignalWhenDestroyedThread : public Thread {
: Thread(std::unique_ptr<SocketServer>(new NullSocketServer())),
event_(event) {}
virtual ~SignalWhenDestroyedThread() {
~SignalWhenDestroyedThread() override {
Stop();
event_->Set();
}
virtual void Run() {
void Run() override {
// Do nothing.
}

8
rtc_base/virtualsocket_unittest.cc
View file

@ -53,7 +53,7 @@ struct Sender : public MessageHandler {
return 1000 * size / rate;
}
void OnMessage(Message* pmsg) {
void OnMessage(Message* pmsg) override {
ASSERT_EQ(1u, pmsg->message_id);
if (done)
@ -98,9 +98,7 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
}
~Receiver() {
thread->Clear(this);
}
~Receiver() override { thread->Clear(this); }
void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
const SocketAddress& remote_addr,
@ -119,7 +117,7 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
samples += 1;
}
void OnMessage(Message* pmsg) {
void OnMessage(Message* pmsg) override {
ASSERT_EQ(1u, pmsg->message_id);
if (done)

24
rtc_base/win32socketserver.cc
View file

@ -152,9 +152,11 @@ class Win32Socket::EventSink : public Win32Window {
void Dispose();
virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
LRESULT& result);
virtual void OnNcDestroy();
bool OnMessage(UINT uMsg,
WPARAM wParam,
LPARAM lParam,
LRESULT& result) override;
void OnNcDestroy() override;
private:
bool OnSocketNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result);
@ -831,4 +833,20 @@ bool Win32SocketServer::MessageWindow::OnMessage(UINT wm, WPARAM wp,
return handled;
}
Win32Thread::Win32Thread(SocketServer* ss) : Thread(ss), id_(0) {}
Win32Thread::~Win32Thread() {
Stop();
}
void Win32Thread::Run() {
id_ = GetCurrentThreadId();
Thread::Run();
id_ = 0;
}
void Win32Thread::Quit() {
PostThreadMessage(id_, WM_QUIT, 0, 0);
}
} // namespace rtc

78
rtc_base/win32socketserver.h
View file

@ -30,7 +30,7 @@ namespace rtc {
class Win32Socket : public AsyncSocket {
public:
Win32Socket();
virtual ~Win32Socket();
~Win32Socket() override;
bool CreateT(int family, int type);
@ -38,25 +38,27 @@ class Win32Socket : public AsyncSocket {
void SetTimeout(int ms);
// AsyncSocket Interface
virtual SocketAddress GetLocalAddress() const;
virtual SocketAddress GetRemoteAddress() const;
virtual int Bind(const SocketAddress& addr);
virtual int Connect(const SocketAddress& addr);
virtual int Send(const void *buffer, size_t length);
virtual int SendTo(const void *buffer, size_t length, const SocketAddress& addr);
virtual int Recv(void* buffer, size_t length, int64_t* timestamp);
virtual int RecvFrom(void* buffer,
size_t length,
SocketAddress* out_addr,
int64_t* timestamp);
virtual int Listen(int backlog);
virtual Win32Socket *Accept(SocketAddress *out_addr);
virtual int Close();
virtual int GetError() const;
virtual void SetError(int error);
virtual ConnState GetState() const;
virtual int GetOption(Option opt, int* value);
virtual int SetOption(Option opt, int value);
SocketAddress GetLocalAddress() const override;
SocketAddress GetRemoteAddress() const override;
int Bind(const SocketAddress& addr) override;
int Connect(const SocketAddress& addr) override;
int Send(const void* buffer, size_t length) override;
int SendTo(const void* buffer,
size_t length,
const SocketAddress& addr) override;
int Recv(void* buffer, size_t length, int64_t* timestamp) override;
int RecvFrom(void* buffer,
size_t length,
SocketAddress* out_addr,
int64_t* timestamp) override;
int Listen(int backlog) override;
Win32Socket* Accept(SocketAddress* out_addr) override;
int Close() override;
int GetError() const override;
void SetError(int error) override;
ConnState GetState() const override;
int GetOption(Option opt, int* value) override;
int SetOption(Option opt, int value) override;
private:
void CreateSink();
@ -93,22 +95,22 @@ class Win32Socket : public AsyncSocket {
class Win32SocketServer : public SocketServer {
public:
Win32SocketServer();
virtual ~Win32SocketServer();
~Win32SocketServer() override;
void set_modeless_dialog(HWND hdlg) {
hdlg_ = hdlg;
}
// SocketServer Interface
virtual Socket* CreateSocket(int type);
virtual Socket* CreateSocket(int family, int type);
Socket* CreateSocket(int type) override;
Socket* CreateSocket(int family, int type) override;
virtual AsyncSocket* CreateAsyncSocket(int type);
virtual AsyncSocket* CreateAsyncSocket(int family, int type);
AsyncSocket* CreateAsyncSocket(int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
virtual void SetMessageQueue(MessageQueue* queue);
virtual bool Wait(int cms, bool process_io);
virtual void WakeUp();
void SetMessageQueue(MessageQueue* queue) override;
bool Wait(int cms, bool process_io) override;
void WakeUp() override;
void Pump();
@ -119,7 +121,7 @@ class Win32SocketServer : public SocketServer {
public:
explicit MessageWindow(Win32SocketServer* ss) : ss_(ss) {}
private:
virtual bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result);
bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result) override;
Win32SocketServer* ss_;
};
@ -137,18 +139,12 @@ class Win32SocketServer : public SocketServer {
class Win32Thread : public Thread {
public:
explicit Win32Thread(SocketServer* ss) : Thread(ss), id_(0) {}
virtual ~Win32Thread() {
Stop();
}
virtual void Run() {
id_ = GetCurrentThreadId();
Thread::Run();
id_ = 0;
}
virtual void Quit() {
PostThreadMessage(id_, WM_QUIT, 0, 0);
}
explicit Win32Thread(SocketServer* ss);
~Win32Thread() override;
void Run() override;
void Quit() override;
private:
DWORD id_;
};

18
rtc_base/win32window.cc
View file

@ -87,10 +87,20 @@ bool Win32Window::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
return false;
}
LRESULT Win32Window::WndProc(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam) {
Win32Window* that = reinterpret_cast<Win32Window*>(
::GetWindowLongPtr(hwnd, GWLP_USERDATA));
bool Win32Window::OnClose() {
return true;
}
void Win32Window::OnNcDestroy() {
// Do nothing. }
}
LRESULT Win32Window::WndProc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam) {
Win32Window* that =
reinterpret_cast<Win32Window*>(::GetWindowLongPtr(hwnd, GWLP_USERDATA));
if (!that && (WM_CREATE == uMsg)) {
CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lParam);
that = static_cast<Win32Window*>(cs->lpCreateParams);

4
rtc_base/win32window.h
View file

@ -39,8 +39,8 @@ class Win32Window {
virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
LRESULT& result);
virtual bool OnClose() { return true; }
virtual void OnNcDestroy() { }
virtual bool OnClose();
virtual void OnNcDestroy();
private:
static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam,

10
rtc_base/win32window_unittest.cc
View file

@ -20,17 +20,17 @@ class TestWindow : public rtc::Win32Window {
const MSG& msg() const { return msg_; }
bool destroyed() const { return destroyed_; }
virtual bool OnMessage(UINT uMsg, WPARAM wParam,
LPARAM lParam, LRESULT& result) {
bool OnMessage(UINT uMsg,
WPARAM wParam,
LPARAM lParam,
LRESULT& result) override {
msg_.message = uMsg;
msg_.wParam = wParam;
msg_.lParam = lParam;
result = kDummyResult;
return true;
}
virtual void OnNcDestroy() {
destroyed_ = true;
}
void OnNcDestroy() override { destroyed_ = true; }
private:
MSG msg_;