1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright 2014 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.
#ifndef MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_
#define MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_
#include <stddef.h>
#include <stdint.h>
#include <limits>
#include <vector>
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/pickle_buffer.h"
namespace mojo {
// Message is a holder for the data and handles to be sent over a MessagePipe.
// Message owns its data and handles, but a consumer of Message is free to
// mutate the data and handles. The message's data is comprised of a header
// followed by payload.
class Message {
public:
Message();
~Message();
void Initialize(size_t capacity, bool zero_initialized);
// Transfers data and handles to |destination|.
void MoveTo(Message* destination);
uint32_t data_num_bytes() const {
DCHECK(buffer_->data_num_bytes() <= std::numeric_limits<uint32_t>::max());
return static_cast<uint32_t>(buffer_->data_num_bytes());
}
// Access the raw bytes of the message.
const uint8_t* data() const {
return static_cast<const uint8_t*>(buffer_->data());
}
uint8_t* mutable_data() { return static_cast<uint8_t*>(buffer_->data()); }
// Access the header.
const internal::MessageHeader* header() const {
return static_cast<const internal::MessageHeader*>(buffer_->data());
}
internal::MessageHeader* header() {
return const_cast<internal::MessageHeader*>(
static_cast<const Message*>(this)->header());
}
uint32_t interface_id() const { return header()->interface_id; }
void set_interface_id(uint32_t id) { header()->interface_id = id; }
uint32_t name() const { return header()->name; }
bool has_flag(uint32_t flag) const { return !!(header()->flags & flag); }
// Access the request_id field (if present).
bool has_request_id() const { return header()->version >= 1; }
uint64_t request_id() const {
DCHECK(has_request_id());
return static_cast<const internal::MessageHeaderWithRequestID*>(
header())->request_id;
}
void set_request_id(uint64_t request_id) {
DCHECK(has_request_id());
static_cast<internal::MessageHeaderWithRequestID*>(header())
->request_id = request_id;
}
// Access the payload.
const uint8_t* payload() const { return data() + header()->num_bytes; }
uint8_t* mutable_payload() { return const_cast<uint8_t*>(payload()); }
uint32_t payload_num_bytes() const {
DCHECK(buffer_->data_num_bytes() >= header()->num_bytes);
size_t num_bytes = buffer_->data_num_bytes() - header()->num_bytes;
DCHECK(num_bytes <= std::numeric_limits<uint32_t>::max());
return static_cast<uint32_t>(num_bytes);
}
// Access the handles.
const std::vector<Handle>* handles() const { return &handles_; }
std::vector<Handle>* mutable_handles() { return &handles_; }
// Access the underlying Buffer interface.
internal::Buffer* buffer() { return buffer_.get(); }
private:
void CloseHandles();
scoped_ptr<internal::PickleBuffer> buffer_;
std::vector<Handle> handles_;
MOJO_DISALLOW_COPY_AND_ASSIGN(Message);
};
class MessageReceiver {
public:
virtual ~MessageReceiver() {}
// The receiver may mutate the given message. Returns true if the message
// was accepted and false otherwise, indicating that the message was invalid
// or malformed.
virtual bool Accept(Message* message) MOJO_WARN_UNUSED_RESULT = 0;
};
class MessageReceiverWithResponder : public MessageReceiver {
public:
~MessageReceiverWithResponder() override {}
// A variant on Accept that registers a MessageReceiver (known as the
// responder) to handle the response message generated from the given
// message. The responder's Accept method may be called during
// AcceptWithResponder or some time after its return.
//
// NOTE: Upon returning true, AcceptWithResponder assumes ownership of
// |responder| and will delete it after calling |responder->Accept| or upon
// its own destruction.
//
virtual bool AcceptWithResponder(Message* message, MessageReceiver* responder)
MOJO_WARN_UNUSED_RESULT = 0;
};
// A MessageReceiver that is also able to provide status about the state
// of the underlying MessagePipe to which it will be forwarding messages
// received via the |Accept()| call.
class MessageReceiverWithStatus : public MessageReceiver {
public:
~MessageReceiverWithStatus() override {}
// Returns |true| if this MessageReceiver is currently bound to a MessagePipe,
// the pipe has not been closed, and the pipe has not encountered an error.
virtual bool IsValid() = 0;
};
// An alternative to MessageReceiverWithResponder for cases in which it
// is necessary for the implementor of this interface to know about the status
// of the MessagePipe which will carry the responses.
class MessageReceiverWithResponderStatus : public MessageReceiver {
public:
~MessageReceiverWithResponderStatus() override {}
// A variant on Accept that registers a MessageReceiverWithStatus (known as
// the responder) to handle the response message generated from the given
// message. Any of the responder's methods (Accept or IsValid) may be called
// during AcceptWithResponder or some time after its return.
//
// NOTE: Upon returning true, AcceptWithResponder assumes ownership of
// |responder| and will delete it after calling |responder->Accept| or upon
// its own destruction.
//
virtual bool AcceptWithResponder(Message* message,
MessageReceiverWithStatus* responder)
MOJO_WARN_UNUSED_RESULT = 0;
};
// Read a single message from the pipe. The caller should have created the
// Message, but not called Initialize(). Returns MOJO_RESULT_SHOULD_WAIT if
// the caller should wait on the handle to become readable. Returns
// MOJO_RESULT_OK if the message was read successfully and should be
// dispatched, otherwise returns an error code if something went wrong.
//
// NOTE: The message hasn't been validated and may be malformed!
MojoResult ReadMessage(MessagePipeHandle handle, Message* message);
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_BINDINGS_MESSAGE_H_
|
