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
|
// Copyright 2013 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/message.h"
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <algorithm>
#include <utility>
#include "base/logging.h"
#include "base/strings/stringprintf.h"
namespace mojo {
Message::Message() {
}
Message::~Message() {
CloseHandles();
}
void Message::Initialize(size_t capacity, bool zero_initialized) {
DCHECK(!buffer_);
buffer_.reset(new internal::MessageBuffer(capacity, zero_initialized));
}
void Message::InitializeFromMojoMessage(ScopedMessageHandle message,
uint32_t num_bytes,
std::vector<Handle>* handles) {
DCHECK(!buffer_);
buffer_.reset(new internal::MessageBuffer(std::move(message), num_bytes));
handles_.swap(*handles);
}
void Message::MoveTo(Message* destination) {
DCHECK(this != destination);
// No copy needed.
std::swap(destination->buffer_, buffer_);
std::swap(destination->handles_, handles_);
CloseHandles();
handles_.clear();
buffer_.reset();
}
ScopedMessageHandle Message::TakeMojoMessage() {
if (handles_.empty()) // Fast path for the common case: No handles.
return buffer_->TakeMessage();
// Allocate a new message with space for the handles, then copy the buffer
// contents into it.
//
// TODO(rockot): We could avoid this copy by extending GetSerializedSize()
// behavior to collect handles. It's unoptimized for now because it's much
// more common to have messages with no handles.
ScopedMessageHandle new_message;
MojoResult rv = AllocMessage(
data_num_bytes(),
handles_.empty() ? nullptr
: reinterpret_cast<const MojoHandle*>(handles_.data()),
handles_.size(),
MOJO_ALLOC_MESSAGE_FLAG_NONE,
&new_message);
CHECK_EQ(rv, MOJO_RESULT_OK);
handles_.clear();
void* new_buffer = nullptr;
rv = GetMessageBuffer(new_message.get(), &new_buffer);
CHECK_EQ(rv, MOJO_RESULT_OK);
memcpy(new_buffer, data(), data_num_bytes());
buffer_.reset();
return new_message;
}
void Message::NotifyBadMessage(const std::string& error) {
buffer_->NotifyBadMessage(error);
}
void Message::CloseHandles() {
for (std::vector<Handle>::iterator it = handles_.begin();
it != handles_.end(); ++it) {
if (it->is_valid())
CloseRaw(*it);
}
}
MojoResult ReadMessage(MessagePipeHandle handle, Message* message) {
MojoResult rv;
std::vector<Handle> handles;
ScopedMessageHandle mojo_message;
uint32_t num_bytes = 0, num_handles = 0;
rv = ReadMessageNew(handle,
&mojo_message,
&num_bytes,
nullptr,
&num_handles,
MOJO_READ_MESSAGE_FLAG_NONE);
if (rv == MOJO_RESULT_RESOURCE_EXHAUSTED) {
DCHECK_GT(num_handles, 0u);
handles.resize(num_handles);
rv = ReadMessageNew(handle,
&mojo_message,
&num_bytes,
reinterpret_cast<MojoHandle*>(handles.data()),
&num_handles,
MOJO_READ_MESSAGE_FLAG_NONE);
}
if (rv != MOJO_RESULT_OK)
return rv;
message->InitializeFromMojoMessage(
std::move(mojo_message), num_bytes, &handles);
return MOJO_RESULT_OK;
}
} // namespace mojo
|
