ThreadScope concept to check variable accessed on correct thread

webrtc/p2p/stunprober/stunprober.cc

 /*
  *  Copyright 2015 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 <map>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/asyncresolverinterface.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/thread.h"
+#include "webrtc/base/thread_scope.h"
 #include "webrtc/p2p/base/packetsocketfactory.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/p2p/stunprober/stunprober.h"
 
 namespace stunprober {
 
 namespace {
 
 const int THREAD_WAKE_UP_INTERVAL_MS = 5;
 
@@ skipping 55 matching lines @@
 
   StunProber* prober_;
 
   // The socket for this session.
   std::unique_ptr<rtc::AsyncPacketSocket> socket_;
 
   // Temporary SocketAddress and buffer for RecvFrom.
   rtc::SocketAddress addr_;
   std::unique_ptr<rtc::ByteBufferWriter> response_packet_;
 
-  std::vector<Request*> requests_;
+  std::vector<Request*> requests_ GUARDED_BY(thread_checker_);
   std::vector<rtc::SocketAddress> server_ips_;
   int16_t num_request_sent_ = 0;
   int16_t num_response_received_ = 0;
 
   rtc::ThreadChecker& thread_checker_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Requester);
 };
 
 StunProber::Requester::Requester(
@@ skipping 14 matching lines @@
     socket_->Close();
   }
   for (auto req : requests_) {
     if (req) {
       delete req;
     }
   }
 }
 
 void StunProber::Requester::SendStunRequest() {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   requests_.push_back(new Request());
   Request& request = *(requests_.back());
   cricket::StunMessage message;
 
   // Random transaction ID, STUN_BINDING_REQUEST
   message.SetTransactionID(
       rtc::CreateRandomString(cricket::kStunTransactionIdLength));
   message.SetType(cricket::STUN_BINDING_REQUEST);
 
   std::unique_ptr<rtc::ByteBufferWriter> request_packet(
@@ skipping 66 matching lines @@
     prober_->ReportOnFinished(GENERIC_FAILURE);
     return;
   }
 
   num_response_received_++;
   request->ProcessResponse(buf, size);
 }
 
 StunProber::Requester::Request* StunProber::Requester::GetRequestByAddress(
     const rtc::IPAddress& ipaddr) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   for (auto request : requests_) {
     if (request->server_addr == ipaddr) {
       return request;
     }
   }
 
   return nullptr;
 }
 
 StunProber::StunProber(rtc::PacketSocketFactory* socket_factory,
@@ skipping 330 matching lines @@
   }
 }
 
 void StunProber::ReportOnFinished(StunProber::Status status) {
   if (observer_) {
     observer_->OnFinished(this, status);
   }
 }
 
 }  // namespace stunprober