Cast: Switching recevier to use media::VideoFrame

media/cast/test/transport/transport.cc

 // Copyright 2013 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/test/transport/transport.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
-#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
 
 namespace media {
 namespace cast {
 namespace test {
 
 const int kMaxPacketSize = 1500;
 
 class LocalUdpTransportData;
 
 void CreateUDPAddress(std::string ip_str, int port, net::IPEndPoint* address) {
   net::IPAddressNumber ip_number;
   bool rv = net::ParseIPLiteralToNumber(ip_str, &ip_number);
   if (!rv)
     return;
   *address = net::IPEndPoint(ip_number, port);
 }
 
 class LocalUdpTransportData
     : public base::RefCountedThreadSafe<LocalUdpTransportData> {
  public:
-  LocalUdpTransportData(net::DatagramServerSocket* udp_socket,
+  LocalUdpTransportData(net::UDPServerSocket* udp_socket,
                         scoped_refptr<base::TaskRunner> io_thread_proxy)
     : udp_socket_(udp_socket),
       buffer_(new net::IOBufferWithSize(kMaxPacketSize)),
       io_thread_proxy_(io_thread_proxy) {
   }
 
   void ListenTo(net::IPEndPoint bind_address) {
     DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
 
     bind_address_ = bind_address;
@@ skipping 37 matching lines @@
   void Close() {
     udp_socket_->Close();
   }
 
  protected:
   virtual ~LocalUdpTransportData() {}
 
  private:
   friend class base::RefCountedThreadSafe<LocalUdpTransportData>;
 
-  net::DatagramServerSocket* udp_socket_;
+  net::UDPServerSocket* udp_socket_;
   net::IPEndPoint bind_address_;
   PacketReceiver* packet_receiver_;
   scoped_refptr<net::IOBufferWithSize> buffer_;
   scoped_refptr<base::TaskRunner> io_thread_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalUdpTransportData);
 };
 
 class LocalPacketSender : public PacketSender,
                           public base::RefCountedThreadSafe<LocalPacketSender> {
  public:
-  LocalPacketSender(net::DatagramServerSocket* udp_socket,
+  LocalPacketSender(net::UDPServerSocket* udp_socket,
                     scoped_refptr<base::TaskRunner> io_thread_proxy)
       : udp_socket_(udp_socket),
         send_address_(),
         loss_limit_(0),
         io_thread_proxy_(io_thread_proxy) {}
 
   virtual bool SendPacket(const Packet& packet) OVERRIDE {
     io_thread_proxy_->PostTask(FROM_HERE,
     base::Bind(&LocalPacketSender::SendPacketToNetwork,
                this, packet));
@@ skipping 36 matching lines @@
   void SetSendAddress(const net::IPEndPoint& send_address) {
     send_address_ = send_address;
   }
 
  protected:
   virtual ~LocalPacketSender() {}
 
  private:
   friend class base::RefCountedThreadSafe<LocalPacketSender>;
 
-  net::DatagramServerSocket* udp_socket_;  // Not owned by this class.
+  net::UDPServerSocket* udp_socket_;  // Not owned by this class.
   net::IPEndPoint send_address_;
   int loss_limit_;
   scoped_refptr<base::TaskRunner> io_thread_proxy_;
 };
 
 Transport::Transport(
     scoped_refptr<base::TaskRunner> io_thread_proxy)
     : udp_socket_(new net::UDPServerSocket(NULL, net::NetLog::Source())),
       local_udp_transport_data_(new LocalUdpTransportData(udp_socket_.get(),
                                                           io_thread_proxy)),
@@ skipping 33 matching lines @@
 
 void Transport::SetSendDestination(std::string ip_address, int port) {
   net::IPEndPoint send_address;
   CreateUDPAddress(ip_address, port, &send_address);
   packet_sender_->SetSendAddress(send_address);
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media