OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 package org.chromium.mojo.bindings; | |
6 | |
7 import org.chromium.mojo.system.AsyncWaiter; | |
8 import org.chromium.mojo.system.MessagePipeHandle; | |
9 | |
10 import java.util.HashMap; | |
11 import java.util.Map; | |
12 | |
13 /** | |
14 * Implementation of Router. | |
rmcilroy
2014/07/10 19:03:59
{@link Router}
qsr
2014/07/11 11:42:08
Done.
| |
15 */ | |
16 public class RouterImpl implements Router { | |
17 | |
18 /** | |
19 * {@link MessageReceiver} used as the {@link Connector} callback. | |
20 */ | |
21 private class Thunk implements MessageReceiver { | |
rmcilroy
2014/07/10 19:03:59
Thunk is not a very clear name for what the class
qsr
2014/07/11 11:42:08
It is the name the C++ implementation use. I'd lik
| |
22 | |
23 /** | |
24 * @see MessageReceiver#accept(Message) | |
25 */ | |
26 @Override | |
27 public boolean accept(Message message) { | |
28 return handleIncomingMessage(message); | |
29 } | |
30 | |
31 } | |
32 | |
33 /** | |
34 * The {@link Connector} connected to the handle. | |
rmcilroy
2014/07/10 19:03:59
/s/connected/which is connected
qsr
2014/07/11 11:42:08
Done.
| |
35 */ | |
36 private final Connector mConnector; | |
37 | |
38 /** | |
39 * The {@link MessageReceiverWithResponder} that will deserialize and use th e message received | |
rmcilroy
2014/07/10 19:03:59
/s/deserialize and use/consume
/s/message/messages
qsr
2014/07/11 11:42:08
Done.
| |
40 * from the pipe. | |
41 */ | |
42 private MessageReceiverWithResponder mIncomingMessageReceiver; | |
43 | |
44 /** | |
45 * The id of the next request that needs a response. It is auto-incremented. | |
rmcilroy
2014/07/10 19:03:59
The next id to use for a request id which needs a
qsr
2014/07/11 11:42:09
Done.
| |
46 */ | |
47 private long mNextRequestId = 1; | |
48 | |
49 /** | |
50 * The map from request ids to {@link MessageReceiver} of request currently in flight. | |
51 */ | |
52 private Map<Long, MessageReceiver> mResponders = new HashMap<Long, MessageRe ceiver>(); | |
53 | |
54 /** | |
55 * Constructor. | |
rmcilroy
2014/07/10 19:03:59
Detail parameters and that it uses the default asy
qsr
2014/07/11 11:42:09
Done.
| |
56 */ | |
57 public RouterImpl(MessagePipeHandle messagePipeHandle) { | |
58 this(messagePipeHandle, BindingsHelper.getDefaultAsyncWaiterForHandle(me ssagePipeHandle)); | |
59 } | |
60 | |
61 /** | |
62 * Constructor. | |
rmcilroy
2014/07/10 19:03:59
Detail parameters
qsr
2014/07/11 11:42:08
Done.
| |
63 */ | |
64 public RouterImpl(MessagePipeHandle messagePipeHandle, AsyncWaiter asyncWait er) { | |
65 mConnector = new Connector(messagePipeHandle, asyncWaiter); | |
66 mConnector.setIncomingMessageReceiver(new Thunk()); | |
67 } | |
68 | |
69 /** | |
70 * @see org.chromium.mojo.bindings.Router#start() | |
71 */ | |
72 @Override | |
73 public void start() { | |
74 mConnector.start(); | |
75 } | |
76 | |
77 /** | |
78 * @see Router#setIncomingMessageReceiver(MessageReceiverWithResponder) | |
79 */ | |
80 @Override | |
81 public void setIncomingMessageReceiver(MessageReceiverWithResponder incoming MessageReceiver) { | |
82 this.mIncomingMessageReceiver = incomingMessageReceiver; | |
83 } | |
84 | |
85 /** | |
86 * @see MessageReceiver#accept(Message) | |
87 */ | |
88 @Override | |
89 public boolean accept(Message message) { | |
90 // A message without receiver is directly forwarded to the connector. | |
rmcilroy
2014/07/10 19:03:59
/s/receiever/a responder
qsr
2014/07/11 11:42:08
Done.
| |
91 return mConnector.accept(message); | |
92 } | |
93 | |
94 /** | |
95 * @see MessageReceiverWithResponder#acceptWithResponder(Message, MessageRec eiver) | |
96 */ | |
97 @Override | |
98 public boolean acceptWithResponder(Message message, MessageReceiver receiver ) { | |
rmcilroy
2014/07/10 19:03:59
/s/receiver/responder
qsr
2014/07/11 11:42:09
Done.
| |
99 // Checking the message expects a response. | |
100 assert message.getHeader().hasFlag(MessageHeader.MESSAGE_EXPECTS_RESPONS E_FLAG); | |
101 | |
102 // Compute a request id for being able to route the response. | |
103 long requestId = mNextRequestId++; | |
104 // Reserve 0 in case we want it to convey special meaning in the future. | |
105 if (requestId == 0) { | |
106 requestId = mNextRequestId++; | |
107 } | |
108 assert !mResponders.containsKey(requestId); | |
rmcilroy
2014/07/10 19:03:59
I don't think it's enough to just assert this - ev
qsr
2014/07/11 11:42:09
Done. I don't think (famous last words) that it is
| |
109 MessageHeader.setRequestId(message, requestId); | |
110 if (!mConnector.accept(message)) { | |
111 return false; | |
112 } | |
113 // Only keep the receiver is the message has been accepted. | |
rmcilroy
2014/07/10 19:03:59
/s/receiever/responder
qsr
2014/07/11 11:42:09
Done.
| |
114 mResponders.put(requestId, receiver); | |
115 return true; | |
116 } | |
117 | |
118 /** | |
119 * @see org.chromium.mojo.bindings.HandleOwner#passHandle() | |
120 */ | |
121 @Override | |
122 public MessagePipeHandle passHandle() { | |
123 return mConnector.passHandle(); | |
124 } | |
125 | |
126 /** | |
127 * @see java.io.Closeable#close() | |
128 */ | |
129 @Override | |
130 public void close() { | |
131 mConnector.close(); | |
132 } | |
133 | |
134 /** | |
135 * @see Router#setErrorHandler(ConnectionErrorHandler) | |
136 */ | |
137 @Override | |
138 public void setErrorHandler(ConnectionErrorHandler errorHandler) { | |
139 mConnector.setErrorHandler(errorHandler); | |
140 } | |
141 | |
142 /** | |
143 * Receive a message from the connector. | |
rmcilroy
2014/07/10 19:03:59
describe what's returned
qsr
2014/07/11 11:42:08
Done.
| |
144 */ | |
145 private boolean handleIncomingMessage(Message message) { | |
146 MessageHeader header = message.getHeader(); | |
147 if (header.hasFlag(MessageHeader.MESSAGE_EXPECTS_RESPONSE_FLAG)) { | |
148 if (mIncomingMessageReceiver != null) { | |
149 return mIncomingMessageReceiver.acceptWithResponder(message, thi s); | |
150 } | |
151 // If we receive a request expecting a response when the client is n ot | |
152 // listening, then we have no choice but to tear down the pipe. | |
153 close(); | |
154 return false; | |
155 } else if (header.hasFlag(MessageHeader.MESSAGE_IS_RESPONSE_FLAG)) { | |
156 long requestId = header.getRequestId(); | |
157 MessageReceiver responder = mResponders.get(requestId); | |
158 if (responder == null) { | |
159 return false; | |
rmcilroy
2014/07/10 19:03:59
should we teardown here too?
qsr
2014/07/11 11:42:08
Not really. The message is routed, but the problem
| |
160 } | |
161 return responder.accept(message); | |
162 } else { | |
163 if (mIncomingMessageReceiver != null) { | |
164 return mIncomingMessageReceiver.accept(message); | |
165 } | |
166 // OK to drop the message. | |
167 } | |
168 return false; | |
169 } | |
170 | |
171 } | |
OLD | NEW |