Cast: Make castv2 mirroring performance test run again

media/cast/test/utility/udp_proxy.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/test/utility/udp_proxy.h"
 
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/rand_util.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 392 matching lines @@
  public:
   UDPProxyImpl(const net::IPEndPoint& local_port,
                const net::IPEndPoint& destination,
                scoped_ptr<PacketPipe> to_dest_pipe,
                scoped_ptr<PacketPipe> from_dest_pipe,
                net::NetLog* net_log) :
       local_port_(local_port),
       destination_(destination),
       proxy_thread_("media::cast::test::UdpProxy Thread"),
       to_dest_pipe_(to_dest_pipe.Pass()),
-      from_dest_pipe_(to_dest_pipe.Pass()),
-      start_event_(false, false) {
+      from_dest_pipe_(to_dest_pipe.Pass()) {
     proxy_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+    base::WaitableEvent start_event(false, false);
     proxy_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&UDPProxyImpl::Start,
                    base::Unretained(this),
+                   base::Unretained(&start_event),
                    net_log));
-    start_event_.Wait();
+    start_event.Wait();
   }
 
-  void Start(net::NetLog* net_log) {
+  virtual ~UDPProxyImpl() {
+    base::WaitableEvent stop_event(false, false);
+    proxy_thread_.message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(&UDPProxyImpl::Stop,
+                   base::Unretained(this),
+                   base::Unretained(&stop_event)));
+    stop_event.Wait();
+    proxy_thread_.Stop();
+  }
+
+ private:
+  void Start(base::WaitableEvent* start_event,
+             net::NetLog* net_log) {
     socket_.reset(new net::UDPSocket(net::DatagramSocket::DEFAULT_BIND,
                                      net::RandIntCallback(),
                                      net_log,
                                      net::NetLog::Source()));
     BuildPipe(&to_dest_pipe_, new PacketSender(socket_.get(), &destination_));
     BuildPipe(&from_dest_pipe_,
               new PacketSender(socket_.get(), &return_address_));
     to_dest_pipe_->InitOnIOThread();
     from_dest_pipe_->InitOnIOThread();
 
     VLOG(0) << "From:" << local_port_.ToString();
     VLOG(0) << "To:" << destination_.ToString();
 
     CHECK_GE(socket_->Bind(local_port_), 0);
 
-    start_event_.Signal();
+    start_event->Signal();
     PollRead();
   }
 
-  virtual ~UDPProxyImpl() {
-    proxy_thread_.Stop();
+  void Stop(base::WaitableEvent* stop_event) {
+    to_dest_pipe_.reset(NULL);
+    from_dest_pipe_.reset(NULL);
+    socket_.reset(NULL);
+    stop_event->Signal();
   }
 
   void ProcessPacket(scoped_refptr<net::IOBuffer> recv_buf,
                      int len) {
     DCHECK_NE(len, net::ERR_IO_PENDING);
     VLOG(1) << "Got packet, len = " << len;
     if (len < 0) {
       LOG(WARNING) << "Socket read error: " << len;
       return;
     }
@@ skipping 24 matching lines @@
           &recv_address_,
           base::Bind(&UDPProxyImpl::ReadCallback,
                      base::Unretained(this),
                      recv_buf));
       if (len == net::ERR_IO_PENDING)
         break;
       ProcessPacket(recv_buf, len);
     }
   }
 
- private:
+
   net::IPEndPoint local_port_;
   net::IPEndPoint destination_;
   net::IPEndPoint recv_address_;
   net::IPEndPoint return_address_;
   base::Thread proxy_thread_;
   scoped_ptr<net::UDPSocket> socket_;
   scoped_ptr<PacketPipe> to_dest_pipe_;
   scoped_ptr<PacketPipe> from_dest_pipe_;
-  base::WaitableEvent start_event_;
   scoped_ptr<transport::Packet> packet_;
 };
 
 scoped_ptr<UDPProxy> UDPProxy::Create(
     const net::IPEndPoint& local_port,
     const net::IPEndPoint& destination,
     scoped_ptr<PacketPipe> to_dest_pipe,
     scoped_ptr<PacketPipe> from_dest_pipe,
     net::NetLog* net_log) {
   scoped_ptr<UDPProxy> ret(new UDPProxyImpl(local_port,
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media