1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/net/network_diagnostics/fake_udp_socket.h"
#include <optional>
#include <utility>
#include "net/base/ip_endpoint.h"
namespace ash {
namespace network_diagnostics {
namespace {} // namespace
FakeUdpSocket::FakeUdpSocket() = default;
FakeUdpSocket::~FakeUdpSocket() = default;
void FakeUdpSocket::Connect(const net::IPEndPoint& remote_addr,
network::mojom::UDPSocketOptionsPtr options,
ConnectCallback callback) {
DCHECK(task_environment_);
task_environment_->FastForwardBy(connection_delay_);
if (mojo_disconnect_on_connect_) {
receiver_.reset();
return;
}
std::move(callback).Run(udp_connect_code_, net::IPEndPoint());
}
void FakeUdpSocket::Bind(const net::IPEndPoint& local_addr,
network::mojom::UDPSocketOptionsPtr options,
BindCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::SetBroadcast(bool broadcast,
SetBroadcastCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::SetSendBufferSize(int32_t send_buffer_size,
SetSendBufferSizeCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::SetReceiveBufferSize(int32_t receive_buffer_size,
SetSendBufferSizeCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::JoinGroup(const net::IPAddress& group_address,
JoinGroupCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::LeaveGroup(const net::IPAddress& group_address,
LeaveGroupCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::ReceiveMore(uint32_t num_additional_datagrams) {
DCHECK(remote_.is_bound());
DCHECK(task_environment_);
task_environment_->FastForwardBy(receive_delay_);
if (mojo_disconnect_on_receive_) {
remote_.reset();
return;
}
remote_->OnReceived(udp_on_received_code_, net::IPEndPoint(),
std::move(udp_on_received_data_));
}
void FakeUdpSocket::ReceiveMoreWithBufferSize(uint32_t num_additional_datagrams,
uint32_t buffer_size) {
NOTREACHED();
}
void FakeUdpSocket::SendTo(
const net::IPEndPoint& dest_addr,
base::span<const uint8_t> data,
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
SendToCallback callback) {
NOTREACHED();
}
void FakeUdpSocket::Send(
base::span<const uint8_t> data,
const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
SendCallback callback) {
DCHECK(task_environment_);
task_environment_->FastForwardBy(send_delay_);
if (mojo_disconnect_on_send_) {
receiver_.reset();
return;
}
std::move(callback).Run(udp_send_code_);
}
void FakeUdpSocket::Close() {
NOTREACHED();
}
void FakeUdpSocket::BindReceiver(
mojo::PendingReceiver<network::mojom::UDPSocket> socket) {
DCHECK(!receiver_.is_bound());
receiver_.Bind(std::move(socket));
}
void FakeUdpSocket::BindRemote(
mojo::PendingRemote<network::mojom::UDPSocketListener> socket_listener) {
DCHECK(!remote_.is_bound());
remote_.Bind(std::move(socket_listener));
}
} // namespace network_diagnostics
} // namespace ash
|
