blob: 53ca15544f94856135bff81cae9abecb12215e80 (
plain)
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
126
127
128
129
130
131
132
133
|
// Copyright (c) 2012 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.
// P2PSocketDispatcher is a per-renderer object that dispatchers all
// P2P messages received from the browser and relays all P2P messages
// sent to the browser. P2PSocketClient instances register themselves
// with the dispatcher using RegisterClient() and UnregisterClient().
//
// Relationship of classes.
//
// P2PSocketHost P2PSocketClient
// ^ ^
// | |
// v IPC v
// P2PSocketDispatcherHost <---------> P2PSocketDispatcher
//
// P2PSocketDispatcher receives and dispatches messages on the
// IO thread.
#ifndef CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_
#define CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_
#include <stdint.h>
#include <vector>
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/id_map.h"
#include "base/macros.h"
#include "base/observer_list_threadsafe.h"
#include "base/synchronization/lock.h"
#include "content/common/content_export.h"
#include "content/common/p2p_socket_type.h"
#include "content/renderer/p2p/network_list_manager.h"
#include "ipc/message_filter.h"
#include "net/base/ip_address.h"
#include "net/base/network_interfaces.h"
namespace base {
class SingleThreadTaskRunner;
} // namespace base
namespace net {
class IPEndPoint;
} // namespace net
namespace content {
class NetworkListObserver;
class P2PAsyncAddressResolver;
class P2PSocketClientImpl;
class CONTENT_EXPORT P2PSocketDispatcher : public IPC::MessageFilter,
public NetworkListManager {
public:
explicit P2PSocketDispatcher(base::SingleThreadTaskRunner* ipc_task_runner);
// NetworkListManager interface:
void AddNetworkListObserver(
NetworkListObserver* network_list_observer) override;
void RemoveNetworkListObserver(
NetworkListObserver* network_list_observer) override;
bool connected() { return connected_; }
protected:
~P2PSocketDispatcher() override;
private:
friend class P2PAsyncAddressResolver;
friend class P2PSocketClientImpl;
// Send a message asynchronously.
virtual void Send(IPC::Message* message);
// IPC::MessageFilter override. Called on IO thread.
bool OnMessageReceived(const IPC::Message& message) override;
void OnFilterAdded(IPC::Channel* channel) override;
void OnFilterRemoved() override;
void OnChannelClosing() override;
void OnChannelConnected(int32_t peer_pid) override;
base::SingleThreadTaskRunner* task_runner();
// Called by P2PSocketClient.
int RegisterClient(P2PSocketClientImpl* client);
void UnregisterClient(int id);
void SendP2PMessage(IPC::Message* msg);
// Called by DnsRequest.
int RegisterHostAddressRequest(P2PAsyncAddressResolver* request);
void UnregisterHostAddressRequest(int id);
// Incoming message handlers.
void OnNetworkListChanged(const net::NetworkInterfaceList& networks,
const net::IPAddress& default_ipv4_local_address,
const net::IPAddress& default_ipv6_local_address);
void OnGetHostAddressResult(int32_t request_id,
const net::IPAddressList& addresses);
void OnSocketCreated(int socket_id,
const net::IPEndPoint& local_address,
const net::IPEndPoint& remote_address);
void OnIncomingTcpConnection(int socket_id, const net::IPEndPoint& address);
void OnSendComplete(int socket_id, const P2PSendPacketMetrics& send_metrics);
void OnError(int socket_id);
void OnDataReceived(int socket_id, const net::IPEndPoint& address,
const std::vector<char>& data,
const base::TimeTicks& timestamp);
P2PSocketClientImpl* GetClient(int socket_id);
scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
IDMap<P2PSocketClientImpl*> clients_;
IDMap<P2PAsyncAddressResolver*> host_address_requests_;
bool network_notifications_started_;
scoped_refptr<base::ObserverListThreadSafe<NetworkListObserver>>
network_list_observers_;
IPC::Sender* sender_;
// To indicate whether IPC could be invoked on this dispatcher.
bool connected_ = false;
DISALLOW_COPY_AND_ASSIGN(P2PSocketDispatcher);
};
} // namespace content
#endif // CONTENT_RENDERER_P2P_SOCKET_DISPATCHER_H_
|
