Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(383)

Side by Side Diff: mojo/public/cpp/bindings/tests/bindings_perftest.cc

Issue 2766523002: mojo: MessageReceiver*::AcceptWithResponder() now take a unique_ptr to the responder (Closed)
Patch Set: Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 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 <stddef.h> 5 #include <stddef.h>
6 #include <utility> 6 #include <utility>
7 7
8 #include "base/bind.h" 8 #include "base/bind.h"
9 #include "base/message_loop/message_loop.h" 9 #include "base/message_loop/message_loop.h"
10 #include "base/run_loop.h" 10 #include "base/run_loop.h"
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after
132 "InProcessPingPong", "1000_Inactive", 132 "InProcessPingPong", "1000_Inactive",
133 kIterations / MojoTicksToSeconds(end_time - start_time), 133 kIterations / MojoTicksToSeconds(end_time - start_time),
134 "pings/second"); 134 "pings/second");
135 135
136 delete[] inactive_services; 136 delete[] inactive_services;
137 } 137 }
138 } 138 }
139 139
140 class PingPongPaddle : public MessageReceiverWithResponderStatus { 140 class PingPongPaddle : public MessageReceiverWithResponderStatus {
141 public: 141 public:
142 PingPongPaddle(MessageReceiver* sender) : sender_(sender) {} 142 PingPongPaddle(std::unique_ptr<MessageReceiver> sender)
143 : sender_(std::move(sender)) {}
143 144
144 void set_sender(MessageReceiver* sender) { sender_ = sender; } 145 void set_sender(std::unique_ptr<MessageReceiver> sender) {
146 sender_ = std::move(sender);
147 }
145 148
146 bool Accept(Message* message) override { 149 bool Accept(Message* message) override {
147 uint32_t count = message->header()->name; 150 uint32_t count = message->header()->name;
148 if (!quit_closure_.is_null()) { 151 if (!quit_closure_.is_null()) {
149 count++; 152 count++;
150 if (count >= expected_count_) { 153 if (count >= expected_count_) {
151 end_time_ = base::TimeTicks::Now(); 154 end_time_ = base::TimeTicks::Now();
152 quit_closure_.Run(); 155 quit_closure_.Run();
153 return true; 156 return true;
154 } 157 }
155 } 158 }
156 159
157 internal::MessageBuilder builder(count, 0, 8, 0); 160 internal::MessageBuilder builder(count, 0, 8, 0);
158 bool result = sender_->Accept(builder.message()); 161 bool result = sender_->Accept(builder.message());
159 DCHECK(result); 162 DCHECK(result);
160 return true; 163 return true;
161 } 164 }
162 165
163 bool AcceptWithResponder(Message* message, 166 bool AcceptWithResponder(
164 MessageReceiverWithStatus* responder) override { 167 Message* message,
168 std::unique_ptr<MessageReceiverWithStatus> responder) override {
165 NOTREACHED(); 169 NOTREACHED();
166 return true; 170 return true;
167 } 171 }
168 172
169 base::TimeDelta Serve(uint32_t expected_count) { 173 base::TimeDelta Serve(uint32_t expected_count) {
170 base::RunLoop run_loop; 174 base::RunLoop run_loop;
171 175
172 expected_count_ = expected_count; 176 expected_count_ = expected_count;
173 quit_closure_ = run_loop.QuitClosure(); 177 quit_closure_ = run_loop.QuitClosure();
174 178
175 start_time_ = base::TimeTicks::Now(); 179 start_time_ = base::TimeTicks::Now();
176 internal::MessageBuilder builder(0, 0, 8, 0); 180 internal::MessageBuilder builder(0, 0, 8, 0);
177 bool result = sender_->Accept(builder.message()); 181 bool result = sender_->Accept(builder.message());
178 DCHECK(result); 182 DCHECK(result);
179 183
180 run_loop.Run(); 184 run_loop.Run();
181 185
182 return end_time_ - start_time_; 186 return end_time_ - start_time_;
183 } 187 }
184 188
185 private: 189 private:
186 base::TimeTicks start_time_; 190 base::TimeTicks start_time_;
187 base::TimeTicks end_time_; 191 base::TimeTicks end_time_;
188 uint32_t expected_count_ = 0; 192 uint32_t expected_count_ = 0;
189 MessageReceiver* sender_; 193 std::unique_ptr<MessageReceiver> sender_;
190 base::Closure quit_closure_; 194 base::Closure quit_closure_;
191 }; 195 };
192 196
193 TEST_F(MojoBindingsPerftest, MultiplexRouterPingPong) { 197 TEST_F(MojoBindingsPerftest, MultiplexRouterPingPong) {
194 MessagePipe pipe; 198 MessagePipe pipe;
195 scoped_refptr<internal::MultiplexRouter> router0( 199 scoped_refptr<internal::MultiplexRouter> router0(
196 new internal::MultiplexRouter(std::move(pipe.handle0), 200 new internal::MultiplexRouter(std::move(pipe.handle0),
197 internal::MultiplexRouter::SINGLE_INTERFACE, 201 internal::MultiplexRouter::SINGLE_INTERFACE,
198 true, base::ThreadTaskRunnerHandle::Get())); 202 true, base::ThreadTaskRunnerHandle::Get()));
199 scoped_refptr<internal::MultiplexRouter> router1( 203 scoped_refptr<internal::MultiplexRouter> router1(
(...skipping 25 matching lines...) Expand all
225 kTestIterations / duration.InSecondsF(), "pings/second"); 229 kTestIterations / duration.InSecondsF(), "pings/second");
226 } 230 }
227 231
228 class CounterReceiver : public MessageReceiverWithResponderStatus { 232 class CounterReceiver : public MessageReceiverWithResponderStatus {
229 public: 233 public:
230 bool Accept(Message* message) override { 234 bool Accept(Message* message) override {
231 counter_++; 235 counter_++;
232 return true; 236 return true;
233 } 237 }
234 238
235 bool AcceptWithResponder(Message* message, 239 bool AcceptWithResponder(
236 MessageReceiverWithStatus* responder) override { 240 Message* message,
241 std::unique_ptr<MessageReceiverWithStatus> responder) override {
237 NOTREACHED(); 242 NOTREACHED();
238 return true; 243 return true;
239 } 244 }
240 245
241 uint32_t counter() const { return counter_; } 246 uint32_t counter() const { return counter_; }
242 247
243 void Reset() { counter_ = 0; } 248 void Reset() { counter_ = 0; }
244 249
245 private: 250 private:
246 uint32_t counter_ = 0; 251 uint32_t counter_ = 0;
(...skipping 28 matching lines...) Expand all
275 if (i == 1) { 280 if (i == 1) {
276 test::LogPerfResult("MultiplexRouterDispatchCost", nullptr, 281 test::LogPerfResult("MultiplexRouterDispatchCost", nullptr,
277 kIterations[i] / duration.InSecondsF(), 282 kIterations[i] / duration.InSecondsF(),
278 "times/second"); 283 "times/second");
279 } 284 }
280 } 285 }
281 } 286 }
282 287
283 } // namespace 288 } // namespace
284 } // namespace mojo 289 } // namespace mojo
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698