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 #include "ipc/ipc_sync_message_filter.h" | 5 #include "ipc/ipc_sync_message_filter.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/location.h" | 8 #include "base/location.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/message_loop/message_loop_proxy.h" | 10 #include "base/message_loop/message_loop_proxy.h" |
11 #include "base/synchronization/waitable_event.h" | 11 #include "base/synchronization/waitable_event.h" |
12 #include "ipc/ipc_channel.h" | 12 #include "ipc/ipc_channel.h" |
13 #include "ipc/ipc_sync_message.h" | 13 #include "ipc/ipc_sync_message.h" |
14 | 14 |
15 using base::MessageLoopProxy; | 15 using base::MessageLoopProxy; |
16 | 16 |
17 namespace IPC { | 17 namespace IPC { |
18 | 18 |
19 SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event) | 19 SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event) |
20 : channel_(NULL), | 20 : sender_(NULL), |
21 listener_loop_(MessageLoopProxy::current()), | 21 listener_loop_(MessageLoopProxy::current()), |
22 shutdown_event_(shutdown_event) { | 22 shutdown_event_(shutdown_event) { |
23 } | 23 } |
24 | 24 |
25 bool SyncMessageFilter::Send(Message* message) { | 25 bool SyncMessageFilter::Send(Message* message) { |
26 { | 26 { |
27 base::AutoLock auto_lock(lock_); | 27 base::AutoLock auto_lock(lock_); |
28 if (!io_loop_.get()) { | 28 if (!io_loop_.get()) { |
29 delete message; | 29 delete message; |
30 return false; | 30 return false; |
(...skipping 29 matching lines...) Expand all Loading... |
60 | 60 |
61 { | 61 { |
62 base::AutoLock auto_lock(lock_); | 62 base::AutoLock auto_lock(lock_); |
63 delete pending_message.deserializer; | 63 delete pending_message.deserializer; |
64 pending_sync_messages_.erase(&pending_message); | 64 pending_sync_messages_.erase(&pending_message); |
65 } | 65 } |
66 | 66 |
67 return pending_message.send_result; | 67 return pending_message.send_result; |
68 } | 68 } |
69 | 69 |
70 void SyncMessageFilter::OnFilterAdded(Channel* channel) { | 70 void SyncMessageFilter::OnFilterAdded(Sender* sender) { |
71 channel_ = channel; | 71 sender_ = sender; |
72 base::AutoLock auto_lock(lock_); | 72 base::AutoLock auto_lock(lock_); |
73 io_loop_ = MessageLoopProxy::current(); | 73 io_loop_ = MessageLoopProxy::current(); |
74 } | 74 } |
75 | 75 |
76 void SyncMessageFilter::OnChannelError() { | 76 void SyncMessageFilter::OnSenderError() { |
77 channel_ = NULL; | 77 sender_ = NULL; |
78 SignalAllEvents(); | 78 SignalAllEvents(); |
79 } | 79 } |
80 | 80 |
81 void SyncMessageFilter::OnChannelClosing() { | 81 void SyncMessageFilter::OnSenderClosing() { |
82 channel_ = NULL; | 82 sender_ = NULL; |
83 SignalAllEvents(); | 83 SignalAllEvents(); |
84 } | 84 } |
85 | 85 |
86 bool SyncMessageFilter::OnMessageReceived(const Message& message) { | 86 bool SyncMessageFilter::OnMessageReceived(const Message& message) { |
87 base::AutoLock auto_lock(lock_); | 87 base::AutoLock auto_lock(lock_); |
88 for (PendingSyncMessages::iterator iter = pending_sync_messages_.begin(); | 88 for (PendingSyncMessages::iterator iter = pending_sync_messages_.begin(); |
89 iter != pending_sync_messages_.end(); ++iter) { | 89 iter != pending_sync_messages_.end(); ++iter) { |
90 if (SyncMessage::IsMessageReplyTo(message, (*iter)->id)) { | 90 if (SyncMessage::IsMessageReplyTo(message, (*iter)->id)) { |
91 if (!message.is_reply_error()) { | 91 if (!message.is_reply_error()) { |
92 (*iter)->send_result = | 92 (*iter)->send_result = |
93 (*iter)->deserializer->SerializeOutputParameters(message); | 93 (*iter)->deserializer->SerializeOutputParameters(message); |
94 } | 94 } |
95 (*iter)->done_event->Signal(); | 95 (*iter)->done_event->Signal(); |
96 return true; | 96 return true; |
97 } | 97 } |
98 } | 98 } |
99 | 99 |
100 return false; | 100 return false; |
101 } | 101 } |
102 | 102 |
103 SyncMessageFilter::~SyncMessageFilter() { | 103 SyncMessageFilter::~SyncMessageFilter() { |
104 } | 104 } |
105 | 105 |
106 void SyncMessageFilter::SendOnIOThread(Message* message) { | 106 void SyncMessageFilter::SendOnIOThread(Message* message) { |
107 if (channel_) { | 107 if (sender_) { |
108 channel_->Send(message); | 108 sender_->Send(message); |
109 return; | 109 return; |
110 } | 110 } |
111 | 111 |
112 if (message->is_sync()) { | 112 if (message->is_sync()) { |
113 // We don't know which thread sent it, but it doesn't matter, just signal | 113 // We don't know which thread sent it, but it doesn't matter, just signal |
114 // them all. | 114 // them all. |
115 SignalAllEvents(); | 115 SignalAllEvents(); |
116 } | 116 } |
117 | 117 |
118 delete message; | 118 delete message; |
119 } | 119 } |
120 | 120 |
121 void SyncMessageFilter::SignalAllEvents() { | 121 void SyncMessageFilter::SignalAllEvents() { |
122 base::AutoLock auto_lock(lock_); | 122 base::AutoLock auto_lock(lock_); |
123 for (PendingSyncMessages::iterator iter = pending_sync_messages_.begin(); | 123 for (PendingSyncMessages::iterator iter = pending_sync_messages_.begin(); |
124 iter != pending_sync_messages_.end(); ++iter) { | 124 iter != pending_sync_messages_.end(); ++iter) { |
125 (*iter)->done_event->Signal(); | 125 (*iter)->done_event->Signal(); |
126 } | 126 } |
127 } | 127 } |
128 | 128 |
129 } // namespace IPC | 129 } // namespace IPC |
OLD | NEW |