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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sts=4 et sw=4 tw=99:
*/
#include <fcntl.h>
#include <stdio.h>
#include "jsfriendapi.h"
#include "js/StructuredClone.h"
#include "jsapi-tests/tests.h"
#include "vm/ArrayBufferObject.h"
#ifdef XP_WIN
# include <io.h>
# define GET_OS_FD(a) int(_get_osfhandle(a))
#else
# include <unistd.h>
# define GET_OS_FD(a) (a)
#endif
const char test_data[] = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const char test_filename[] = "temp-bug945152_MappedArrayBuffer";
BEGIN_TEST(testMappedArrayBuffer_bug945152)
{
TempFile test_file;
FILE* test_stream = test_file.open(test_filename);
CHECK(fputs(test_data, test_stream) != EOF);
test_file.close();
// Offset 0.
CHECK(TestCreateObject(0, 12));
// Aligned offset.
CHECK(TestCreateObject(8, 12));
// Unaligned offset.
CHECK(CreateNewObject(11, 12) == nullptr);
// Offset + length greater than file size.
CHECK(CreateNewObject(8, sizeof(test_data) - 7) == nullptr);
// Release the mapped content.
CHECK(TestReleaseContents());
// Detach mapped array buffer.
CHECK(TestDetachObject());
// Clone mapped array buffer.
CHECK(TestCloneObject());
// Steal mapped array buffer contents.
CHECK(TestStealContents());
// Transfer mapped array buffer contents.
CHECK(TestTransferObject());
// GC so we can remove the file we created.
GC(cx);
test_file.remove();
return true;
}
JSObject* CreateNewObject(const int offset, const int length)
{
int fd = open(test_filename, O_RDONLY);
void* ptr = JS_CreateMappedArrayBufferContents(GET_OS_FD(fd), offset, length);
close(fd);
if (!ptr)
return nullptr;
JSObject* obj = JS_NewMappedArrayBufferWithContents(cx, length, ptr);
if (!obj) {
JS_ReleaseMappedArrayBufferContents(ptr, length);
return nullptr;
}
return obj;
}
bool VerifyObject(JS::HandleObject obj, uint32_t offset, uint32_t length, const bool mapped)
{
JS::AutoCheckCannotGC nogc;
CHECK(obj);
CHECK(JS_IsArrayBufferObject(obj));
CHECK_EQUAL(JS_GetArrayBufferByteLength(obj), length);
if (mapped)
CHECK(JS_IsMappedArrayBufferObject(obj));
else
CHECK(!JS_IsMappedArrayBufferObject(obj));
bool sharedDummy;
const char* data =
reinterpret_cast<const char*>(JS_GetArrayBufferData(obj, &sharedDummy, nogc));
CHECK(data);
CHECK(memcmp(data, test_data + offset, length) == 0);
return true;
}
bool TestCreateObject(uint32_t offset, uint32_t length)
{
JS::RootedObject obj(cx, CreateNewObject(offset, length));
CHECK(VerifyObject(obj, offset, length, true));
return true;
}
bool TestReleaseContents()
{
int fd = open(test_filename, O_RDONLY);
void* ptr = JS_CreateMappedArrayBufferContents(GET_OS_FD(fd), 0, 12);
close(fd);
if (!ptr)
return false;
JS_ReleaseMappedArrayBufferContents(ptr, 12);
return true;
}
bool TestDetachObject()
{
JS::RootedObject obj(cx, CreateNewObject(8, 12));
CHECK(obj);
JS_DetachArrayBuffer(cx, obj);
CHECK(JS_IsDetachedArrayBufferObject(obj));
return true;
}
bool TestCloneObject()
{
JS::RootedObject obj1(cx, CreateNewObject(8, 12));
CHECK(obj1);
JSAutoStructuredCloneBuffer cloned_buffer(JS::StructuredCloneScope::SameProcessSameThread, nullptr, nullptr);
JS::RootedValue v1(cx, JS::ObjectValue(*obj1));
CHECK(cloned_buffer.write(cx, v1, nullptr, nullptr));
JS::RootedValue v2(cx);
CHECK(cloned_buffer.read(cx, &v2, nullptr, nullptr));
JS::RootedObject obj2(cx, v2.toObjectOrNull());
CHECK(VerifyObject(obj2, 8, 12, false));
return true;
}
bool TestStealContents()
{
JS::RootedObject obj(cx, CreateNewObject(8, 12));
CHECK(obj);
void* contents = JS_StealArrayBufferContents(cx, obj);
CHECK(contents);
CHECK(memcmp(contents, test_data + 8, 12) == 0);
CHECK(JS_IsDetachedArrayBufferObject(obj));
return true;
}
bool TestTransferObject()
{
JS::RootedObject obj1(cx, CreateNewObject(8, 12));
CHECK(obj1);
JS::RootedValue v1(cx, JS::ObjectValue(*obj1));
// Create an Array of transferable values.
JS::AutoValueVector argv(cx);
if (!argv.append(v1))
return false;
JS::RootedObject obj(cx, JS_NewArrayObject(cx, JS::HandleValueArray::subarray(argv, 0, 1)));
CHECK(obj);
JS::RootedValue transferable(cx, JS::ObjectValue(*obj));
JSAutoStructuredCloneBuffer cloned_buffer(JS::StructuredCloneScope::SameProcessSameThread, nullptr, nullptr);
CHECK(cloned_buffer.write(cx, v1, transferable, JS::CloneDataPolicy().denySharedArrayBuffer(), nullptr, nullptr));
JS::RootedValue v2(cx);
CHECK(cloned_buffer.read(cx, &v2, nullptr, nullptr));
JS::RootedObject obj2(cx, v2.toObjectOrNull());
CHECK(VerifyObject(obj2, 8, 12, true));
CHECK(JS_IsDetachedArrayBufferObject(obj1));
return true;
}
static void GC(JSContext* cx)
{
JS_GC(cx);
// Trigger another to wait for background finalization to end.
JS_GC(cx);
}
END_TEST(testMappedArrayBuffer_bug945152)
#undef GET_OS_FD
|
