admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Enable the clang style plugin in rtc_base/"

Browse Source 
This reverts commit af551a1956d2ec3a388cf7e0e88c7ee2c2b61291.

Reason for revert: Fails to compile on Chromium FYI bot: https://build.chromium.org/p/chromium.webrtc.fyi/builders/Linux%20Builder/builds/21375

Original change's description:
> Enable the clang style plugin in rtc_base/
> 
> 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}

TBR=steveanton@webrtc.org,kwiberg@webrtc.org

Change-Id: Iafdf4bc1744a981b5d7d38e4a0c5b2d88753f00a
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:163
Reviewed-on: https://webrtc-review.googlesource.com/14740
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Commit-Queue: Steve Anton <steveanton@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20402}
This commit is contained in:
Steve Anton 2017-10-24 00:43:48 +00:00 committed by Commit Bot
parent af551a1956
commit a17ce27b20
35 changed files with 353 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
rtc_base/BUILD.gn
View File

@ -716,6 +716,10 @@ 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") {
@ -748,7 +752,6 @@ rtc_source_set("rtc_base_tests_utils") {
"fakeclock.cc",
"fakeclock.h",
"fakenetwork.h",
"fakesslidentity.cc",
"fakesslidentity.h",
"firewallsocketserver.cc",
"firewallsocketserver.h",
@ -779,9 +782,7 @@ 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",
@ -798,6 +799,11 @@ 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) {
@ -819,6 +825,11 @@ 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") {
@ -851,6 +862,11 @@ 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") {
@ -915,6 +931,10 @@ 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") {
@ -937,6 +957,10 @@ 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") {
@ -1072,6 +1096,10 @@ 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
View File

@ -1,118 +0,0 @@
/*
* 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,9 +11,13 @@
#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 {
@ -22,28 +26,57 @@ 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);
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;
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;
}
bool ComputeDigest(const std::string& algorithm,
unsigned char* digest,
size_t size,
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);
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));
}
private:
static std::unique_ptr<SSLCertificate> DupCert(FakeSSLCertificate cert) {
@ -59,19 +92,24 @@ class FakeSSLCertificate : public rtc::SSLCertificate {
class FakeSSLIdentity : public rtc::SSLIdentity {
public:
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;
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;
}
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));
}
void TearDown() override {
virtual void TearDown() {
// On windows, open files can't be removed.
stream_->Close();
CleanupLogDirectory(*stream_);

9
rtc_base/httpbase_unittest.cc
View File

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

7
rtc_base/messagequeue_unittest.cc
View File

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

2
rtc_base/network.cc
View File

@ -907,8 +907,6 @@ 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,7 +288,6 @@ 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 (const auto* network : networks) {
for (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,9 +18,12 @@ static const uint32_t kTimeout = 5000U;
class NullSocketServerTest
: public testing::Test,
public MessageHandler {
public:
NullSocketServerTest() {}
protected:
void OnMessage(Message* message) override { ss_.WakeUp(); }
virtual void OnMessage(Message* message) {
ss_.WakeUp();
}
NullSocketServer ss_;
};

20
rtc_base/physicalsocketserver.cc
View File

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

8
rtc_base/physicalsocketserver_unittest.cc
View File

@ -506,9 +506,11 @@ class PosixSignalDeliveryTest : public testing::Test {
}
protected:
void SetUp() override { ss_.reset(new PhysicalSocketServer()); }
void SetUp() {
ss_.reset(new PhysicalSocketServer());
}
void TearDown() override {
void TearDown() {
ss_.reset(nullptr);
signals_received_.clear();
signaled_thread_ = nullptr;
@ -582,7 +584,7 @@ TEST_F(PosixSignalDeliveryTest, SignalDuringWait) {
}
class RaiseSigTermRunnable : public Runnable {
void Run(Thread* thread) override {
void Run(Thread *thread) {
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,6 +37,7 @@ 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,6 +30,10 @@ 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,6 +72,7 @@ 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) {}
~SlowSignalThread() override {
virtual ~SlowSignalThread() {
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:
void OnWorkStart() override {
virtual void OnWorkStart() {
ASSERT_TRUE(harness_ != nullptr);
++harness_->thread_started_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_FALSE(worker()->RunningForTest()); // not started yet
}
void OnWorkStop() override {
virtual void OnWorkStop() {
++harness_->thread_stopped_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_TRUE(worker()->RunningForTest()); // not stopped yet
}
void OnWorkDone() override {
virtual void OnWorkDone() {
++harness_->thread_done_;
EXPECT_EQ(harness_->main_thread_, Thread::Current());
EXPECT_TRUE(worker()->RunningForTest()); // not stopped yet
}
void DoWork() override {
virtual void DoWork() {
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<> {
}
}
void SetUp() override {
virtual void SetUp() {
main_thread_ = Thread::Current();
thread_ = new SlowSignalThread(this);
thread_->SignalWorkDone.connect(this, &SignalThreadTest::OnWorkComplete);
@ -87,6 +87,8 @@ class SignalThreadTest : public testing::Test, public sigslot::has_slots<> {
thread_deleted_ = 0;
}
virtual void TearDown() {}
void ExpectState(int started,
int done,
int completed,
@ -128,9 +130,9 @@ class OwnerThread : public Thread, public sigslot::has_slots<> {
explicit OwnerThread(SignalThreadTest* harness)
: harness_(harness), has_run_(false) {}
~OwnerThread() override { Stop(); }
virtual ~OwnerThread() { Stop(); }
void Run() override {
virtual void Run() {
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() {}
void SetUp() override {
virtual void SetUp() {
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());
}
void TearDown() override {
virtual void TearDown() {
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,10 +41,6 @@ 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);
}
@ -641,7 +637,10 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
class Sleeper : public MessageHandler {
public:
void OnMessage(Message* msg) override { Thread::Current()->SleepMs(500); }
Sleeper() {}
void OnMessage(Message* msg) {
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) {}
void SetUp() override;
virtual void SetUp() { ss_ = Thread::Current()->socketserver(); }
void TestConnectIPv4();
void TestConnectIPv6();
void TestConnectWithDnsLookupIPv4();

9
rtc_base/sslidentity_unittest.cc
View File

@ -207,7 +207,12 @@ IdentityAndInfo CreateFakeIdentityAndInfoFromDers(
class SSLIdentityTest : public testing::Test {
public:
void SetUp() override {
SSLIdentityTest() {}
~SSLIdentityTest() {
}
virtual void SetUp() {
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));
@ -494,7 +499,7 @@ class SSLIdentityExpirationTest : public testing::Test {
// Set use of the test RNG to get deterministic expiration timestamp.
rtc::SetRandomTestMode(true);
}
~SSLIdentityExpirationTest() override {
~SSLIdentityExpirationTest() {
// 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() override {
~SSLStreamAdapterTestBase() {
// Put it back for the next test.
rtc::SetRandomTestMode(false);
}

35
rtc_base/stream_unittest.cc
View File

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

30
rtc_base/testechoserver.cc
View File

@ -1,30 +0,0 @@
/*
* 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,8 +25,19 @@ namespace rtc {
// Useful for unit tests.
class TestEchoServer : public sigslot::has_slots<> {
public:
TestEchoServer(Thread* thread, const SocketAddress& addr);
~TestEchoServer() override;
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;
}
}
SocketAddress address() const { return server_socket_->GetLocalAddress(); }

117
rtc_base/testutils.cc
View File

@ -1,117 +0,0 @@
/*
* 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,9 +60,6 @@ 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);
@ -162,15 +159,16 @@ class StreamSink : public sigslot::has_slots<> {
class StreamSource : public StreamInterface {
public:
StreamSource();
~StreamSource() override;
StreamSource() {
Clear();
}
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));
@ -219,18 +217,53 @@ public:
// Will cause Write to block when there are pos bytes in the write queue.
void SetWriteBlock(size_t pos) { write_block_ = pos; }
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;
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; }
private:
private:
typedef std::vector<char> Buffer;
Buffer readable_data_, written_data_;
StreamState state_;
@ -244,22 +277,28 @@ public:
class SocketTestClient : public sigslot::has_slots<> {
public:
SocketTestClient();
SocketTestClient(AsyncSocket* socket);
SocketTestClient(const SocketAddress& address);
~SocketTestClient() override;
SocketTestClient() { Init(nullptr, AF_INET); }
SocketTestClient(AsyncSocket* socket) {
Init(socket, socket->GetLocalAddress().family());
}
SocketTestClient(const SocketAddress& address) {
Init(nullptr, address.family());
socket_->Connect(address);
}
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);
@ -343,8 +382,17 @@ private:
class SocketTestServer : public sigslot::has_slots<> {
public:
SocketTestServer(const SocketAddress& address);
~SocketTestServer() override;
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();
}
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,6 +44,7 @@ class TestGenerator {
struct TestMessage : public MessageData {
explicit TestMessage(int v) : value(v) {}
virtual ~TestMessage() {}
int value;
};
@ -59,7 +60,9 @@ class SocketClient : public TestGenerator, public sigslot::has_slots<> {
socket_->SignalReadPacket.connect(this, &SocketClient::OnPacket);
}
~SocketClient() override { delete socket_; }
~SocketClient() {
delete socket_;
}
SocketAddress address() const { return socket_->GetLocalAddress(); }
@ -87,9 +90,11 @@ class MessageClient : public MessageHandler, public TestGenerator {
: socket_(socket) {
}
~MessageClient() override { delete socket_; }
virtual ~MessageClient() {
delete socket_;
}
void OnMessage(Message* pmsg) override {
virtual void OnMessage(Message *pmsg) {
TestMessage* msg = static_cast<TestMessage*>(pmsg->pdata);
int result = Next(msg->value);
EXPECT_GE(socket_->Send(&result, sizeof(result)), 0);
@ -104,7 +109,7 @@ class CustomThread : public rtc::Thread {
public:
CustomThread()
: Thread(std::unique_ptr<SocketServer>(new rtc::NullSocketServer())) {}
~CustomThread() override { Stop(); }
virtual ~CustomThread() { Stop(); }
bool Start() { return false; }
bool WrapCurrent() {
@ -124,12 +129,12 @@ class SignalWhenDestroyedThread : public Thread {
: Thread(std::unique_ptr<SocketServer>(new NullSocketServer())),
event_(event) {}
~SignalWhenDestroyedThread() override {
virtual ~SignalWhenDestroyedThread() {
Stop();
event_->Set();
}
void Run() override {
virtual void Run() {
// 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) override {
void OnMessage(Message* pmsg) {
ASSERT_EQ(1u, pmsg->message_id);
if (done)
@ -98,7 +98,9 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
}
~Receiver() override { thread->Clear(this); }
~Receiver() {
thread->Clear(this);
}
void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
const SocketAddress& remote_addr,
@ -117,7 +119,7 @@ struct Receiver : public MessageHandler, public sigslot::has_slots<> {
samples += 1;
}
void OnMessage(Message* pmsg) override {
void OnMessage(Message* pmsg) {
ASSERT_EQ(1u, pmsg->message_id);
if (done)

24
rtc_base/win32socketserver.cc
View File

@ -152,11 +152,9 @@ class Win32Socket::EventSink : public Win32Window {
void Dispose();
bool OnMessage(UINT uMsg,
WPARAM wParam,
LPARAM lParam,
LRESULT& result) override;
void OnNcDestroy() override;
virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
LRESULT& result);
virtual void OnNcDestroy();
private:
bool OnSocketNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result);
@ -833,20 +831,4 @@ 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();
~Win32Socket() override;
virtual ~Win32Socket();
bool CreateT(int family, int type);
@ -38,27 +38,25 @@ class Win32Socket : public AsyncSocket {
void SetTimeout(int ms);
// AsyncSocket Interface
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;
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);
private:
void CreateSink();
@ -95,22 +93,22 @@ class Win32Socket : public AsyncSocket {
class Win32SocketServer : public SocketServer {
public:
Win32SocketServer();
~Win32SocketServer() override;
virtual ~Win32SocketServer();
void set_modeless_dialog(HWND hdlg) {
hdlg_ = hdlg;
}
// SocketServer Interface
Socket* CreateSocket(int type) override;
Socket* CreateSocket(int family, int type) override;
virtual Socket* CreateSocket(int type);
virtual Socket* CreateSocket(int family, int type);
AsyncSocket* CreateAsyncSocket(int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
virtual AsyncSocket* CreateAsyncSocket(int type);
virtual AsyncSocket* CreateAsyncSocket(int family, int type);
void SetMessageQueue(MessageQueue* queue) override;
bool Wait(int cms, bool process_io) override;
void WakeUp() override;
virtual void SetMessageQueue(MessageQueue* queue);
virtual bool Wait(int cms, bool process_io);
virtual void WakeUp();
void Pump();
@ -121,7 +119,7 @@ class Win32SocketServer : public SocketServer {
public:
explicit MessageWindow(Win32SocketServer* ss) : ss_(ss) {}
private:
bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result) override;
virtual bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result);
Win32SocketServer* ss_;
};
@ -139,12 +137,18 @@ class Win32SocketServer : public SocketServer {
class Win32Thread : public Thread {
public:
explicit Win32Thread(SocketServer* ss);
~Win32Thread() override;
void Run() override;
void Quit() override;
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);
}
private:
DWORD id_;
};

18
rtc_base/win32window.cc
View File

@ -87,20 +87,10 @@ bool Win32Window::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
return false;
}
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));
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();
virtual void OnNcDestroy();
virtual bool OnClose() { return true; }
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_; }
bool OnMessage(UINT uMsg,
WPARAM wParam,
LPARAM lParam,
LRESULT& result) override {
virtual bool OnMessage(UINT uMsg, WPARAM wParam,
LPARAM lParam, LRESULT& result) {
msg_.message = uMsg;
msg_.wParam = wParam;
msg_.lParam = lParam;
result = kDummyResult;
return true;
}
void OnNcDestroy() override { destroyed_ = true; }
virtual void OnNcDestroy() {
destroyed_ = true;
}
private:
MSG msg_;