blob: c56f4154500319fba2104a62a07a97fd2ddfdce3 (
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
|
// 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/edk/system/platform_handle_dispatcher.h"
#include <algorithm>
#include "base/logging.h"
namespace mojo {
namespace edk {
namespace {
const size_t kInvalidPlatformHandleIndex = static_cast<size_t>(-1);
struct MOJO_ALIGNAS(8) SerializedPlatformHandleDispatcher {
size_t platform_handle_index; // (Or |kInvalidPlatformHandleIndex|.)
};
} // namespace
ScopedPlatformHandle PlatformHandleDispatcher::PassPlatformHandle() {
base::AutoLock locker(lock());
return platform_handle_.Pass();
}
Dispatcher::Type PlatformHandleDispatcher::GetType() const {
return Type::PLATFORM_HANDLE;
}
// static
scoped_refptr<PlatformHandleDispatcher> PlatformHandleDispatcher::Deserialize(
const void* source,
size_t size,
PlatformHandleVector* platform_handles) {
if (size != sizeof(SerializedPlatformHandleDispatcher)) {
LOG(ERROR) << "Invalid serialized platform handle dispatcher (bad size)";
return nullptr;
}
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.
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 nullptr;
}
// 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 Create(ScopedPlatformHandle(platform_handle));
}
PlatformHandleDispatcher::PlatformHandleDispatcher(
ScopedPlatformHandle platform_handle)
: platform_handle_(platform_handle.Pass()) {
}
PlatformHandleDispatcher::~PlatformHandleDispatcher() {
}
void PlatformHandleDispatcher::CloseImplNoLock() {
lock().AssertAcquired();
platform_handle_.reset();
}
scoped_refptr<Dispatcher>
PlatformHandleDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
lock().AssertAcquired();
return Create(platform_handle_.Pass());
}
void PlatformHandleDispatcher::StartSerializeImplNoLock(
size_t* max_size,
size_t* max_platform_handles) {
*max_size = sizeof(SerializedPlatformHandleDispatcher);
*max_platform_handles = 1;
}
bool PlatformHandleDispatcher::EndSerializeAndCloseImplNoLock(
void* destination,
size_t* actual_size,
PlatformHandleVector* platform_handles) {
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;
}
} // namespace edk
} // namespace mojo
|
