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 #ifndef MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_ 6 #define MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_ 7 8 #include <assert.h> 9 10 #include <vector> 11 12 #include "mojo/public/cpp/bindings/lib/message_internal.h" 13 14 namespace mojo { 15 16 // Message is a holder for the data and handles to be sent over a MessagePipe. 17 // Message owns its data and handles, but a consumer of Message is free to 18 // mutate the data and handles. The message's data is comprised of a header 19 // followed by payload. 20 class Message { 21 public: 22 Message(); 23 ~Message(); 24 25 // These may only be called on a newly created Message object. 26 void AllocUninitializedData(uint32_t num_bytes); 27 void AdoptData(uint32_t num_bytes, internal::MessageData* data); 28 29 // Swaps data and handles between this Message and another. 30 void Swap(Message* other); 31 data_num_bytes()32 uint32_t data_num_bytes() const { return data_num_bytes_; } 33 34 // Access the raw bytes of the message. data()35 const uint8_t* data() const { return 36 reinterpret_cast<const uint8_t*>(data_); 37 } mutable_data()38 uint8_t* mutable_data() { return reinterpret_cast<uint8_t*>(data_); } 39 40 // Access the header. header()41 const internal::MessageHeader* header() const { return &data_->header; } 42 name()43 uint32_t name() const { return data_->header.name; } has_flag(uint32_t flag)44 bool has_flag(uint32_t flag) const { return !!(data_->header.flags & flag); } 45 46 // Access the request_id field (if present). has_request_id()47 bool has_request_id() const { return data_->header.num_fields >= 3; } request_id()48 uint64_t request_id() const { 49 assert(has_request_id()); 50 return static_cast<const internal::MessageHeaderWithRequestID*>( 51 &data_->header)->request_id; 52 } set_request_id(uint64_t request_id)53 void set_request_id(uint64_t request_id) { 54 assert(has_request_id()); 55 static_cast<internal::MessageHeaderWithRequestID*>(&data_->header)-> 56 request_id = request_id; 57 } 58 59 // Access the payload. payload()60 const uint8_t* payload() const { 61 return reinterpret_cast<const uint8_t*>(data_) + data_->header.num_bytes; 62 } mutable_payload()63 uint8_t* mutable_payload() { 64 return reinterpret_cast<uint8_t*>(data_) + data_->header.num_bytes; 65 } payload_num_bytes()66 uint32_t payload_num_bytes() const { 67 assert(data_num_bytes_ >= data_->header.num_bytes); 68 return data_num_bytes_ - data_->header.num_bytes; 69 } 70 71 // Access the handles. handles()72 const std::vector<Handle>* handles() const { return &handles_; } mutable_handles()73 std::vector<Handle>* mutable_handles() { return &handles_; } 74 75 private: 76 uint32_t data_num_bytes_; 77 internal::MessageData* data_; // Heap-allocated using malloc. 78 std::vector<Handle> handles_; 79 80 MOJO_DISALLOW_COPY_AND_ASSIGN(Message); 81 }; 82 83 class MessageReceiver { 84 public: ~MessageReceiver()85 virtual ~MessageReceiver() {} 86 87 // The receiver may mutate the given message. Returns true if the message 88 // was accepted and false otherwise, indicating that the message was invalid 89 // or malformed. 90 virtual bool Accept(Message* message) MOJO_WARN_UNUSED_RESULT = 0; 91 }; 92 93 class MessageReceiverWithResponder : public MessageReceiver { 94 public: ~MessageReceiverWithResponder()95 virtual ~MessageReceiverWithResponder() {} 96 97 // A variant on Accept that registers a MessageReceiver (known as the 98 // responder) to handle the response message generated from the given 99 // message. The responder's Accept method may be called during 100 // AcceptWithResponder or some time after its return. 101 // 102 // NOTE: Upon returning true, AcceptWithResponder assumes ownership of 103 // |responder| and will delete it after calling |responder->Accept| or upon 104 // its own destruction. 105 // 106 virtual bool AcceptWithResponder( 107 Message* message, MessageReceiver* responder) MOJO_WARN_UNUSED_RESULT = 0; 108 }; 109 110 // Read a single message from the pipe and dispatch to the given receiver. The 111 // receiver may be null, in which case the message is simply discarded. 112 // Returns MOJO_RESULT_SHOULD_WAIT if the caller should wait on the handle to 113 // become readable. Returns MOJO_RESULT_OK if a message was dispatched and 114 // otherwise returns an error code if something went wrong. 115 // 116 // NOTE: The message hasn't been validated and may be malformed! 117 MojoResult ReadAndDispatchMessage(MessagePipeHandle handle, 118 MessageReceiver* receiver, 119 bool* receiver_result); 120 121 } // namespace mojo 122 123 #endif // MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_ 124