Replace deprecated base::NonThreadSafe in content/renderer/p2p in favor of SequenceChecker.

content/renderer/p2p/ipc_socket_factory.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/p2p/ipc_socket_factory.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/sequence_checker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
-#include "base/threading/non_thread_safe.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/p2p/host_address_request.h"
 #include "content/renderer/p2p/socket_client_delegate.h"
 #include "content/renderer/p2p/socket_client_impl.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "jingle/glue/utils.h"
 #include "net/base/ip_address.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
@@ skipping 177 matching lines @@
   size_t total_packets_;
 
   DISALLOW_COPY_AND_ASSIGN(IpcPacketSocket);
 };
 
 // Simple wrapper around P2PAsyncAddressResolver. The main purpose of this
 // class is to send SignalDone, after OnDone callback from
 // P2PAsyncAddressResolver. Libjingle sig slots are not thread safe. In case
 // of MT sig slots clients must call disconnect. This class is to make sure
 // we destruct from the same thread on which is created.
-class AsyncAddressResolverImpl :  public base::NonThreadSafe,
-                                  public rtc::AsyncResolverInterface {
+class AsyncAddressResolverImpl : public rtc::AsyncResolverInterface {
  public:
   AsyncAddressResolverImpl(P2PSocketDispatcher* dispatcher);
   ~AsyncAddressResolverImpl() override;
 
   // rtc::AsyncResolverInterface interface.
   void Start(const rtc::SocketAddress& addr) override;
   bool GetResolvedAddress(int family, rtc::SocketAddress* addr) const override;
   int GetError() const override;
   void Destroy(bool wait) override;
 
  private:
   virtual void OnAddressResolved(const net::IPAddressList& addresses);
 
   scoped_refptr<P2PAsyncAddressResolver> resolver_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
   int port_;   // Port number in |addr| from Start() method.
   std::vector<rtc::IPAddress> addresses_;  // Resolved addresses.
 };
 
 IpcPacketSocket::IpcPacketSocket()
     : type_(P2P_SOCKET_UDP),
       state_(IS_UNINITIALIZED),
       send_bytes_available_(kMaximumInFlightBytes),
       writable_signal_expected_(false),
       error_(0),
@@ skipping 427 matching lines @@
   SignalReadPacket(this, &data[0], data.size(), address_lj,
                    packet_time);
 }
 
 AsyncAddressResolverImpl::AsyncAddressResolverImpl(
     P2PSocketDispatcher* dispatcher)
     : resolver_(new P2PAsyncAddressResolver(dispatcher)) {
 }
 
 AsyncAddressResolverImpl::~AsyncAddressResolverImpl() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void AsyncAddressResolverImpl::Start(const rtc::SocketAddress& addr) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Copy port number from |addr|. |port_| must be copied
   // when resolved address is returned in GetResolvedAddress.
   port_ = addr.port();
 
   resolver_->Start(addr, base::Bind(
       &AsyncAddressResolverImpl::OnAddressResolved,
       base::Unretained(this)));
 }
 
 bool AsyncAddressResolverImpl::GetResolvedAddress(
     int family, rtc::SocketAddress* addr) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (addresses_.empty())
    return false;
 
   for (size_t i = 0; i < addresses_.size(); ++i) {
     if (family == addresses_[i].family()) {
       addr->SetResolvedIP(addresses_[i]);
       addr->SetPort(port_);
       return true;
     }
   }
   return false;
 }
 
 int AsyncAddressResolverImpl::GetError() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return addresses_.empty() ? -1 : 0;
 }
 
 void AsyncAddressResolverImpl::Destroy(bool wait) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   resolver_->Cancel();
   // Libjingle doesn't need this object any more and it's not going to delete
   // it explicitly.
   delete this;
 }
 
 void AsyncAddressResolverImpl::OnAddressResolved(
     const net::IPAddressList& addresses) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (size_t i = 0; i < addresses.size(); ++i) {
     rtc::SocketAddress socket_address;
     if (!jingle_glue::IPEndPointToSocketAddress(
             net::IPEndPoint(addresses[i], 0), &socket_address)) {
       NOTREACHED();
     }
     addresses_.push_back(socket_address.ipaddr());
   }
   SignalDone(this);
 }
@@ skipping 68 matching lines @@
 }
 
 rtc::AsyncResolverInterface*
 IpcPacketSocketFactory::CreateAsyncResolver() {
   std::unique_ptr<AsyncAddressResolverImpl> resolver(
       new AsyncAddressResolverImpl(socket_dispatcher_));
   return resolver.release();
 }
 
 }  // namespace content