Cast: Make receiver use cast_transport

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 "base/bind.h"
@@ skipping 47 matching lines @@
       send_buffer_size_(send_buffer_size),
       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 PacketReceiverCallback& packet_receiver) {
+    const PacketReceiverCallbackWithStatus& packet_receiver) {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
 
   packet_receiver_ = packet_receiver;
   udp_socket_->SetMulticastLoopbackMode(true);
   if (!IsEmpty(local_addr_)) {
     if (udp_socket_->Open(local_addr_.GetFamily()) < 0 ||
         udp_socket_->AllowAddressReuse() < 0 ||
         udp_socket_->Bind(local_addr_) < 0) {
       udp_socket_->Close();
       status_callback_.Run(TRANSPORT_SOCKET_ERROR);
@@ skipping 13 matching lines @@
   } else {
     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());
+  packet_receiver_ = PacketReceiverCallbackWithStatus();
+}
+
+
 void UdpTransport::SetDscp(net::DiffServCodePoint dscp) {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
   next_dscp_value_ = dscp;
 }
 
 void UdpTransport::ScheduleReceiveNextPacket() {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
   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());
 
+  if (packet_receiver_.is_null())
+    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) {
     if (length_or_status == net::ERR_IO_PENDING) {
       next_packet_.reset(new Packet(kMaxPacketSize));
       recv_buf_ = new net::WrappedIOBuffer(
           reinterpret_cast<char*>(&next_packet_->front()));
       length_or_status =
           udp_socket_->RecvFrom(recv_buf_.get(),
@@ skipping 17 matching lines @@
 
     // Confirm the packet has come from the expected remote address; otherwise,
     // ignore it.  If this is the first packet being received and no remote
     // address has been set, set the remote address and expect all future
     // packets to come from the same one.
     // TODO(hubbe): We should only do this if the caller used a valid ssrc.
     if (IsEmpty(remote_addr_)) {
       remote_addr_ = recv_addr_;
       VLOG(1) << "Setting remote address from first received packet: "
               << remote_addr_.ToString();
+      next_packet_->resize(length_or_status);
+      if (!packet_receiver_.Run(next_packet_.Pass())) {
+        VLOG(1) << "Packet was not valid, resetting remote address.";
+        remote_addr_ = net::IPEndPoint();
+      }
     } else if (!IsEqual(remote_addr_, recv_addr_)) {
       VLOG(1) << "Ignoring packet received from an unrecognized address: "
               << recv_addr_.ToString() << ".";
-      length_or_status = net::ERR_IO_PENDING;
-      continue;
+    } else {
+      next_packet_->resize(length_or_status);
+      packet_receiver_.Run(next_packet_.Pass());
     }
-
-    next_packet_->resize(length_or_status);
-    packet_receiver_.Run(next_packet_.Pass());
     length_or_status = net::ERR_IO_PENDING;
   }
 }
 
 bool UdpTransport::SendPacket(PacketRef packet, const base::Closure& cb) {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
 
   // Increase byte count no matter the packet was sent or dropped.
   bytes_sent_ += packet->data.size();
 
@@ skipping 66 matching lines @@
   }
   ScheduleReceiveNextPacket();
 
   if (!cb.is_null()) {
     cb.Run();
   }
 }
 
 }  // namespace cast
 }  // namespace media