diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index 8490a60351..710de7af8d 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -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" ]
     }
diff --git a/rtc_base/buffer_unittest.cc b/rtc_base/buffer_unittest.cc
index 5cd18891b9..2eaf6f4b06 100644
--- a/rtc_base/buffer_unittest.cc
+++ b/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;
diff --git a/rtc_base/fakesslidentity.cc b/rtc_base/fakesslidentity.cc
deleted file mode 100644
index 296f09c918..0000000000
--- a/rtc_base/fakesslidentity.cc
+++ /dev/null
@@ -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
diff --git a/rtc_base/fakesslidentity.h b/rtc_base/fakesslidentity.h
index 52aaf05558..30507290e0 100644
--- a/rtc_base/fakesslidentity.h
+++ b/rtc_base/fakesslidentity.h
@@ -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_;
 };
diff --git a/rtc_base/filerotatingstream_unittest.cc b/rtc_base/filerotatingstream_unittest.cc
index 16db280d21..3507ba5260 100644
--- a/rtc_base/filerotatingstream_unittest.cc
+++ b/rtc_base/filerotatingstream_unittest.cc
@@ -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_);
diff --git a/rtc_base/httpbase_unittest.cc b/rtc_base/httpbase_unittest.cc
index 4c92f9b45c..f3e950bf18 100644
--- a/rtc_base/httpbase_unittest.cc
+++ b/rtc_base/httpbase_unittest.cc
@@ -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);
diff --git a/rtc_base/httpcommon.cc b/rtc_base/httpcommon.cc
index b2e48691e5..a22f0a6aad 100644
--- a/rtc_base/httpcommon.cc
+++ b/rtc_base/httpcommon.cc
@@ -703,7 +703,7 @@ struct NegotiateAuthContext : public HttpAuthContext {
     specified_credentials(false)
   { }
 
-  ~NegotiateAuthContext() override {
+  virtual ~NegotiateAuthContext() {
     DeleteSecurityContext(&ctx);
     FreeCredentialsHandle(&cred);
   }
diff --git a/rtc_base/messagequeue_unittest.cc b/rtc_base/messagequeue_unittest.cc
index aa94962387..b7528cf7b2 100644
--- a/rtc_base/messagequeue_unittest.cc
+++ b/rtc_base/messagequeue_unittest.cc
@@ -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_;
 };
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index bfe0fce12d..407c5de752 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -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.
diff --git a/rtc_base/network.h b/rtc_base/network.h
index 5755699fcd..6bddf4626a 100644
--- a/rtc_base/network.h
+++ b/rtc_base/network.h
@@ -288,7 +288,6 @@ class Network {
           const IPAddress& prefix,
           int prefix_length,
           AdapterType type);
-  Network(const Network&);
   ~Network();
 
   sigslot::signal1<const Network*> SignalTypeChanged;
diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc
index 49b5e04b44..29349b477c 100644
--- a/rtc_base/network_unittest.cc
+++ b/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 (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 &&
diff --git a/rtc_base/nullsocketserver_unittest.cc b/rtc_base/nullsocketserver_unittest.cc
index e3d9952f77..29f4980c26 100644
--- a/rtc_base/nullsocketserver_unittest.cc
+++ b/rtc_base/nullsocketserver_unittest.cc
@@ -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_;
 };
 
diff --git a/rtc_base/physicalsocketserver.cc b/rtc_base/physicalsocketserver.cc
index db27827734..d61e3e738a 100644
--- a/rtc_base/physicalsocketserver.cc
+++ b/rtc_base/physicalsocketserver.cc
@@ -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_;
 };
diff --git a/rtc_base/physicalsocketserver_unittest.cc b/rtc_base/physicalsocketserver_unittest.cc
index 2320e97081..36d1881485 100644
--- a/rtc_base/physicalsocketserver_unittest.cc
+++ b/rtc_base/physicalsocketserver_unittest.cc
@@ -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
diff --git a/rtc_base/proxy_unittest.cc b/rtc_base/proxy_unittest.cc
index 7d7b6f8913..d236002348 100644
--- a/rtc_base/proxy_unittest.cc
+++ b/rtc_base/proxy_unittest.cc
@@ -37,6 +37,7 @@ class ProxyTest : public testing::Test {
     https_.reset(new rtc::HttpListenServer());
     https_->Listen(kHttpsProxyIntAddr);
   }
+  ~ProxyTest() {}
 
   rtc::SocketServer* ss() { return ss_.get(); }
 
diff --git a/rtc_base/rtccertificate_unittest.cc b/rtc_base/rtccertificate_unittest.cc
index 04a76764ec..980e1a82fd 100644
--- a/rtc_base/rtccertificate_unittest.cc
+++ b/rtc_base/rtccertificate_unittest.cc
@@ -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(
diff --git a/rtc_base/rtccertificategenerator_unittest.cc b/rtc_base/rtccertificategenerator_unittest.cc
index 9a0ad0cb8d..4ff6880567 100644
--- a/rtc_base/rtccertificategenerator_unittest.cc
+++ b/rtc_base/rtccertificategenerator_unittest.cc
@@ -72,6 +72,7 @@ class RTCCertificateGeneratorTest
  public:
   RTCCertificateGeneratorTest()
       : fixture_(new RefCountedObject<RTCCertificateGeneratorFixture>()) {}
+  ~RTCCertificateGeneratorTest() {}
 
  protected:
   static const int kGenerationTimeoutMs = 10000;
diff --git a/rtc_base/signalthread_unittest.cc b/rtc_base/signalthread_unittest.cc
index 078710b2ca..e434c81b48 100644
--- a/rtc_base/signalthread_unittest.cc
+++ b/rtc_base/signalthread_unittest.cc
@@ -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);
diff --git a/rtc_base/sigslot_unittest.cc b/rtc_base/sigslot_unittest.cc
index 234bf4547f..e60d301323 100644
--- a/rtc_base/sigslot_unittest.cc
+++ b/rtc_base/sigslot_unittest.cc
@@ -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().
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index 9e44572c14..5548c0262e 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -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) {
diff --git a/rtc_base/socket_unittest.h b/rtc_base/socket_unittest.h
index 55df219eea..41835d2c5c 100644
--- a/rtc_base/socket_unittest.h
+++ b/rtc_base/socket_unittest.h
@@ -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();
diff --git a/rtc_base/sslidentity_unittest.cc b/rtc_base/sslidentity_unittest.cc
index 69322985c7..7d9f82c2c6 100644
--- a/rtc_base/sslidentity_unittest.cc
+++ b/rtc_base/sslidentity_unittest.cc
@@ -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);
   }
diff --git a/rtc_base/sslstreamadapter_unittest.cc b/rtc_base/sslstreamadapter_unittest.cc
index 3999ac5411..03aabd8a79 100644
--- a/rtc_base/sslstreamadapter_unittest.cc
+++ b/rtc_base/sslstreamadapter_unittest.cc
@@ -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);
   }
diff --git a/rtc_base/stream_unittest.cc b/rtc_base/stream_unittest.cc
index 8c305c5a19..fc0ecf8845 100644
--- a/rtc_base/stream_unittest.cc
+++ b/rtc_base/stream_unittest.cc
@@ -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_;
diff --git a/rtc_base/testechoserver.cc b/rtc_base/testechoserver.cc
deleted file mode 100644
index a5eb7de687..0000000000
--- a/rtc_base/testechoserver.cc
+++ /dev/null
@@ -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
diff --git a/rtc_base/testechoserver.h b/rtc_base/testechoserver.h
index 672dda0f18..7ef512da12 100644
--- a/rtc_base/testechoserver.h
+++ b/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,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(); }
 
diff --git a/rtc_base/testutils.cc b/rtc_base/testutils.cc
deleted file mode 100644
index 53fb03e8e9..0000000000
--- a/rtc_base/testutils.cc
+++ /dev/null
@@ -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
diff --git a/rtc_base/testutils.h b/rtc_base/testutils.h
index 1c4a6b351b..e05488052b 100644
--- a/rtc_base/testutils.h
+++ b/rtc_base/testutils.h
@@ -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]; }
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index 5f00064eb1..dfaa51a0ac 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -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.
   }
 
diff --git a/rtc_base/virtualsocket_unittest.cc b/rtc_base/virtualsocket_unittest.cc
index 6081346e85..785d32c5c4 100644
--- a/rtc_base/virtualsocket_unittest.cc
+++ b/rtc_base/virtualsocket_unittest.cc
@@ -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)
diff --git a/rtc_base/win32socketserver.cc b/rtc_base/win32socketserver.cc
index 72d352d398..889e49537f 100644
--- a/rtc_base/win32socketserver.cc
+++ b/rtc_base/win32socketserver.cc
@@ -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
diff --git a/rtc_base/win32socketserver.h b/rtc_base/win32socketserver.h
index ce29bc5003..63b662c715 100644
--- a/rtc_base/win32socketserver.h
+++ b/rtc_base/win32socketserver.h
@@ -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_;
 };
diff --git a/rtc_base/win32window.cc b/rtc_base/win32window.cc
index 9e9c83988e..f55a8ba8fb 100644
--- a/rtc_base/win32window.cc
+++ b/rtc_base/win32window.cc
@@ -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);
diff --git a/rtc_base/win32window.h b/rtc_base/win32window.h
index fa026d118a..c7b7fa9d16 100644
--- a/rtc_base/win32window.h
+++ b/rtc_base/win32window.h
@@ -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,
diff --git a/rtc_base/win32window_unittest.cc b/rtc_base/win32window_unittest.cc
index c659349e0e..f1d8e84af8 100644
--- a/rtc_base/win32window_unittest.cc
+++ b/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_; }
 
-  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_;