OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef IPC_IPC_SYNC_CHANNEL_H_ | 5 #ifndef IPC_IPC_SYNC_CHANNEL_H_ |
6 #define IPC_IPC_SYNC_CHANNEL_H_ | 6 #define IPC_IPC_SYNC_CHANNEL_H_ |
7 | 7 |
8 #include <string> | 8 #include <string> |
9 #include <deque> | 9 #include <deque> |
10 | 10 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
51 // Significant complexity results from the fact that messages are still coming | 51 // Significant complexity results from the fact that messages are still coming |
52 // in while the original thread is blocked. Normal async messages are queued | 52 // in while the original thread is blocked. Normal async messages are queued |
53 // and dispatched after the blocking call is complete. Sync messages must | 53 // and dispatched after the blocking call is complete. Sync messages must |
54 // be dispatched in a reentrant manner to avoid deadlock. | 54 // be dispatched in a reentrant manner to avoid deadlock. |
55 // | 55 // |
56 // | 56 // |
57 // Note that care must be taken that the lifetime of the ipc_thread argument | 57 // Note that care must be taken that the lifetime of the ipc_thread argument |
58 // is more than this object. If the message loop goes away while this object | 58 // is more than this object. If the message loop goes away while this object |
59 // is running and it's used to send a message, then it will use the invalid | 59 // is running and it's used to send a message, then it will use the invalid |
60 // message loop pointer to proxy it to the ipc thread. | 60 // message loop pointer to proxy it to the ipc thread. |
61 class IPC_EXPORT SyncChannel : public ChannelProxy, | 61 class IPC_EXPORT SyncChannel : public ChannelProxy { |
62 public base::WaitableEventWatcher::Delegate { | |
63 public: | 62 public: |
64 enum RestrictDispatchGroup { | 63 enum RestrictDispatchGroup { |
65 kRestrictDispatchGroup_None = 0, | 64 kRestrictDispatchGroup_None = 0, |
66 }; | 65 }; |
67 | 66 |
68 // Creates and initializes a sync channel. If create_pipe_now is specified, | 67 // Creates and initializes a sync channel. If create_pipe_now is specified, |
69 // the channel will be initialized synchronously. | 68 // the channel will be initialized synchronously. |
70 SyncChannel(const IPC::ChannelHandle& channel_handle, | 69 SyncChannel(const IPC::ChannelHandle& channel_handle, |
71 Channel::Mode mode, | 70 Channel::Mode mode, |
72 Listener* listener, | 71 Listener* listener, |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
108 // default) will be dispatched in any case. | 107 // default) will be dispatched in any case. |
109 void SetRestrictDispatchChannelGroup(int group); | 108 void SetRestrictDispatchChannelGroup(int group); |
110 | 109 |
111 protected: | 110 protected: |
112 class ReceivedSyncMsgQueue; | 111 class ReceivedSyncMsgQueue; |
113 friend class ReceivedSyncMsgQueue; | 112 friend class ReceivedSyncMsgQueue; |
114 | 113 |
115 // SyncContext holds the per object data for SyncChannel, so that SyncChannel | 114 // SyncContext holds the per object data for SyncChannel, so that SyncChannel |
116 // can be deleted while it's being used in a different thread. See | 115 // can be deleted while it's being used in a different thread. See |
117 // ChannelProxy::Context for more information. | 116 // ChannelProxy::Context for more information. |
118 class SyncContext : public Context, | 117 class SyncContext : public Context { |
119 public base::WaitableEventWatcher::Delegate { | |
120 public: | 118 public: |
121 SyncContext(Listener* listener, | 119 SyncContext(Listener* listener, |
122 base::SingleThreadTaskRunner* ipc_task_runner, | 120 base::SingleThreadTaskRunner* ipc_task_runner, |
123 base::WaitableEvent* shutdown_event); | 121 base::WaitableEvent* shutdown_event); |
124 | 122 |
125 // Adds information about an outgoing sync message to the context so that | 123 // Adds information about an outgoing sync message to the context so that |
126 // we know how to deserialize the reply. | 124 // we know how to deserialize the reply. |
127 void Push(SyncMessage* sync_msg); | 125 void Push(SyncMessage* sync_msg); |
128 | 126 |
129 // Cleanly remove the top deserializer (and throw it away). Returns the | 127 // Cleanly remove the top deserializer (and throw it away). Returns the |
(...skipping 13 matching lines...) Expand all Loading... | |
143 // Checks if the given message is blocking the listener thread because of a | 141 // Checks if the given message is blocking the listener thread because of a |
144 // synchronous send. If it is, the thread is unblocked and true is | 142 // synchronous send. If it is, the thread is unblocked and true is |
145 // returned. Otherwise the function returns false. | 143 // returned. Otherwise the function returns false. |
146 bool TryToUnblockListener(const Message* msg); | 144 bool TryToUnblockListener(const Message* msg); |
147 | 145 |
148 // Called on the IPC thread when a sync send that runs a nested message loop | 146 // Called on the IPC thread when a sync send that runs a nested message loop |
149 // times out. | 147 // times out. |
150 void OnSendTimeout(int message_id); | 148 void OnSendTimeout(int message_id); |
151 | 149 |
152 base::WaitableEvent* shutdown_event() { return shutdown_event_; } | 150 base::WaitableEvent* shutdown_event() { return shutdown_event_; } |
151 base::WaitableEventWatcher::EventCallback | |
152 shutdown_watcher_callback() const { | |
153 return shutdown_watcher_callback_; | |
154 } | |
153 | 155 |
154 ReceivedSyncMsgQueue* received_sync_msgs() { | 156 ReceivedSyncMsgQueue* received_sync_msgs() { |
155 return received_sync_msgs_; | 157 return received_sync_msgs_; |
156 } | 158 } |
157 | 159 |
158 void set_restrict_dispatch_group(int group) { | 160 void set_restrict_dispatch_group(int group) { |
159 restrict_dispatch_group_ = group; | 161 restrict_dispatch_group_ = group; |
160 } | 162 } |
161 | 163 |
162 int restrict_dispatch_group() const { | 164 int restrict_dispatch_group() const { |
163 return restrict_dispatch_group_; | 165 return restrict_dispatch_group_; |
164 } | 166 } |
165 | 167 |
166 private: | 168 private: |
167 virtual ~SyncContext(); | 169 virtual ~SyncContext(); |
168 // ChannelProxy methods that we override. | 170 // ChannelProxy methods that we override. |
169 | 171 |
170 // Called on the listener thread. | 172 // Called on the listener thread. |
171 virtual void Clear() OVERRIDE; | 173 virtual void Clear() OVERRIDE; |
172 | 174 |
173 // Called on the IPC thread. | 175 // Called on the IPC thread. |
174 virtual bool OnMessageReceived(const Message& msg) OVERRIDE; | 176 virtual bool OnMessageReceived(const Message& msg) OVERRIDE; |
175 virtual void OnChannelError() OVERRIDE; | 177 virtual void OnChannelError() OVERRIDE; |
176 virtual void OnChannelOpened() OVERRIDE; | 178 virtual void OnChannelOpened() OVERRIDE; |
177 virtual void OnChannelClosed() OVERRIDE; | 179 virtual void OnChannelClosed() OVERRIDE; |
178 | 180 |
179 // Cancels all pending Send calls. | 181 // Cancels all pending Send calls. |
180 void CancelPendingSends(); | 182 void CancelPendingSends(); |
181 | 183 |
182 // WaitableEventWatcher::Delegate implementation. | 184 void OnWaitableEventSignaled(base::WaitableEvent* arg); |
183 virtual void OnWaitableEventSignaled(base::WaitableEvent* arg) OVERRIDE; | |
184 | 185 |
185 typedef std::deque<PendingSyncMsg> PendingSyncMessageQueue; | 186 typedef std::deque<PendingSyncMsg> PendingSyncMessageQueue; |
186 PendingSyncMessageQueue deserializers_; | 187 PendingSyncMessageQueue deserializers_; |
187 base::Lock deserializers_lock_; | 188 base::Lock deserializers_lock_; |
188 | 189 |
189 scoped_refptr<ReceivedSyncMsgQueue> received_sync_msgs_; | 190 scoped_refptr<ReceivedSyncMsgQueue> received_sync_msgs_; |
190 | 191 |
191 base::WaitableEvent* shutdown_event_; | 192 base::WaitableEvent* shutdown_event_; |
192 base::WaitableEventWatcher shutdown_watcher_; | 193 base::WaitableEventWatcher shutdown_watcher_; |
194 base::WaitableEventWatcher::EventCallback shutdown_watcher_callback_; | |
dmichael (off chromium)
2013/02/01 17:27:18
Why is this called shutdown_watcher_callback_?
It
| |
193 int restrict_dispatch_group_; | 195 int restrict_dispatch_group_; |
194 }; | 196 }; |
195 | 197 |
196 private: | 198 private: |
197 // WaitableEventWatcher::Delegate implementation. | 199 void OnWaitableEventSignaled(base::WaitableEvent* arg); |
198 virtual void OnWaitableEventSignaled(base::WaitableEvent* arg) OVERRIDE; | |
199 | 200 |
200 SyncContext* sync_context() { | 201 SyncContext* sync_context() { |
201 return reinterpret_cast<SyncContext*>(context()); | 202 return reinterpret_cast<SyncContext*>(context()); |
202 } | 203 } |
203 | 204 |
204 // Both these functions wait for a reply, timeout or process shutdown. The | 205 // Both these functions wait for a reply, timeout or process shutdown. The |
205 // latter one also runs a nested message loop in the meantime. | 206 // latter one also runs a nested message loop in the meantime. |
206 static void WaitForReply( | 207 static void WaitForReply( |
207 SyncContext* context, base::WaitableEvent* pump_messages_event); | 208 SyncContext* context, base::WaitableEvent* pump_messages_event); |
208 | 209 |
209 // Runs a nested message loop until a reply arrives, times out, or the process | 210 // Runs a nested message loop until a reply arrives, times out, or the process |
210 // shuts down. | 211 // shuts down. |
211 static void WaitForReplyWithNestedMessageLoop(SyncContext* context); | 212 static void WaitForReplyWithNestedMessageLoop(SyncContext* context); |
212 | 213 |
213 // Starts the dispatch watcher. | 214 // Starts the dispatch watcher. |
214 void StartWatching(); | 215 void StartWatching(); |
215 | 216 |
216 bool sync_messages_with_no_timeout_allowed_; | 217 bool sync_messages_with_no_timeout_allowed_; |
217 | 218 |
218 // Used to signal events between the IPC and listener threads. | 219 // Used to signal events between the IPC and listener threads. |
219 base::WaitableEventWatcher dispatch_watcher_; | 220 base::WaitableEventWatcher dispatch_watcher_; |
221 base::WaitableEventWatcher::EventCallback dispatch_watcher_callback_; | |
220 | 222 |
221 DISALLOW_COPY_AND_ASSIGN(SyncChannel); | 223 DISALLOW_COPY_AND_ASSIGN(SyncChannel); |
222 }; | 224 }; |
223 | 225 |
224 } // namespace IPC | 226 } // namespace IPC |
225 | 227 |
226 #endif // IPC_IPC_SYNC_CHANNEL_H_ | 228 #endif // IPC_IPC_SYNC_CHANNEL_H_ |
OLD | NEW |