OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 <stdlib.h> | 5 #include <stdlib.h> |
6 #include <string.h> | 6 #include <string.h> |
7 | 7 |
8 #include "mojo/public/bindings/lib/message_builder.h" | 8 #include "mojo/public/bindings/lib/message_builder.h" |
9 #include "mojo/public/bindings/lib/message_queue.h" | 9 #include "mojo/public/bindings/lib/message_queue.h" |
10 #include "mojo/public/bindings/lib/router.h" | 10 #include "mojo/public/bindings/lib/router.h" |
(...skipping 16 matching lines...) Expand all Loading... |
27 void AllocResponseMessage(uint32_t name, const char* text, | 27 void AllocResponseMessage(uint32_t name, const char* text, |
28 uint64_t request_id, Message* message) { | 28 uint64_t request_id, Message* message) { |
29 size_t payload_size = strlen(text) + 1; // Plus null terminator. | 29 size_t payload_size = strlen(text) + 1; // Plus null terminator. |
30 internal::ResponseMessageBuilder builder(name, payload_size, request_id); | 30 internal::ResponseMessageBuilder builder(name, payload_size, request_id); |
31 memcpy(builder.buffer()->Allocate(payload_size), text, payload_size); | 31 memcpy(builder.buffer()->Allocate(payload_size), text, payload_size); |
32 builder.Finish(message); | 32 builder.Finish(message); |
33 } | 33 } |
34 | 34 |
35 class MessageAccumulator : public MessageReceiver { | 35 class MessageAccumulator : public MessageReceiver { |
36 public: | 36 public: |
37 MessageAccumulator() { | 37 explicit MessageAccumulator(internal::MessageQueue* queue) : queue_(queue) { |
38 } | 38 } |
39 | 39 |
40 virtual bool Accept(Message* message) MOJO_OVERRIDE { | 40 virtual bool Accept(Message* message) MOJO_OVERRIDE { |
41 queue_.Push(message); | 41 queue_->Push(message); |
42 return true; | 42 return true; |
43 } | 43 } |
44 | 44 |
45 virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder) | 45 virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder) |
46 MOJO_OVERRIDE { | 46 MOJO_OVERRIDE { |
47 return false; | 47 return false; |
48 } | 48 } |
49 | 49 |
50 bool IsEmpty() const { | |
51 return queue_.IsEmpty(); | |
52 } | |
53 | |
54 void Pop(Message* message) { | |
55 queue_.Pop(message); | |
56 } | |
57 | |
58 private: | 50 private: |
59 internal::MessageQueue queue_; | 51 internal::MessageQueue* queue_; |
60 }; | 52 }; |
61 | 53 |
62 class ResponseGenerator : public MessageReceiver { | 54 class ResponseGenerator : public MessageReceiver { |
63 public: | 55 public: |
64 ResponseGenerator() { | 56 ResponseGenerator() { |
65 } | 57 } |
66 | 58 |
67 virtual bool Accept(Message* message) MOJO_OVERRIDE { | 59 virtual bool Accept(Message* message) MOJO_OVERRIDE { |
68 return false; | 60 return false; |
69 } | 61 } |
70 | 62 |
71 virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder) | 63 virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder) |
72 MOJO_OVERRIDE { | 64 MOJO_OVERRIDE { |
73 EXPECT_TRUE(message->has_flag(internal::kMessageExpectsResponse)); | 65 EXPECT_TRUE(message->has_flag(internal::kMessageExpectsResponse)); |
74 | 66 |
75 return SendResponse(message->name(), message->request_id(), responder); | 67 return SendResponse(message->name(), message->request_id(), responder); |
76 } | 68 } |
77 | 69 |
78 bool SendResponse(uint32_t name, uint64_t request_id, | 70 bool SendResponse(uint32_t name, uint64_t request_id, |
79 MessageReceiver* responder) { | 71 MessageReceiver* responder) { |
80 Message response; | 72 Message response; |
81 AllocResponseMessage(name, "world", request_id, &response); | 73 AllocResponseMessage(name, "world", request_id, &response); |
82 return responder->Accept(&response); | 74 |
| 75 bool result = responder->Accept(&response); |
| 76 delete responder; |
| 77 return result; |
83 } | 78 } |
84 }; | 79 }; |
85 | 80 |
86 class LazyResponseGenerator : public ResponseGenerator { | 81 class LazyResponseGenerator : public ResponseGenerator { |
87 public: | 82 public: |
| 83 LazyResponseGenerator() : responder_(NULL), name_(0), request_id_(0) { |
| 84 } |
| 85 |
| 86 virtual ~LazyResponseGenerator() { |
| 87 delete responder_; |
| 88 } |
| 89 |
88 virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder) | 90 virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder) |
89 MOJO_OVERRIDE { | 91 MOJO_OVERRIDE { |
90 name_ = message->name(); | 92 name_ = message->name(); |
91 request_id_ = message->request_id(); | 93 request_id_ = message->request_id(); |
92 responder_ = responder; | 94 responder_ = responder; |
93 return true; | 95 return true; |
94 } | 96 } |
95 | 97 |
96 bool has_responder() const { return !!responder_; } | 98 bool has_responder() const { return !!responder_; } |
97 | 99 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
134 TEST_F(RouterTest, BasicRequestResponse) { | 136 TEST_F(RouterTest, BasicRequestResponse) { |
135 internal::Router router0(handle0_.Pass()); | 137 internal::Router router0(handle0_.Pass()); |
136 internal::Router router1(handle1_.Pass()); | 138 internal::Router router1(handle1_.Pass()); |
137 | 139 |
138 ResponseGenerator generator; | 140 ResponseGenerator generator; |
139 router1.set_incoming_receiver(&generator); | 141 router1.set_incoming_receiver(&generator); |
140 | 142 |
141 Message request; | 143 Message request; |
142 AllocRequestMessage(1, "hello", &request); | 144 AllocRequestMessage(1, "hello", &request); |
143 | 145 |
144 MessageAccumulator accumulator; | 146 internal::MessageQueue message_queue; |
145 router0.AcceptWithResponder(&request, &accumulator); | 147 router0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue)); |
146 | 148 |
147 PumpMessages(); | 149 PumpMessages(); |
148 | 150 |
149 EXPECT_FALSE(accumulator.IsEmpty()); | 151 EXPECT_FALSE(message_queue.IsEmpty()); |
150 | 152 |
151 Message response; | 153 Message response; |
152 accumulator.Pop(&response); | 154 message_queue.Pop(&response); |
153 | 155 |
154 EXPECT_EQ(std::string("world"), | 156 EXPECT_EQ(std::string("world"), |
155 std::string(reinterpret_cast<const char*>(response.payload()))); | 157 std::string(reinterpret_cast<const char*>(response.payload()))); |
156 } | 158 } |
157 | 159 |
158 TEST_F(RouterTest, RequestWithNoReceiver) { | 160 TEST_F(RouterTest, RequestWithNoReceiver) { |
159 internal::Router router0(handle0_.Pass()); | 161 internal::Router router0(handle0_.Pass()); |
160 internal::Router router1(handle1_.Pass()); | 162 internal::Router router1(handle1_.Pass()); |
161 | 163 |
162 // Without an incoming receiver set on router1, we expect router0 to observe | 164 // Without an incoming receiver set on router1, we expect router0 to observe |
163 // an error as a result of sending a message. | 165 // an error as a result of sending a message. |
164 | 166 |
165 Message request; | 167 Message request; |
166 AllocRequestMessage(1, "hello", &request); | 168 AllocRequestMessage(1, "hello", &request); |
167 | 169 |
168 MessageAccumulator accumulator; | 170 internal::MessageQueue message_queue; |
169 router0.AcceptWithResponder(&request, &accumulator); | 171 router0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue)); |
170 | 172 |
171 PumpMessages(); | 173 PumpMessages(); |
172 | 174 |
173 EXPECT_TRUE(router0.encountered_error()); | 175 EXPECT_TRUE(router0.encountered_error()); |
174 EXPECT_TRUE(router1.encountered_error()); | 176 EXPECT_TRUE(router1.encountered_error()); |
175 EXPECT_TRUE(accumulator.IsEmpty()); | 177 EXPECT_TRUE(message_queue.IsEmpty()); |
176 } | 178 } |
177 | 179 |
178 TEST_F(RouterTest, LateResponse) { | 180 TEST_F(RouterTest, LateResponse) { |
179 // Test that things won't blow up if we try to send a message to a | 181 // Test that things won't blow up if we try to send a message to a |
180 // MessageReceiver, which was given to us via AcceptWithResponder, | 182 // MessageReceiver, which was given to us via AcceptWithResponder, |
181 // after the router has gone away. | 183 // after the router has gone away. |
182 | 184 |
183 LazyResponseGenerator generator; | 185 LazyResponseGenerator generator; |
184 { | 186 { |
185 internal::Router router0(handle0_.Pass()); | 187 internal::Router router0(handle0_.Pass()); |
186 internal::Router router1(handle1_.Pass()); | 188 internal::Router router1(handle1_.Pass()); |
187 | 189 |
188 router1.set_incoming_receiver(&generator); | 190 router1.set_incoming_receiver(&generator); |
189 | 191 |
190 Message request; | 192 Message request; |
191 AllocRequestMessage(1, "hello", &request); | 193 AllocRequestMessage(1, "hello", &request); |
192 | 194 |
193 MessageAccumulator accumulator; | 195 internal::MessageQueue message_queue; |
194 router0.AcceptWithResponder(&request, &accumulator); | 196 router0.AcceptWithResponder(&request, |
| 197 new MessageAccumulator(&message_queue)); |
195 | 198 |
196 PumpMessages(); | 199 PumpMessages(); |
197 | 200 |
198 EXPECT_TRUE(generator.has_responder()); | 201 EXPECT_TRUE(generator.has_responder()); |
199 | 202 |
200 } | 203 } |
201 | 204 |
202 generator.Complete(); // This should end up doing nothing. | 205 generator.Complete(); // This should end up doing nothing. |
203 } | 206 } |
204 | 207 |
205 } // namespace | 208 } // namespace |
206 } // namespace test | 209 } // namespace test |
207 } // namespace mojo | 210 } // namespace mojo |
OLD | NEW |