Revert of Remove calls to MessageLoop::current() in content.

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/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.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 118 matching lines @@
                        const rtc::SocketAddress& remote_address);
 
   int DoSetOption(P2PSocketOption option, int value);
 
   // Allow a finch experiment to control the initial value of
   // send_bytes_available_;
   void AdjustUdpSendBufferSize();
 
   P2PSocketType type_;
 
-  // Used to verify that a method runs on the thread that created this socket.
-  base::ThreadChecker thread_checker_;
+  // Message loop on which this socket was created and being used.
+  base::MessageLoop* message_loop_;
 
   // Corresponding P2P socket client.
   scoped_refptr<P2PSocketClient> client_;
 
   // Local address is allocated by the browser process, and the
   // renderer side doesn't know the address until it receives OnOpen()
   // event from the browser.
   rtc::SocketAddress local_address_;
 
   // Remote address for client TCP connections.
@@ skipping 55 matching lines @@
  private:
   virtual void OnAddressResolved(const net::IPAddressList& addresses);
 
   scoped_refptr<P2PAsyncAddressResolver> resolver_;
   int port_;   // Port number in |addr| from Start() method.
   std::vector<rtc::IPAddress> addresses_;  // Resolved addresses.
 };
 
 IpcPacketSocket::IpcPacketSocket()
     : type_(P2P_SOCKET_UDP),
+      message_loop_(base::MessageLoop::current()),
       state_(IS_UNINITIALIZED),
       send_bytes_available_(kMaximumInFlightBytes),
       writable_signal_expected_(false),
       error_(0),
       max_discard_bytes_sequence_(0),
       current_discard_bytes_sequence_(0),
       packets_discarded_(0),
       total_packets_(0) {
   static_assert(kMaximumInFlightBytes > 0, "would send at zero rate");
   std::fill_n(options_, static_cast<int> (P2P_SOCKET_OPT_MAX),
@@ skipping 40 matching lines @@
 
   if (send_buffer_size > 0) {
     send_bytes_available_ = send_buffer_size;
   }
 }
 
 bool IpcPacketSocket::Init(P2PSocketType type,
                            P2PSocketClientImpl* client,
                            const rtc::SocketAddress& local_address,
                            const rtc::SocketAddress& remote_address) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(state_, IS_UNINITIALIZED);
 
   type_ = type;
   client_ = client;
   local_address_ = local_address;
   remote_address_ = remote_address;
   state_ = IS_OPENING;
 
   net::IPEndPoint local_endpoint;
   if (!jingle_glue::SocketAddressToIPEndPoint(
@@ skipping 27 matching lines @@
 
   client->Init(type, local_endpoint, remote_info, this);
 
   return true;
 }
 
 void IpcPacketSocket::InitAcceptedTcp(
     P2PSocketClient* client,
     const rtc::SocketAddress& local_address,
     const rtc::SocketAddress& remote_address) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(state_, IS_UNINITIALIZED);
 
   client_ = client;
   local_address_ = local_address;
   remote_address_ = remote_address;
   state_ = IS_OPEN;
   TraceSendThrottlingState();
   client_->SetDelegate(this);
 }
 
 // rtc::AsyncPacketSocket interface.
 rtc::SocketAddress IpcPacketSocket::GetLocalAddress() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return local_address_;
 }
 
 rtc::SocketAddress IpcPacketSocket::GetRemoteAddress() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return remote_address_;
 }
 
 int IpcPacketSocket::Send(const void *data, size_t data_size,
                           const rtc::PacketOptions& options) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return SendTo(data, data_size, remote_address_, options);
 }
 
 int IpcPacketSocket::SendTo(const void *data, size_t data_size,
                             const rtc::SocketAddress& address,
                             const rtc::PacketOptions& options) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   switch (state_) {
     case IS_UNINITIALIZED:
       NOTREACHED();
       error_ = EWOULDBLOCK;
       return -1;
     case IS_OPENING:
       error_ = EWOULDBLOCK;
       return -1;
     case IS_CLOSED:
@@ skipping 60 matching lines @@
 
   in_flight_packet_records_.push_back(
       InFlightPacketRecord(packet_id, data_size));
   TraceSendThrottlingState();
 
   // Fake successful send. The caller ignores result anyway.
   return data_size;
 }
 
 int IpcPacketSocket::Close() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   client_->Close();
   state_ = IS_CLOSED;
 
   return 0;
 }
 
 rtc::AsyncPacketSocket::State IpcPacketSocket::GetState() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   switch (state_) {
     case IS_UNINITIALIZED:
       NOTREACHED();
       return STATE_CLOSED;
 
     case IS_OPENING:
       return STATE_BINDING;
 
     case IS_OPEN:
@@ skipping 17 matching lines @@
   if (!JingleSocketOptionToP2PSocketOption(option, &p2p_socket_option)) {
     // unsupported option.
     return -1;
   }
 
   *value = options_[p2p_socket_option];
   return 0;
 }
 
 int IpcPacketSocket::SetOption(rtc::Socket::Option option, int value) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   P2PSocketOption p2p_socket_option = P2P_SOCKET_OPT_MAX;
   if (!JingleSocketOptionToP2PSocketOption(option, &p2p_socket_option)) {
     // Option is not supported.
     return -1;
   }
 
   options_[p2p_socket_option] = value;
 
   if (state_ == IS_OPEN) {
     // Options will be applied when state becomes IS_OPEN in OnOpen.
     return DoSetOption(p2p_socket_option, value);
   }
   return 0;
 }
 
 int IpcPacketSocket::DoSetOption(P2PSocketOption option, int value) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(state_, IS_OPEN);
 
   client_->SetOption(option, value);
   return 0;
 }
 
 int IpcPacketSocket::GetError() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return error_;
 }
 
 void IpcPacketSocket::SetError(int error) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   error_ = error;
 }
 
 void IpcPacketSocket::OnOpen(const net::IPEndPoint& local_address,
                              const net::IPEndPoint& remote_address) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   if (!jingle_glue::IPEndPointToSocketAddress(local_address, &local_address_)) {
     // Always expect correct IPv4 address to be allocated.
     NOTREACHED();
     OnError();
     return;
   }
 
   state_ = IS_OPEN;
   TraceSendThrottlingState();
@@ skipping 23 matching lines @@
 
     // SignalConnect after updating the |remote_address_| so that the listener
     // can get the resolved remote address.
     SignalConnect(this);
   }
 }
 
 void IpcPacketSocket::OnIncomingTcpConnection(
     const net::IPEndPoint& address,
     P2PSocketClient* client) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   std::unique_ptr<IpcPacketSocket> socket(new IpcPacketSocket());
 
   rtc::SocketAddress remote_address;
   if (!jingle_glue::IPEndPointToSocketAddress(address, &remote_address)) {
     // Always expect correct IPv4 address to be allocated.
     NOTREACHED();
   }
   socket->InitAcceptedTcp(client, local_address_, remote_address);
   SignalNewConnection(this, socket.release());
 }
 
 void IpcPacketSocket::OnSendComplete(const P2PSendPacketMetrics& send_metrics) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   CHECK(!in_flight_packet_records_.empty());
 
   const InFlightPacketRecord& record = in_flight_packet_records_.front();
 
   // Tracking is not turned on for TCP so it's always 0. For UDP, this will
   // cause a crash when the packet ids don't match.
   CHECK(send_metrics.packet_id == 0 ||
         record.packet_id == send_metrics.packet_id);
 
@@ skipping 16 matching lines @@
     WebRtcLogMessage(base::StringPrintf(
         "IpcPacketSocket: sending is unblocked. %d packets in flight.",
         static_cast<int>(in_flight_packet_records_.size())));
 
     SignalReadyToSend(this);
     writable_signal_expected_ = false;
   }
 }
 
 void IpcPacketSocket::OnError() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   bool was_closed = (state_ == IS_ERROR || state_ == IS_CLOSED);
   state_ = IS_ERROR;
   error_ = ECONNABORTED;
   if (!was_closed) {
     SignalClose(this, 0);
   }
 }
 
 void IpcPacketSocket::OnDataReceived(const net::IPEndPoint& address,
                                      const std::vector<char>& data,
                                      const base::TimeTicks& timestamp) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   rtc::SocketAddress address_lj;
 
   if (address.address().empty()) {
     DCHECK(IsTcpClientSocket(type_));
     // |address| could be empty for TCP connections behind a proxy.
     address_lj = remote_address_;
   } else {
     if (!jingle_glue::IPEndPointToSocketAddress(address, &address_lj)) {
       // We should always be able to convert address here because we
@@ skipping 144 matching lines @@
 }
 
 rtc::AsyncResolverInterface*
 IpcPacketSocketFactory::CreateAsyncResolver() {
   std::unique_ptr<AsyncAddressResolverImpl> resolver(
       new AsyncAddressResolverImpl(socket_dispatcher_));
   return resolver.release();
 }
 
 }  // namespace content