mock_mdns_socket_factory.cc 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/dns/mock_mdns_socket_factory.h"
  5. #include <algorithm>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/location.h"
  10. #include "base/task/single_thread_task_runner.h"
  11. #include "base/threading/thread_task_runner_handle.h"
  12. #include "net/base/net_errors.h"
  13. #include "net/dns/public/util.h"
  14. using testing::_;
  15. using testing::Invoke;
  16. namespace net {
  17. MockMDnsDatagramServerSocket::MockMDnsDatagramServerSocket(
  18. AddressFamily address_family) {
  19. local_address_ = dns_util::GetMdnsReceiveEndPoint(address_family);
  20. }
  21. MockMDnsDatagramServerSocket::~MockMDnsDatagramServerSocket() = default;
  22. int MockMDnsDatagramServerSocket::SendTo(IOBuffer* buf,
  23. int buf_len,
  24. const IPEndPoint& address,
  25. CompletionOnceCallback callback) {
  26. return SendToInternal(std::string(buf->data(), buf_len), address.ToString(),
  27. std::move(callback));
  28. }
  29. int MockMDnsDatagramServerSocket::GetLocalAddress(IPEndPoint* address) const {
  30. *address = local_address_;
  31. return OK;
  32. }
  33. void MockMDnsDatagramServerSocket::SetResponsePacket(
  34. const std::string& response_packet) {
  35. response_packet_ = response_packet;
  36. }
  37. int MockMDnsDatagramServerSocket::HandleRecvNow(
  38. IOBuffer* buffer,
  39. int size,
  40. IPEndPoint* address,
  41. CompletionOnceCallback callback) {
  42. int size_returned =
  43. std::min(response_packet_.size(), static_cast<size_t>(size));
  44. memcpy(buffer->data(), response_packet_.data(), size_returned);
  45. return size_returned;
  46. }
  47. int MockMDnsDatagramServerSocket::HandleRecvLater(
  48. IOBuffer* buffer,
  49. int size,
  50. IPEndPoint* address,
  51. CompletionOnceCallback callback) {
  52. int rv = HandleRecvNow(buffer, size, address, base::DoNothing());
  53. base::ThreadTaskRunnerHandle::Get()->PostTask(
  54. FROM_HERE, base::BindOnce(std::move(callback), rv));
  55. return ERR_IO_PENDING;
  56. }
  57. MockMDnsSocketFactory::MockMDnsSocketFactory() = default;
  58. MockMDnsSocketFactory::~MockMDnsSocketFactory() = default;
  59. void MockMDnsSocketFactory::CreateSockets(
  60. std::vector<std::unique_ptr<DatagramServerSocket>>* sockets) {
  61. CreateSocket(ADDRESS_FAMILY_IPV4, sockets);
  62. CreateSocket(ADDRESS_FAMILY_IPV6, sockets);
  63. }
  64. void MockMDnsSocketFactory::CreateSocket(
  65. AddressFamily address_family,
  66. std::vector<std::unique_ptr<DatagramServerSocket>>* sockets) {
  67. auto new_socket =
  68. std::make_unique<testing::NiceMock<MockMDnsDatagramServerSocket>>(
  69. address_family);
  70. ON_CALL(*new_socket, SendToInternal(_, _, _))
  71. .WillByDefault(Invoke(
  72. this,
  73. &MockMDnsSocketFactory::SendToInternal));
  74. ON_CALL(*new_socket, RecvFrom(_, _, _, _))
  75. .WillByDefault(Invoke(this, &MockMDnsSocketFactory::RecvFromInternal));
  76. sockets->push_back(std::move(new_socket));
  77. }
  78. void MockMDnsSocketFactory::SimulateReceive(const uint8_t* packet, int size) {
  79. DCHECK(recv_buffer_size_ >= size);
  80. DCHECK(recv_buffer_.get());
  81. DCHECK(!recv_callback_.is_null());
  82. memcpy(recv_buffer_->data(), packet, size);
  83. std::move(recv_callback_).Run(size);
  84. }
  85. int MockMDnsSocketFactory::RecvFromInternal(IOBuffer* buffer,
  86. int size,
  87. IPEndPoint* address,
  88. CompletionOnceCallback callback) {
  89. recv_buffer_ = buffer;
  90. recv_buffer_size_ = size;
  91. recv_callback_ = std::move(callback);
  92. return ERR_IO_PENDING;
  93. }
  94. int MockMDnsSocketFactory::SendToInternal(const std::string& packet,
  95. const std::string& address,
  96. CompletionOnceCallback callback) {
  97. OnSendTo(packet);
  98. return packet.size();
  99. }
  100. } // namespace net