| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "mojo/public/cpp/bindings/tests/router_test_util.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include "mojo/public/cpp/bindings/lib/message_builder.h" |
| #include "mojo/public/cpp/bindings/tests/message_queue.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace mojo { |
| namespace test { |
| |
| void AllocRequestMessage(uint32_t name, const char* text, Message* message) { |
| size_t payload_size = strlen(text) + 1; // Plus null terminator. |
| internal::MessageBuilder builder(name, Message::kFlagExpectsResponse, |
| payload_size, 0); |
| memcpy(builder.buffer()->Allocate(payload_size), text, payload_size); |
| *message = std::move(*builder.message()); |
| } |
| |
| void AllocResponseMessage(uint32_t name, |
| const char* text, |
| uint64_t request_id, |
| Message* message) { |
| size_t payload_size = strlen(text) + 1; // Plus null terminator. |
| internal::MessageBuilder builder(name, Message::kFlagIsResponse, payload_size, |
| 0); |
| builder.message()->set_request_id(request_id); |
| memcpy(builder.buffer()->Allocate(payload_size), text, payload_size); |
| *message = std::move(*builder.message()); |
| } |
| |
| MessageAccumulator::MessageAccumulator(MessageQueue* queue, |
| const base::Closure& closure) |
| : queue_(queue), closure_(closure) {} |
| |
| MessageAccumulator::~MessageAccumulator() {} |
| |
| bool MessageAccumulator::Accept(Message* message) { |
| queue_->Push(message); |
| if (!closure_.is_null()) { |
| closure_.Run(); |
| closure_.Reset(); |
| } |
| return true; |
| } |
| |
| ResponseGenerator::ResponseGenerator() {} |
| |
| bool ResponseGenerator::Accept(Message* message) { |
| return false; |
| } |
| |
| bool ResponseGenerator::AcceptWithResponder( |
| Message* message, |
| std::unique_ptr<MessageReceiverWithStatus> responder) { |
| EXPECT_TRUE(message->has_flag(Message::kFlagExpectsResponse)); |
| |
| bool result = SendResponse(message->name(), message->request_id(), |
| reinterpret_cast<const char*>(message->payload()), |
| responder.get()); |
| EXPECT_TRUE(responder->IsValid()); |
| return result; |
| } |
| |
| bool ResponseGenerator::SendResponse(uint32_t name, |
| uint64_t request_id, |
| const char* request_string, |
| MessageReceiver* responder) { |
| Message response; |
| std::string response_string(request_string); |
| response_string += " world!"; |
| AllocResponseMessage(name, response_string.c_str(), request_id, &response); |
| |
| return responder->Accept(&response); |
| } |
| |
| LazyResponseGenerator::LazyResponseGenerator(const base::Closure& closure) |
| : responder_(nullptr), name_(0), request_id_(0), closure_(closure) {} |
| |
| LazyResponseGenerator::~LazyResponseGenerator() = default; |
| |
| bool LazyResponseGenerator::AcceptWithResponder( |
| Message* message, |
| std::unique_ptr<MessageReceiverWithStatus> responder) { |
| name_ = message->name(); |
| request_id_ = message->request_id(); |
| request_string_ = |
| std::string(reinterpret_cast<const char*>(message->payload())); |
| responder_ = std::move(responder); |
| if (!closure_.is_null()) { |
| closure_.Run(); |
| closure_.Reset(); |
| } |
| return true; |
| } |
| |
| void LazyResponseGenerator::Complete(bool send_response) { |
| if (send_response) { |
| SendResponse(name_, request_id_, request_string_.c_str(), responder_.get()); |
| } |
| responder_ = nullptr; |
| } |
| |
| } // namespace test |
| } // namespace mojo |