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_channel_proxy.h" |
| 6 |
5 #include "base/bind.h" | 7 #include "base/bind.h" |
6 #include "base/compiler_specific.h" | 8 #include "base/compiler_specific.h" |
7 #include "base/debug/trace_event.h" | |
8 #include "base/location.h" | 9 #include "base/location.h" |
9 #include "base/memory/ref_counted.h" | 10 #include "base/memory/ref_counted.h" |
10 #include "base/memory/scoped_ptr.h" | 11 #include "base/memory/scoped_ptr.h" |
11 #include "base/single_thread_task_runner.h" | 12 #include "base/single_thread_task_runner.h" |
12 #include "base/thread_task_runner_handle.h" | 13 #include "base/thread_task_runner_handle.h" |
13 #include "ipc/ipc_channel_proxy.h" | |
14 #include "ipc/ipc_listener.h" | 14 #include "ipc/ipc_listener.h" |
15 #include "ipc/ipc_logging.h" | 15 #include "ipc/ipc_logging.h" |
16 #include "ipc/ipc_message_macros.h" | 16 #include "ipc/ipc_message_macros.h" |
17 #include "ipc/ipc_message_start.h" | 17 #include "ipc/message_filter.h" |
18 #include "ipc/ipc_message_utils.h" | 18 #include "ipc/message_filter_router.h" |
19 | 19 |
20 namespace IPC { | 20 namespace IPC { |
21 | 21 |
22 //------------------------------------------------------------------------------ | 22 //------------------------------------------------------------------------------ |
23 | 23 |
24 class ChannelProxy::Context::MessageFilterRouter { | |
25 public: | |
26 typedef std::vector<MessageFilter*> MessageFilters; | |
27 | |
28 MessageFilterRouter() {} | |
29 ~MessageFilterRouter() {} | |
30 | |
31 void AddFilter(MessageFilter* filter) { | |
32 // Determine if the filter should be applied to all messages, or only | |
33 // messages of a certain class. | |
34 std::vector<uint32> supported_message_classes; | |
35 if (filter->GetSupportedMessageClasses(&supported_message_classes)) { | |
36 DCHECK(!supported_message_classes.empty()); | |
37 for (size_t i = 0; i < supported_message_classes.size(); ++i) { | |
38 const int message_class = supported_message_classes[i]; | |
39 DCHECK(ValidMessageClass(message_class)); | |
40 // Safely ignore repeated subscriptions to a given message class for the | |
41 // current filter being added. | |
42 if (!message_class_filters_[message_class].empty() && | |
43 message_class_filters_[message_class].back() == filter) { | |
44 continue; | |
45 } | |
46 message_class_filters_[message_class].push_back(filter); | |
47 } | |
48 } else { | |
49 global_filters_.push_back(filter); | |
50 } | |
51 } | |
52 | |
53 void RemoveFilter(MessageFilter* filter) { | |
54 if (RemoveFilter(global_filters_, filter)) | |
55 return; | |
56 | |
57 for (size_t i = 0; i < arraysize(message_class_filters_); ++i) | |
58 RemoveFilter(message_class_filters_[i], filter); | |
59 } | |
60 | |
61 bool TryFilters(const Message& message) { | |
62 if (TryFilters(global_filters_, message)) | |
63 return true; | |
64 | |
65 const int message_class = IPC_MESSAGE_CLASS(message); | |
66 if (!ValidMessageClass(message_class)) | |
67 return false; | |
68 | |
69 return TryFilters(message_class_filters_[message_class], message); | |
70 } | |
71 | |
72 void Clear() { | |
73 global_filters_.clear(); | |
74 for (size_t i = 0; i < arraysize(message_class_filters_); ++i) | |
75 message_class_filters_[i].clear(); | |
76 } | |
77 | |
78 private: | |
79 static bool TryFilters(MessageFilters& filters, const IPC::Message& message) { | |
80 for (size_t i = 0; i < filters.size(); ++i) { | |
81 if (filters[i]->OnMessageReceived(message)) { | |
82 return true; | |
83 } | |
84 } | |
85 return false; | |
86 } | |
87 | |
88 static bool RemoveFilter(MessageFilters& filters, MessageFilter* filter) { | |
89 MessageFilters::iterator it = | |
90 std::remove(filters.begin(), filters.end(), filter); | |
91 if (it == filters.end()) | |
92 return false; | |
93 | |
94 filters.erase(it, filters.end()); | |
95 return true; | |
96 } | |
97 | |
98 static bool ValidMessageClass(int message_class) { | |
99 return message_class >= 0 && message_class < LastIPCMsgStart; | |
100 } | |
101 | |
102 // List of global and selective filters; a given filter will exist in either | |
103 // |message_global_filters_| OR |message_class_filters_|, but not both. | |
104 // Note that |message_global_filters_| will be given first offering of any | |
105 // given message. It's the filter implementer and installer's | |
106 // responsibility to ensure that a filter is either global or selective to | |
107 // ensure proper message filtering order. | |
108 MessageFilters global_filters_; | |
109 MessageFilters message_class_filters_[LastIPCMsgStart]; | |
110 }; | |
111 | |
112 //------------------------------------------------------------------------------ | |
113 | |
114 ChannelProxy::MessageFilter::MessageFilter() {} | |
115 | |
116 void ChannelProxy::MessageFilter::OnFilterAdded(Channel* channel) {} | |
117 | |
118 void ChannelProxy::MessageFilter::OnFilterRemoved() {} | |
119 | |
120 void ChannelProxy::MessageFilter::OnChannelConnected(int32 peer_pid) {} | |
121 | |
122 void ChannelProxy::MessageFilter::OnChannelError() {} | |
123 | |
124 void ChannelProxy::MessageFilter::OnChannelClosing() {} | |
125 | |
126 bool ChannelProxy::MessageFilter::OnMessageReceived(const Message& message) { | |
127 return false; | |
128 } | |
129 | |
130 bool ChannelProxy::MessageFilter::GetSupportedMessageClasses( | |
131 std::vector<uint32>* /*supported_message_classes*/) const { | |
132 return false; | |
133 } | |
134 | |
135 ChannelProxy::MessageFilter::~MessageFilter() {} | |
136 | |
137 //------------------------------------------------------------------------------ | |
138 | |
139 ChannelProxy::Context::Context(Listener* listener, | 24 ChannelProxy::Context::Context(Listener* listener, |
140 base::SingleThreadTaskRunner* ipc_task_runner) | 25 base::SingleThreadTaskRunner* ipc_task_runner) |
141 : listener_task_runner_(base::ThreadTaskRunnerHandle::Get()), | 26 : listener_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
142 listener_(listener), | 27 listener_(listener), |
143 ipc_task_runner_(ipc_task_runner), | 28 ipc_task_runner_(ipc_task_runner), |
144 channel_connected_called_(false), | 29 channel_connected_called_(false), |
145 message_filter_router_(new MessageFilterRouter()), | 30 message_filter_router_(new MessageFilterRouter()), |
146 peer_pid_(base::kNullProcessId) { | 31 peer_pid_(base::kNullProcessId) { |
147 DCHECK(ipc_task_runner_.get()); | 32 DCHECK(ipc_task_runner_.get()); |
148 // The Listener thread where Messages are handled must be a separate thread | 33 // The Listener thread where Messages are handled must be a separate thread |
(...skipping 390 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
539 Channel* channel = context_.get()->channel_.get(); | 424 Channel* channel = context_.get()->channel_.get(); |
540 // Channel must have been created first. | 425 // Channel must have been created first. |
541 DCHECK(channel) << context_.get()->channel_id_; | 426 DCHECK(channel) << context_.get()->channel_id_; |
542 return channel->GetPeerEuid(peer_euid); | 427 return channel->GetPeerEuid(peer_euid); |
543 } | 428 } |
544 #endif | 429 #endif |
545 | 430 |
546 //----------------------------------------------------------------------------- | 431 //----------------------------------------------------------------------------- |
547 | 432 |
548 } // namespace IPC | 433 } // namespace IPC |
OLD | NEW |