blob: e9b8af04b7a4b7b190f91d555b4e07f2c3dc8a12 (
plain)
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
|
// 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.
#include "mojo/system/platform_handle_dispatcher.h"
#include <algorithm>
#include "base/logging.h"
namespace mojo {
namespace system {
namespace {
const size_t kInvalidPlatformHandleIndex = static_cast<size_t>(-1);
struct SerializedPlatformHandleDispatcher {
size_t platform_handle_index; // (Or |kInvalidPlatformHandleIndex|.)
};
} // namespace
PlatformHandleDispatcher::PlatformHandleDispatcher(
embedder::ScopedPlatformHandle platform_handle)
: platform_handle_(platform_handle.Pass()) {
}
embedder::ScopedPlatformHandle PlatformHandleDispatcher::PassPlatformHandle() {
base::AutoLock locker(lock());
return platform_handle_.Pass();
}
Dispatcher::Type PlatformHandleDispatcher::GetType() const {
return kTypePlatformHandle;
}
// static
scoped_refptr<PlatformHandleDispatcher> PlatformHandleDispatcher::Deserialize(
Channel* channel,
const void* source,
size_t size,
embedder::PlatformHandleVector* platform_handles) {
if (size != sizeof(SerializedPlatformHandleDispatcher)) {
LOG(ERROR) << "Invalid serialized platform handle dispatcher (bad size)";
return scoped_refptr<PlatformHandleDispatcher>();
}
const SerializedPlatformHandleDispatcher* serialization =
static_cast<const SerializedPlatformHandleDispatcher*>(source);
size_t platform_handle_index = serialization->platform_handle_index;
// Starts off invalid, which is what we want.
embedder::PlatformHandle platform_handle;
if (platform_handle_index != kInvalidPlatformHandleIndex) {
if (!platform_handles ||
platform_handle_index >= platform_handles->size()) {
LOG(ERROR)
<< "Invalid serialized platform handle dispatcher (missing handles)";
return scoped_refptr<PlatformHandleDispatcher>();
}
// We take ownership of the handle, so we have to invalidate the one in
// |platform_handles|.
std::swap(platform_handle, (*platform_handles)[platform_handle_index]);
}
return scoped_refptr<PlatformHandleDispatcher>(new PlatformHandleDispatcher(
embedder::ScopedPlatformHandle(platform_handle)));
}
PlatformHandleDispatcher::~PlatformHandleDispatcher() {
}
void PlatformHandleDispatcher::CloseImplNoLock() {
lock().AssertAcquired();
platform_handle_.reset();
}
scoped_refptr<Dispatcher>
PlatformHandleDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
lock().AssertAcquired();
return scoped_refptr<Dispatcher>(
new PlatformHandleDispatcher(platform_handle_.Pass()));
}
void PlatformHandleDispatcher::StartSerializeImplNoLock(
Channel* /*channel*/,
size_t* max_size,
size_t* max_platform_handles) {
DCHECK(HasOneRef()); // Only one ref => no need to take the lock.
*max_size = sizeof(SerializedPlatformHandleDispatcher);
*max_platform_handles = 1;
}
bool PlatformHandleDispatcher::EndSerializeAndCloseImplNoLock(
Channel* /*channel*/,
void* destination,
size_t* actual_size,
embedder::PlatformHandleVector* platform_handles) {
DCHECK(HasOneRef()); // Only one ref => no need to take the lock.
SerializedPlatformHandleDispatcher* serialization =
static_cast<SerializedPlatformHandleDispatcher*>(destination);
if (platform_handle_.is_valid()) {
serialization->platform_handle_index = platform_handles->size();
platform_handles->push_back(platform_handle_.release());
} else {
serialization->platform_handle_index = kInvalidPlatformHandleIndex;
}
*actual_size = sizeof(SerializedPlatformHandleDispatcher);
return true;
}
MojoWaitFlags PlatformHandleDispatcher::SatisfiedFlagsNoLock() const {
return MOJO_WAIT_FLAG_NONE;
}
MojoWaitFlags PlatformHandleDispatcher::SatisfiableFlagsNoLock() const {
return MOJO_WAIT_FLAG_NONE;
}
} // namespace system
} // namespace mojo
|
