Rename TaskRunner::RunsTasksOnCurrentThread() in //media, //ui, //ipc

media/cast/net/udp_transport.cc

 // Copyright 2014 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 "media/cast/net/udp_transport.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 70 matching lines @@
       status_callback_(status_callback),
       bytes_sent_(0),
       weak_factory_(this) {
   DCHECK(!IsEmpty(local_end_point) || !IsEmpty(remote_end_point));
 }
 
 UdpTransport::~UdpTransport() {}
 
 void UdpTransport::StartReceiving(
     const PacketReceiverCallbackWithStatus& packet_receiver) {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
 
   if (!udp_socket_) {
     status_callback_.Run(TRANSPORT_SOCKET_ERROR);
     return;
   }
 
   packet_receiver_ = packet_receiver;
   udp_socket_->SetMulticastLoopbackMode(true);
   if (!IsEmpty(local_addr_)) {
     if (udp_socket_->Open(local_addr_.GetFamily()) < 0 ||
@@ skipping 20 matching lines @@
     NOTREACHED() << "Either local or remote address has to be defined.";
   }
   if (udp_socket_->SetSendBufferSize(send_buffer_size_) != net::OK) {
     LOG(WARNING) << "Failed to set socket send buffer size.";
   }
 
   ScheduleReceiveNextPacket();
 }
 
 void UdpTransport::StopReceiving() {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
   packet_receiver_ = PacketReceiverCallbackWithStatus();
 }
 
 
 void UdpTransport::SetDscp(net::DiffServCodePoint dscp) {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
   next_dscp_value_ = dscp;
 }
 
 #if defined(OS_WIN)
 void UdpTransport::UseNonBlockingIO() {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
   if (!udp_socket_)
     return;
   udp_socket_->UseNonBlockingIO();
 }
 #endif
 
 void UdpTransport::ScheduleReceiveNextPacket() {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
   if (!packet_receiver_.is_null() && !receive_pending_) {
     receive_pending_ = true;
     io_thread_proxy_->PostTask(FROM_HERE,
                                base::Bind(&UdpTransport::ReceiveNextPacket,
                                           weak_factory_.GetWeakPtr(),
                                           net::ERR_IO_PENDING));
   }
 }
 
 void UdpTransport::ReceiveNextPacket(int length_or_status) {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
 
   if (packet_receiver_.is_null())
     return;
   if (!udp_socket_)
     return;
 
   // Loop while UdpSocket is delivering data synchronously.  When it responds
   // with a "pending" status, break and expect this method to be called back in
   // the future when a packet is ready.
   while (true) {
@@ skipping 38 matching lines @@
               << recv_addr_.ToString() << ".";
     } else {
       next_packet_->resize(length_or_status);
       packet_receiver_.Run(std::move(next_packet_));
     }
     length_or_status = net::ERR_IO_PENDING;
   }
 }
 
 bool UdpTransport::SendPacket(PacketRef packet, const base::Closure& cb) {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
   if (!udp_socket_)
     return true;
 
   // Increase byte count no matter the packet was sent or dropped.
   bytes_sent_ += packet->data.size();
 
   DCHECK(!send_pending_);
   if (send_pending_) {
     VLOG(1) << "Cannot send because of pending IO.";
     return true;
@@ skipping 47 matching lines @@
 }
 
 int64_t UdpTransport::GetBytesSent() {
   return bytes_sent_;
 }
 
 void UdpTransport::OnSent(const scoped_refptr<net::IOBuffer>& buf,
                           PacketRef packet,
                           const base::Closure& cb,
                           int result) {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_proxy_->RunsTasksInCurrentSequence());
 
   send_pending_ = false;
   if (result < 0) {
     VLOG(1) << "Failed to send packet: " << result << ".";
   }
   ScheduleReceiveNextPacket();
 
   if (!cb.is_null()) {
     cb.Run();
   }
@@ skipping 12 matching lines @@
   }
 #endif
 }
 
 void UdpTransport::SetSendBufferSize(int32_t send_buffer_size) {
   send_buffer_size_ = send_buffer_size;
 }
 
 }  // namespace cast
 }  // namespace media