Enqueue mDns requests if send on socket in progress.

net/dns/mdns_client_unittest.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 <queue>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 1105 matching lines @@
   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
       .WillOnce(
           Invoke(socket_ipv6_, &MockMDnsDatagramServerSocket::HandleRecvNow))
       .WillOnce(Return(ERR_IO_PENDING));
 
   EXPECT_CALL(delegate_, HandlePacketInternal(sample_packet));
 
   ASSERT_TRUE(InitConnection());
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(MDnsConnectionTest, ReceiveAsynchronous) {
   std::string sample_packet = MakeString(kSamplePacket1,
       sizeof(kSamplePacket1));
   socket_ipv6_->SetResponsePacket(sample_packet);
   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
       .WillOnce(
           Invoke(socket_ipv6_, &MockMDnsDatagramServerSocket::HandleRecvLater))
       .WillOnce(Return(ERR_IO_PENDING));
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(delegate_, HandlePacketInternal(sample_packet));
-
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(MDnsConnectionTest, Send) {
   std::string sample_packet = MakeString(kSamplePacket1,
       sizeof(kSamplePacket1));
 
   scoped_refptr<IOBufferWithSize> buf(
       new IOBufferWithSize(sizeof kSamplePacket1));
   memcpy(buf->data(), kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(*socket_ipv4_,
               SendToInternal(sample_packet, "224.0.0.251:5353", _));
   EXPECT_CALL(*socket_ipv6_,
               SendToInternal(sample_packet, "[ff02::fb]:5353", _));
 
-  connection_.Send(buf.get(), buf->size());
+  connection_.Send(buf);
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(MDnsConnectionTest, Error) {
   CompletionCallback callback;
 
   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
       .WillOnce(DoAll(SaveArg<3>(&callback),  Return(ERR_IO_PENDING)));
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
   callback.Run(ERR_SOCKET_NOT_CONNECTED);
+  base::MessageLoop::current()->RunUntilIdle();
 }
 

[Ryan Hamilton, 2014/09/22 19:26:44]

I don't see any tests of the new behavior. Specifically of queueing up multiple
requests and then sending them all when one completes. Seems like this would be
a good idea?

[Vitaly Buka (NO REVIEWS), 2014/09/22 22:53:49]

Done.

 }  // namespace
 
 }  // namespace net