Delete method MessageQueue::set_socketserver

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 128 matching lines @@
   size_t sec_count;
   double sum;
   double sum_sq;
   uint32_t samples;
 };
 
 class VirtualSocketServerTest : public testing::Test {
  public:
   VirtualSocketServerTest()
       : ss_(new VirtualSocketServer(nullptr)),
+        thread_(ss_.get()),
         kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
         kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
 
   void CheckPortIncrementalization(const SocketAddress& post,
                                    const SocketAddress& pre) {
     EXPECT_EQ(post.port(), pre.port() + 1);
     IPAddress post_ip = post.ipaddr();
     IPAddress pre_ip = pre.ipaddr();
     EXPECT_EQ(pre_ip.family(), post_ip.family());
     if (post_ip.family() == AF_INET) {
@@ skipping 37 matching lines @@
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
     EXPECT_EQ(client1_addr,
               SocketAddress(default_route, client1_any_addr.port()));
 
     // Client2 can send back to client1's default route address.
     EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
   }
 
   void BasicTest(const SocketAddress& initial_addr) {

[nisse-webrtc, 2017/05/05 07:58:36]

I don't see how this test can ever have passed the memcheck, it's full of raw
pointers and allocations without corresponding deallocations.

Local run of 

valgrind ./out/Debug/webrtc_nonparallell_tests --gtest_filter='VirtualSocket*'

reports lots of leaks, also on the master branch. And I find no obvious
supressions either (looking in tools-webrtc/valgrind/memcheck/).

[Taylor Brandstetter, 2017/05/05 08:47:46]

My guess is that Thread indirectly references the sockets that are leaked, and
previously the global auto-wrap Thread would never be deleted, so the sockets
weren't detected as leaked.

But these are definitely leaks.

     AsyncSocket* socket = ss_->CreateAsyncSocket(initial_addr.family(),
                                                  SOCK_DGRAM);
     socket->Bind(initial_addr);
     SocketAddress server_addr = socket->GetLocalAddress();
     // Make sure VSS didn't switch families on us.
     EXPECT_EQ(server_addr.family(), initial_addr.family());
 
     TestClient* client1 = new TestClient(new AsyncUDPSocket(socket));
     AsyncSocket* socket2 =
         ss_->CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     TestClient* client2 = new TestClient(new AsyncUDPSocket(socket2));
 
     SocketAddress client2_addr;
     EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
 
     SocketAddress client1_addr;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
     EXPECT_EQ(client1_addr, server_addr);
 
     SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
     for (int i = 0; i < 10; i++) {
-      client2 = new TestClient(AsyncUDPSocket::Create(ss_, empty));
+      client2 = new TestClient(AsyncUDPSocket::Create(ss_.get(), empty));
 
       SocketAddress next_client2_addr;
       EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
       CheckPortIncrementalization(next_client2_addr, client2_addr);
       // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
 
       SocketAddress server_addr2;
       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
@@ skipping 574 matching lines @@
       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
       EXPECT_EQ(client1_addr, bound_server_addr);
     } else {
       EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
       EXPECT_TRUE(client1->CheckNoPacket());
     }
   }
 
  protected:
-  virtual void SetUp() {
-    Thread::Current()->set_socketserver(ss_);
-  }
-  virtual void TearDown() { Thread::Current()->set_socketserver(nullptr); }
-
-  VirtualSocketServer* ss_;
+  std::unique_ptr<VirtualSocketServer> ss_;
+  AutoSocketServerThread thread_;
   const SocketAddress kIPv4AnyAddress;
   const SocketAddress kIPv6AnyAddress;
 };
 
 TEST_F(VirtualSocketServerTest, basic_v4) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
   BasicTest(ipv4_test_addr);
 }
 
 TEST_F(VirtualSocketServerTest, basic_v6) {
@@ skipping 279 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }