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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
|
// 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.
#ifndef IPC_IPC_CHANNEL_PROXY_H_
#define IPC_IPC_CHANNEL_PROXY_H_
#pragma once
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop_proxy.h"
#include "base/synchronization/lock.h"
#include "ipc/ipc_channel.h"
#include "ipc/ipc_channel_handle.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
namespace IPC {
class SendCallbackHelper;
//-----------------------------------------------------------------------------
// IPC::ChannelProxy
//
// This class is a helper class that is useful when you wish to run an IPC
// channel on a background thread. It provides you with the option of either
// handling IPC messages on that background thread or having them dispatched to
// your main thread (the thread on which the IPC::ChannelProxy is created).
//
// The API for an IPC::ChannelProxy is very similar to that of an IPC::Channel.
// When you send a message to an IPC::ChannelProxy, the message is routed to
// the background thread, where it is then passed to the IPC::Channel's Send
// method. This means that you can send a message from your thread and your
// message will be sent over the IPC channel when possible instead of being
// delayed until your thread returns to its message loop. (Often IPC messages
// will queue up on the IPC::Channel when there is a lot of traffic, and the
// channel will not get cycles to flush its message queue until the thread, on
// which it is running, returns to its message loop.)
//
// An IPC::ChannelProxy can have a MessageFilter associated with it, which will
// be notified of incoming messages on the IPC::Channel's thread. This gives
// the consumer of IPC::ChannelProxy the ability to respond to incoming
// messages on this background thread instead of on their own thread, which may
// be bogged down with other processing. The result can be greatly improved
// latency for messages that can be handled on a background thread.
//
// The consumer of IPC::ChannelProxy is responsible for allocating the Thread
// instance where the IPC::Channel will be created and operated.
//
class IPC_EXPORT ChannelProxy : public Sender {
public:
struct MessageFilterTraits;
// A class that receives messages on the thread where the IPC channel is
// running. It can choose to prevent the default action for an IPC message.
class IPC_EXPORT MessageFilter
: public base::RefCountedThreadSafe<MessageFilter, MessageFilterTraits> {
public:
MessageFilter();
// Called on the background thread to provide the filter with access to the
// channel. Called when the IPC channel is initialized or when AddFilter
// is called if the channel is already initialized.
virtual void OnFilterAdded(Channel* channel);
// Called on the background thread when the filter has been removed from
// the ChannelProxy and when the Channel is closing. After a filter is
// removed, it will not be called again.
virtual void OnFilterRemoved();
// Called to inform the filter that the IPC channel is connected and we
// have received the internal Hello message from the peer.
virtual void OnChannelConnected(int32 peer_pid);
// Called when there is an error on the channel, typically that the channel
// has been closed.
virtual void OnChannelError();
// Called to inform the filter that the IPC channel will be destroyed.
// OnFilterRemoved is called immediately after this.
virtual void OnChannelClosing();
// Return true to indicate that the message was handled, or false to let
// the message be handled in the default way.
virtual bool OnMessageReceived(const Message& message);
// Called when the message filter is about to be deleted. This gives
// derived classes the option of controlling which thread they're deleted
// on etc.
virtual void OnDestruct() const;
protected:
virtual ~MessageFilter();
private:
friend class base::RefCountedThreadSafe<MessageFilter,
MessageFilterTraits>;
};
struct MessageFilterTraits {
static void Destruct(const MessageFilter* filter) {
filter->OnDestruct();
}
};
// Interface for a filter to be imposed on outgoing messages which can
// re-write the message. Used mainly for testing.
class OutgoingMessageFilter {
public:
// Returns a re-written message, freeing the original, or simply the
// original unchanged if no rewrite indicated.
virtual Message *Rewrite(Message *message) = 0;
};
// Initializes a channel proxy. The channel_handle and mode parameters are
// passed directly to the underlying IPC::Channel. The listener is called on
// the thread that creates the ChannelProxy. The filter's OnMessageReceived
// method is called on the thread where the IPC::Channel is running. The
// filter may be null if the consumer is not interested in handling messages
// on the background thread. Any message not handled by the filter will be
// dispatched to the listener. The given message loop indicates where the
// IPC::Channel should be created.
ChannelProxy(const IPC::ChannelHandle& channel_handle,
Channel::Mode mode,
Listener* listener,
base::MessageLoopProxy* ipc_thread_loop);
// Creates an uninitialized channel proxy. Init must be called to receive
// or send any messages. This two-step setup allows message filters to be
// added before any messages are sent or received.
ChannelProxy(Listener* listener,
base::MessageLoopProxy* ipc_thread_loop);
virtual ~ChannelProxy();
// Initializes the channel proxy. Only call this once to initialize a channel
// proxy that was not initialized in its constructor. If create_pipe_now is
// true, the pipe is created synchronously. Otherwise it's created on the IO
// thread.
void Init(const IPC::ChannelHandle& channel_handle, Channel::Mode mode,
bool create_pipe_now);
// Close the IPC::Channel. This operation completes asynchronously, once the
// background thread processes the command to close the channel. It is ok to
// call this method multiple times. Redundant calls are ignored.
//
// WARNING: The MessageFilter object held by the ChannelProxy is also
// released asynchronously, and it may in fact have its final reference
// released on the background thread. The caller should be careful to deal
// with / allow for this possibility.
void Close();
// Send a message asynchronously. The message is routed to the background
// thread where it is passed to the IPC::Channel's Send method.
virtual bool Send(Message* message) OVERRIDE;
// Used to intercept messages as they are received on the background thread.
//
// Ordinarily, messages sent to the ChannelProxy are routed to the matching
// listener on the worker thread. This API allows code to intercept messages
// before they are sent to the worker thread.
// If you call this before the target process is launched, then you're
// guaranteed to not miss any messages. But if you call this anytime after,
// then some messages might be missed since the filter is added internally on
// the IO thread.
void AddFilter(MessageFilter* filter);
void RemoveFilter(MessageFilter* filter);
void set_outgoing_message_filter(OutgoingMessageFilter* filter) {
outgoing_message_filter_ = filter;
}
// Called to clear the pointer to the IPC message loop when it's going away.
void ClearIPCMessageLoop();
// Get the process ID for the connected peer.
// Returns base::kNullProcessId if the peer is not connected yet.
base::ProcessId peer_pid() const { return context_->peer_pid_; }
#if defined(OS_POSIX) && !defined(OS_NACL)
// Calls through to the underlying channel's methods.
int GetClientFileDescriptor();
int TakeClientFileDescriptor();
bool GetClientEuid(uid_t* client_euid) const;
#endif // defined(OS_POSIX)
protected:
class Context;
// A subclass uses this constructor if it needs to add more information
// to the internal state.
ChannelProxy(Context* context);
// Used internally to hold state that is referenced on the IPC thread.
class Context : public base::RefCountedThreadSafe<Context>,
public Listener {
public:
Context(Listener* listener, base::MessageLoopProxy* ipc_thread);
void ClearIPCMessageLoop() { ipc_message_loop_ = NULL; }
base::MessageLoopProxy* ipc_message_loop() const {
return ipc_message_loop_.get();
}
const std::string& channel_id() const { return channel_id_; }
// Dispatches a message on the listener thread.
void OnDispatchMessage(const Message& message);
protected:
friend class base::RefCountedThreadSafe<Context>;
virtual ~Context();
// IPC::Listener methods:
virtual bool OnMessageReceived(const Message& message) OVERRIDE;
virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
virtual void OnChannelError() OVERRIDE;
// Like OnMessageReceived but doesn't try the filters.
bool OnMessageReceivedNoFilter(const Message& message);
// Gives the filters a chance at processing |message|.
// Returns true if the message was processed, false otherwise.
bool TryFilters(const Message& message);
// Like Open and Close, but called on the IPC thread.
virtual void OnChannelOpened();
virtual void OnChannelClosed();
// Called on the consumers thread when the ChannelProxy is closed. At that
// point the consumer is telling us that they don't want to receive any
// more messages, so we honor that wish by forgetting them!
virtual void Clear() { listener_ = NULL; }
private:
friend class ChannelProxy;
friend class SendCallbackHelper;
// Create the Channel
void CreateChannel(const IPC::ChannelHandle& channel_handle,
const Channel::Mode& mode);
// Methods called on the IO thread.
void OnSendMessage(scoped_ptr<Message> message_ptr);
void OnAddFilter();
void OnRemoveFilter(MessageFilter* filter);
// Methods called on the listener thread.
void AddFilter(MessageFilter* filter);
void OnDispatchConnected();
void OnDispatchError();
scoped_refptr<base::MessageLoopProxy> listener_message_loop_;
Listener* listener_;
// List of filters. This is only accessed on the IPC thread.
std::vector<scoped_refptr<MessageFilter> > filters_;
scoped_refptr<base::MessageLoopProxy> ipc_message_loop_;
scoped_ptr<Channel> channel_;
std::string channel_id_;
bool channel_connected_called_;
// Holds filters between the AddFilter call on the listerner thread and the
// IPC thread when they're added to filters_.
std::vector<scoped_refptr<MessageFilter> > pending_filters_;
// Lock for pending_filters_.
base::Lock pending_filters_lock_;
// Cached copy of the peer process ID. Set on IPC but read on both IPC and
// listener threads.
base::ProcessId peer_pid_;
};
Context* context() { return context_; }
OutgoingMessageFilter* outgoing_message_filter() {
return outgoing_message_filter_;
}
private:
friend class SendCallbackHelper;
// By maintaining this indirection (ref-counted) to our internal state, we
// can safely be destroyed while the background thread continues to do stuff
// that involves this data.
scoped_refptr<Context> context_;
OutgoingMessageFilter* outgoing_message_filter_;
// Whether the channel has been initialized.
bool did_init_;
};
} // namespace IPC
#endif // IPC_IPC_CHANNEL_PROXY_H_
|