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}

rtc_base/BUILD.gn

@@ -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" ]
     }

rtc_base/buffer_unittest.cc

@@ -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;

rtc_base/fakesslidentity.cc

@@ -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

rtc_base/fakesslidentity.h

@@ -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)
+  explicit FakeSSLCertificate(const std::string& data);
-      : data_(data), digest_algorithm_(DIGEST_SHA_1), expiration_time_(-1) {}
+
-  explicit FakeSSLCertificate(const std::vector<std::string>& certs)
+  explicit FakeSSLCertificate(const std::vector<std::string>& certs);
-      : data_(certs.front()),
+
-        digest_algorithm_(DIGEST_SHA_1),
+  FakeSSLCertificate(const FakeSSLCertificate&);
-        expiration_time_(-1) {
+  ~FakeSSLCertificate() override;
-    std::vector<std::string>::const_iterator it;
+
-    // Skip certs[0].
+  // SSLCertificate implementation.
-    for (it = certs.begin() + 1; it != certs.end(); ++it) {
+  FakeSSLCertificate* GetReference() const override;
-      certs_.push_back(FakeSSLCertificate(*it));
+  std::string ToPEMString() const override;
-    }
+  void ToDER(Buffer* der_buffer) const override;
-  }
+  int64_t CertificateExpirationTime() const override;
-  FakeSSLCertificate* GetReference() const override {
+  bool GetSignatureDigestAlgorithm(std::string* algorithm) 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 {
+                     size_t* length) const override;
-    *length = rtc::ComputeDigest(algorithm, data_.c_str(), data_.size(),
+  std::unique_ptr<SSLCertChain> GetChain() const override;
-                                       digest, size);
+
-    return (*length != 0);
+  void SetCertificateExpirationTime(int64_t expiration_time);
-  }
+
-  std::unique_ptr<SSLCertChain> GetChain() const override {
+  void set_digest_algorithm(const std::string& algorithm);
-    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) {
@@ -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 std::string& data);
-  explicit FakeSSLIdentity(const FakeSSLCertificate& cert) : cert_(cert) {}
+  explicit FakeSSLIdentity(const FakeSSLCertificate& cert);
-  virtual FakeSSLIdentity* GetReference() const {
+
-    return new FakeSSLIdentity(*this);
+  // SSLIdentity implementation.
-  }
+  FakeSSLIdentity* GetReference() const override;
-  virtual const FakeSSLCertificate& certificate() const { return cert_; }
+  const FakeSSLCertificate& certificate() const override;
-  virtual std::string PrivateKeyToPEMString() const {
+  // Not implemented.
-    RTC_NOTREACHED();  // Not implemented.
+  std::string PrivateKeyToPEMString() const override;
-    return "";
+  // Not implemented.
-  }
+  std::string PublicKeyToPEMString() const override;
-  virtual std::string PublicKeyToPEMString() const {
+  // Not implemented.
-    RTC_NOTREACHED();  // Not implemented.
+  virtual bool operator==(const SSLIdentity& other) const;
-    return "";
+
-  }
-  virtual bool operator==(const SSLIdentity& other) const {
-    RTC_NOTREACHED();  // Not implemented.
-    return false;
-  }
  private:
   FakeSSLCertificate cert_;
 };

rtc_base/filerotatingstream_unittest.cc

@@ -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_);

rtc_base/httpbase_unittest.cc

@@ -56,14 +56,13 @@ public:
   };
   HttpBaseTest() : mem(nullptr), obtain_stream(false), http_stream(nullptr) {}
 
-  virtual void SetUp() { }
+  void TearDown() override {
-  virtual void TearDown() {
     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);

rtc_base/httpcommon.cc

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

rtc_base/messagequeue_unittest.cc

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

rtc_base/network.cc

@@ -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.

rtc_base/network.h

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

rtc_base/network_unittest.cc

@@ -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 &&

rtc_base/nullsocketserver_unittest.cc

@@ -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) {
+  void OnMessage(Message* message) override { ss_.WakeUp(); }
-    ss_.WakeUp();
+
-  }
   NullSocketServer ss_;
 };
 

rtc_base/physicalsocketserver.cc

@@ -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() {
+  WSAEVENT GetWSAEvent() override { return hev_; }
-    return hev_;
-  }
 
-  virtual SOCKET GetSocket() {
+  SOCKET GetSocket() override { return INVALID_SOCKET; }
-    return INVALID_SOCKET;
-  }
 
-  virtual bool CheckSignalClose() { return false; }
+  bool CheckSignalClose() override { return false; }
 
-private:
+ private:
   PhysicalSocketServer* ss_;
   WSAEVENT hev_;
 };

rtc_base/physicalsocketserver_unittest.cc

@@ -506,11 +506,9 @@ class PosixSignalDeliveryTest : public testing::Test {
   }
 
  protected:
-  void SetUp() {
+  void SetUp() override { ss_.reset(new PhysicalSocketServer()); }
-    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

rtc_base/proxy_unittest.cc

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

rtc_base/rtccertificate_unittest.cc

@@ -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(

rtc_base/rtccertificategenerator_unittest.cc

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

rtc_base/signalthread_unittest.cc

@@ -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);

rtc_base/sigslot_unittest.cc

@@ -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().

rtc_base/socket_unittest.cc

@@ -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) override { Thread::Current()->SleepMs(500); }
-  void OnMessage(Message* msg) {
-    Thread::Current()->SleepMs(500);
-  }
 };
 
 void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {

rtc_base/socket_unittest.h

@@ -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();

rtc_base/sslidentity_unittest.cc

@@ -207,12 +207,7 @@ IdentityAndInfo CreateFakeIdentityAndInfoFromDers(
 
 class SSLIdentityTest : public testing::Test {
  public:
-  SSLIdentityTest() {}
+  void SetUp() override {
-
-  ~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));
@@ -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);
   }

rtc_base/sslstreamadapter_unittest.cc

@@ -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);
   }

rtc_base/stream_unittest.cc

@@ -21,9 +21,12 @@ class TestStream : public StreamInterface {
  public:
   TestStream() : pos_(0) { }
 
-  virtual StreamState GetState() const { return SS_OPEN; }
+  StreamState GetState() const override { return SS_OPEN; }
-  virtual StreamResult Read(void* buffer, size_t buffer_len,
+
-                            size_t* read, int* error) {
+  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;
+  bool GetSize(size_t* size) const override { return false; }
-  }
+
-  virtual bool GetAvailable(size_t* size) const {
+  bool GetAvailable(size_t* size) const override { return false; }
-    return false;
-  }
 
  private:
   size_t pos_;

rtc_base/testechoserver.cc

@@ -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

rtc_base/testechoserver.h

@@ -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)
+  TestEchoServer(Thread* thread, const SocketAddress& addr);
-      : server_socket_(thread->socketserver()->CreateAsyncSocket(addr.family(),
+  ~TestEchoServer() override;
-                                                                 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(); }
 

rtc_base/testutils.cc

@@ -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

rtc_base/testutils.h

@@ -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() {
+ StreamSource();
-    Clear();
+ ~StreamSource() override;
-  }
 
-  void Clear() {
+ void Clear() {
-    readable_data_.clear();
+   readable_data_.clear();
-    written_data_.clear();
+   written_data_.clear();
-    state_ = SS_CLOSED;
+   state_ = SS_CLOSED;
-    read_block_ = 0;
+   read_block_ = 0;
-    write_block_ = SIZE_UNKNOWN;
+   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_; }
+  StreamState GetState() const override;
-  virtual StreamResult Read(void* buffer, size_t buffer_len,
+  StreamResult Read(void* buffer,
-                            size_t* read, int* error) {
+                    size_t buffer_len,
-    if (SS_CLOSED == state_) {
+                    size_t* read,
-      if (error) *error = -1;
+                    int* error) override;
-      return SR_ERROR;
+  StreamResult Write(const void* data,
-    }
+                     size_t data_len,
-    if ((SS_OPENING == state_) || (readable_data_.size() <= read_block_)) {
+                     size_t* written,
-      return SR_BLOCK;
+                     int* error) override;
-    }
+  void Close() override;
-    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_;
@@ -277,28 +244,22 @@ private:
 
 class SocketTestClient : public sigslot::has_slots<> {
 public:
- SocketTestClient() { Init(nullptr, AF_INET); }
+ SocketTestClient();
- SocketTestClient(AsyncSocket* socket) {
+ SocketTestClient(AsyncSocket* socket);
-   Init(socket, socket->GetLocalAddress().family());
+ SocketTestClient(const SocketAddress& address);
-  }
+ ~SocketTestClient() override;
-  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) {
+ void QueueString(const char* data) { QueueData(data, strlen(data)); }
-    QueueData(data, strlen(data));
+ void QueueStringF(const char* format, ...) {
-  }
+   va_list args;
-  void QueueStringF(const char* format, ...) {
+   va_start(args, format);
-    va_list args;
+   char buffer[1024];
-    va_start(args, format);
+   size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
-    char buffer[1024];
+   RTC_CHECK(len < sizeof(buffer) - 1);
-    size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
+   va_end(args);
-    RTC_CHECK(len < sizeof(buffer) - 1);
+   QueueData(buffer, len);
-    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)
+  SocketTestServer(const SocketAddress& address);
-      : socket_(Thread::Current()->socketserver()
+  ~SocketTestServer() override;
-                ->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]; }

rtc_base/thread_unittest.cc

@@ -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() {
+  ~SocketClient() override { delete socket_; }
-    delete socket_;
-  }
 
   SocketAddress address() const { return socket_->GetLocalAddress(); }
 
@@ -90,11 +87,9 @@ class MessageClient : public MessageHandler, public TestGenerator {
       : socket_(socket) {
   }
 
-  virtual ~MessageClient() {
+  ~MessageClient() override { delete socket_; }
-    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.
   }
 

rtc_base/virtualsocket_unittest.cc

@@ -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() {
+  ~Receiver() override { thread->Clear(this); }
-    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)

rtc_base/win32socketserver.cc

@@ -152,9 +152,11 @@ class Win32Socket::EventSink : public Win32Window {
 
   void Dispose();
 
-  virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
+  bool OnMessage(UINT uMsg,
-                         LRESULT& result);
+                 WPARAM wParam,
-  virtual void OnNcDestroy();
+                 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

rtc_base/win32socketserver.h

@@ -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;
+  SocketAddress GetLocalAddress() const override;
-  virtual SocketAddress GetRemoteAddress() const;
+  SocketAddress GetRemoteAddress() const override;
-  virtual int Bind(const SocketAddress& addr);
+  int Bind(const SocketAddress& addr) override;
-  virtual int Connect(const SocketAddress& addr);
+  int Connect(const SocketAddress& addr) override;
-  virtual int Send(const void *buffer, size_t length);
+  int Send(const void* buffer, size_t length) override;
-  virtual int SendTo(const void *buffer, size_t length, const SocketAddress& addr);
+  int SendTo(const void* buffer,
-  virtual int Recv(void* buffer, size_t length, int64_t* timestamp);
+             size_t length,
-  virtual int RecvFrom(void* buffer,
+             const SocketAddress& addr) override;
-                       size_t length,
+  int Recv(void* buffer, size_t length, int64_t* timestamp) override;
-                       SocketAddress* out_addr,
+  int RecvFrom(void* buffer,
-                       int64_t* timestamp);
+               size_t length,
-  virtual int Listen(int backlog);
+               SocketAddress* out_addr,
-  virtual Win32Socket *Accept(SocketAddress *out_addr);
+               int64_t* timestamp) override;
-  virtual int Close();
+  int Listen(int backlog) override;
-  virtual int GetError() const;
+  Win32Socket* Accept(SocketAddress* out_addr) override;
-  virtual void SetError(int error);
+  int Close() override;
-  virtual ConnState GetState() const;
+  int GetError() const override;
-  virtual int GetOption(Option opt, int* value);
+  void SetError(int error) override;
-  virtual int SetOption(Option opt, int value);
+  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);
+  Socket* CreateSocket(int type) override;
-  virtual Socket* CreateSocket(int family, int type);
+  Socket* CreateSocket(int family, int type) override;
 
-  virtual AsyncSocket* CreateAsyncSocket(int type);
+  AsyncSocket* CreateAsyncSocket(int type) override;
-  virtual AsyncSocket* CreateAsyncSocket(int family, int type);
+  AsyncSocket* CreateAsyncSocket(int family, int type) override;
 
-  virtual void SetMessageQueue(MessageQueue* queue);
+  void SetMessageQueue(MessageQueue* queue) override;
-  virtual bool Wait(int cms, bool process_io);
+  bool Wait(int cms, bool process_io) override;
-  virtual void WakeUp();
+  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) {}
+  explicit Win32Thread(SocketServer* ss);
-  virtual ~Win32Thread() {
+  ~Win32Thread() override;
-    Stop();
+
-  }
+  void Run() override;
-  virtual void Run() {
+  void Quit() override;
-    id_ = GetCurrentThreadId();
+
-    Thread::Run();
-    id_ = 0;
-  }
-  virtual void Quit() {
-    PostThreadMessage(id_, WM_QUIT, 0, 0);
-  }
  private:
   DWORD id_;
 };

rtc_base/win32window.cc

@@ -87,10 +87,20 @@ bool Win32Window::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
   return false;
 }
 
-LRESULT Win32Window::WndProc(HWND hwnd, UINT uMsg,
+bool Win32Window::OnClose() {
-                             WPARAM wParam, LPARAM lParam) {
+  return true;
-  Win32Window* that = reinterpret_cast<Win32Window*>(
+}
-      ::GetWindowLongPtr(hwnd, GWLP_USERDATA));
+
+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);

rtc_base/win32window.h

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

rtc_base/win32window_unittest.cc

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