Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(69)

Side by Side Diff: ppapi/tests/test_file_mapping.cc

Issue 69663002: PPAPI: Implement PPB_FileMapping on POSIX (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: bbudge review comments Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ppapi/tests/test_file_mapping.h"
6
7 #include <string.h>
8
9 #include <limits>
10 #include <string>
11
12 #include "ppapi/c/pp_errors.h"
13 #include "ppapi/c/ppb_file_io.h"
14 #include "ppapi/c/ppb_file_mapping.h"
15 #include "ppapi/cpp/file_io.h"
16 #include "ppapi/cpp/file_ref.h"
17 #include "ppapi/cpp/file_system.h"
18 #include "ppapi/cpp/instance.h"
19 #include "ppapi/cpp/module.h"
20 #include "ppapi/tests/test_utils.h"
21
22 REGISTER_TEST_CASE(FileMapping);
23
24 namespace {
25
26 // TODO(dmichael): Move these to test_utils so we can share them?
27 int32_t ReadEntireFile(PP_Instance instance,
28 pp::FileIO* file_io,
29 int32_t offset,
30 std::string* data,
31 CallbackType callback_type) {
32 TestCompletionCallback callback(instance, callback_type);
33 char buf[256];
34 int32_t read_offset = offset;
35
36 for (;;) {
37 callback.WaitForResult(
38 file_io->Read(read_offset, buf, sizeof(buf), callback.GetCallback()));
39 if (callback.result() < 0)
40 return callback.result();
41 if (callback.result() == 0)
42 break;
43 read_offset += callback.result();
44 data->append(buf, callback.result());
45 }
46
47 return PP_OK;
48 }
49
50 int32_t WriteEntireBuffer(PP_Instance instance,
51 pp::FileIO* file_io,
52 int32_t offset,
53 const std::string& data,
54 CallbackType callback_type) {
55 TestCompletionCallback callback(instance, callback_type);
56 int32_t write_offset = offset;
57 const char* buf = data.c_str();
58 int32_t size = data.size();
59
60 while (write_offset < offset + size) {
61 callback.WaitForResult(file_io->Write(write_offset,
62 &buf[write_offset - offset],
63 size - write_offset + offset,
64 callback.GetCallback()));
65 if (callback.result() < 0)
66 return callback.result();
67 if (callback.result() == 0)
68 return PP_ERROR_FAILED;
69 write_offset += callback.result();
70 }
71 callback.WaitForResult(file_io->Flush(callback.GetCallback()));
72 return callback.result();
73 }
74
75 } // namespace
76
77 std::string TestFileMapping::MapAndCheckResults(uint32_t prot,
78 uint32_t flags) {
79 TestCompletionCallback callback(instance_->pp_instance(), callback_type());
80
81 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
82 pp::FileRef file_ref(file_system, "/mapped_file");
83
84 callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
85 ASSERT_EQ(PP_OK, callback.result());
86
87 const int64_t page_size =
88 file_mapping_if_->GetMapPageSize(instance_->pp_instance());
89 const int64_t kNumPages = 4;
90 // Make a string that's big enough that it spans all of the first |n-1| pages,
91 // plus a little bit of the |nth| page.
92 std::string file_contents((page_size * (kNumPages - 1)) + 128, 'a');
93
94 pp::FileIO file_io(instance_);
95 callback.WaitForResult(file_io.Open(file_ref,
96 PP_FILEOPENFLAG_CREATE |
97 PP_FILEOPENFLAG_TRUNCATE |
98 PP_FILEOPENFLAG_READ |
99 PP_FILEOPENFLAG_WRITE,
100 callback.GetCallback()));
101 ASSERT_EQ(PP_OK, callback.result());
102 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
103 &file_io,
104 0,
105 file_contents,
106 callback_type()));
107
108 // TODO(dmichael): Use C++ interface.
109 void* address = NULL;
110 callback.WaitForResult(
111 file_mapping_if_->Map(
112 instance_->pp_instance(),
113 file_io.pp_resource(),
114 kNumPages * page_size,
115 prot,
116 flags,
117 0,
118 &address,
119 callback.GetCallback().pp_completion_callback()));
120 CHECK_CALLBACK_BEHAVIOR(callback);
121 ASSERT_EQ(PP_OK, callback.result());
122 ASSERT_NE(NULL, address);
123
124 if (prot & PP_FILEMAPPROTECTION_READ) {
125 // Make sure we can read.
126 std::string mapped_data(static_cast<char*>(address), file_contents.size());
127 // The initial data should match.
128 ASSERT_EQ(file_contents, mapped_data);
129
130 // Now write some data and flush it.
131 const std::string file_contents2(file_contents.size(), 'x');
132 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
133 &file_io,
134 0,
135 file_contents2,
136 callback_type()));
137 // If the region was mapped SHARED, it should get updated.
138 std::string mapped_data2(static_cast<char*>(address), file_contents.size());
139 if (flags & PP_FILEMAPFLAG_SHARED)
140 ASSERT_EQ(file_contents2, mapped_data2);
141 // In POSIX, it is unspecified in the PRIVATE case whether changes to the
142 // file are visible to the mapped region. So we can't really test anything
143 // here in that case.
144 // FIXME(dmichael): Make sure our Pepper documentation reflects this.
bbudge 2014/01/27 18:56:44 // TODO?
dmichael (off chromium) 2014/01/27 19:20:26 Done.
145 }
146 if (prot & PP_FILEMAPPROTECTION_WRITE) {
147 std::string old_file_contents;
148 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(),
149 &file_io,
150 0,
151 &old_file_contents,
152 callback_type()));
153 // Write something else to the mapped region, then unmap, and see if it
154 // gets written to the file. (Note we have to Unmap to make sure that the
155 // write is committed).
156 memset(address, 'y', file_contents.size());
157 // Note, we might not have read access to the mapped region here, so we
158 // make a string with the same contents without actually reading.
159 std::string mapped_data3(file_contents.size(), 'y');
160 callback.WaitForResult(
161 file_mapping_if_->Unmap(
162 instance_->pp_instance(), address, file_contents.size(),
163 callback.GetCallback().pp_completion_callback()));
164 CHECK_CALLBACK_BEHAVIOR(callback);
165 ASSERT_EQ(PP_OK, callback.result());
166 std::string new_file_contents;
167 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(),
168 &file_io,
169 0,
170 &new_file_contents,
171 callback_type()));
172
173 // Sanity-check that the data we wrote isn't the same as what was already
174 // there, otherwise our test is invalid.
175 ASSERT_NE(mapped_data3, old_file_contents);
176 // If it's SHARED, the file should match what we wrote to the mapped region.
177 // Otherwise, it should not have changed.
178 if (flags & PP_FILEMAPFLAG_SHARED)
179 ASSERT_EQ(mapped_data3, new_file_contents);
180 else
181 ASSERT_EQ(old_file_contents, new_file_contents);
182 } else {
183 // We didn't do the "WRITE" test, but we still want to Unmap.
184 callback.WaitForResult(
185 file_mapping_if_->Unmap(
186 instance_->pp_instance(), address, file_contents.size(),
187 callback.GetCallback().pp_completion_callback()));
188 CHECK_CALLBACK_BEHAVIOR(callback);
189 ASSERT_EQ(PP_OK, callback.result());
190 }
191 PASS();
192 }
193
194 bool TestFileMapping::Init() {
195 // TODO(dmichael): Use unversioned string when this goes to stable?
196 file_mapping_if_ = static_cast<const PPB_FileMapping_0_1*>(
197 pp::Module::Get()->GetBrowserInterface(PPB_FILEMAPPING_INTERFACE_0_1));
198 return !!file_mapping_if_ && CheckTestingInterface() &&
199 EnsureRunningOverHTTP();
200 }
201
202 void TestFileMapping::RunTests(const std::string& filter) {
203 // TODO(dmichael): Tests to write:
204 // - Unmapping partial regions
bbudge 2014/01/27 18:56:44 What would you test that isn't already tested in P
dmichael (off chromium) 2014/01/27 19:20:26 Oops, that's an old comment, thanks :)
205 RUN_CALLBACK_TEST(TestFileMapping, BadParameters, filter);
206 RUN_CALLBACK_TEST(TestFileMapping, Map, filter);
207 RUN_CALLBACK_TEST(TestFileMapping, PartialRegions, filter);
208 }
209
210 std::string TestFileMapping::TestBadParameters() {
211 TestCompletionCallback callback(instance_->pp_instance(), callback_type());
212
213 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
214 pp::FileRef file_ref(file_system, "/mapped_file");
215
216 callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
217 ASSERT_EQ(PP_OK, callback.result());
218
219 const int64_t page_size =
220 file_mapping_if_->GetMapPageSize(instance_->pp_instance());
221 // const int64_t kNumPages = 4;
222 // Make a string that's big enough that it spans 3 pages, plus a little extra.
223 //std::string file_contents((page_size * (kNumPages - 1)) + 128, 'a');
224 std::string file_contents(page_size, 'a');
225
226 pp::FileIO file_io(instance_);
227 callback.WaitForResult(file_io.Open(file_ref,
228 PP_FILEOPENFLAG_CREATE |
229 PP_FILEOPENFLAG_TRUNCATE |
230 PP_FILEOPENFLAG_READ |
231 PP_FILEOPENFLAG_WRITE,
232 callback.GetCallback()));
233 ASSERT_EQ(PP_OK, callback.result());
234 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
235 &file_io,
236 0,
237 file_contents,
238 callback_type()));
239
240 // Bad instance.
241 void* address = NULL;
242 callback.WaitForResult(
243 file_mapping_if_->Map(
244 PP_Instance(0xbadbad),
245 file_io.pp_resource(),
246 page_size,
247 PP_FILEMAPPROTECTION_READ,
248 PP_FILEMAPFLAG_PRIVATE,
249 0,
250 &address,
251 callback.GetCallback().pp_completion_callback()));
252 CHECK_CALLBACK_BEHAVIOR(callback);
253 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
254 ASSERT_EQ(NULL, address);
255
256 // Bad resource.
257 callback.WaitForResult(
258 file_mapping_if_->Map(
259 instance_->pp_instance(),
260 PP_Resource(0xbadbad),
261 page_size,
262 PP_FILEMAPPROTECTION_READ,
263 PP_FILEMAPFLAG_PRIVATE,
264 0,
265 &address,
266 callback.GetCallback().pp_completion_callback()));
267 CHECK_CALLBACK_BEHAVIOR(callback);
268 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
269 ASSERT_EQ(NULL, address);
270
271 // Length too big.
272 callback.WaitForResult(
273 file_mapping_if_->Map(
274 instance_->pp_instance(),
275 file_io.pp_resource(),
276 std::numeric_limits<int64_t>::max(),
277 PP_FILEMAPPROTECTION_READ,
278 PP_FILEMAPFLAG_PRIVATE,
279 0,
280 &address,
281 callback.GetCallback().pp_completion_callback()));
282 CHECK_CALLBACK_BEHAVIOR(callback);
283 ASSERT_EQ(PP_ERROR_NOMEMORY, callback.result());
284 ASSERT_EQ(NULL, address);
285
286 // Length too small.
287 callback.WaitForResult(
288 file_mapping_if_->Map(
289 instance_->pp_instance(),
290 file_io.pp_resource(),
291 -1,
292 PP_FILEMAPPROTECTION_READ,
293 PP_FILEMAPFLAG_PRIVATE,
294 0,
295 &address,
296 callback.GetCallback().pp_completion_callback()));
297 CHECK_CALLBACK_BEHAVIOR(callback);
298 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
299 ASSERT_EQ(NULL, address);
300 // TODO(dmichael): Check & test length that is not a multiple of page size???
301
302 // Bad protection.
303 callback.WaitForResult(
304 file_mapping_if_->Map(
305 instance_->pp_instance(),
306 file_io.pp_resource(),
307 page_size,
308 ~PP_FILEMAPPROTECTION_READ,
309 PP_FILEMAPFLAG_PRIVATE,
310 0,
311 &address,
312 callback.GetCallback().pp_completion_callback()));
313 CHECK_CALLBACK_BEHAVIOR(callback);
314 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
315 ASSERT_EQ(NULL, address);
316
317 // No flags.
318 callback.WaitForResult(
319 file_mapping_if_->Map(
320 instance_->pp_instance(),
321 file_io.pp_resource(),
322 page_size,
323 PP_FILEMAPPROTECTION_READ,
324 0,
325 0,
326 &address,
327 callback.GetCallback().pp_completion_callback()));
328 CHECK_CALLBACK_BEHAVIOR(callback);
329 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
330 ASSERT_EQ(NULL, address);
331
332 // Both flags.
333 callback.WaitForResult(
334 file_mapping_if_->Map(
335 instance_->pp_instance(),
336 file_io.pp_resource(),
337 page_size,
338 PP_FILEMAPPROTECTION_READ,
339 PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_PRIVATE,
340 0,
341 &address,
342 callback.GetCallback().pp_completion_callback()));
343 CHECK_CALLBACK_BEHAVIOR(callback);
344 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
345 ASSERT_EQ(NULL, address);
346
347 // Bad flags.
348 callback.WaitForResult(
349 file_mapping_if_->Map(
350 instance_->pp_instance(),
351 file_io.pp_resource(),
352 page_size,
353 PP_FILEMAPPROTECTION_READ,
354 ~PP_FILEMAPFLAG_SHARED,
355 0,
356 &address,
357 callback.GetCallback().pp_completion_callback()));
358 CHECK_CALLBACK_BEHAVIOR(callback);
359 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
360 ASSERT_EQ(NULL, address);
361
362 // Bad offset; not a multiple of page size.
363 callback.WaitForResult(
364 file_mapping_if_->Map(
365 instance_->pp_instance(),
366 file_io.pp_resource(),
367 page_size,
368 PP_FILEMAPPROTECTION_READ,
369 ~PP_FILEMAPFLAG_SHARED,
370 1,
371 &address,
372 callback.GetCallback().pp_completion_callback()));
373 CHECK_CALLBACK_BEHAVIOR(callback);
374 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
375 ASSERT_EQ(NULL, address);
376
377 // Unmap NULL.
378 callback.WaitForResult(
379 file_mapping_if_->Unmap(
380 instance_->pp_instance(),
381 NULL,
382 page_size,
383 callback.GetCallback().pp_completion_callback()));
384 CHECK_CALLBACK_BEHAVIOR(callback);
385 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
386
387 // Unmap bad address.
388 callback.WaitForResult(
389 file_mapping_if_->Unmap(
390 instance_->pp_instance(),
391 reinterpret_cast<const void*>(0xdeadbeef),
392 page_size,
393 callback.GetCallback().pp_completion_callback()));
394 CHECK_CALLBACK_BEHAVIOR(callback);
395 ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
396
397 PASS();
398 }
399
400 std::string TestFileMapping::TestMap() {
401 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_READ,
402 PP_FILEMAPFLAG_SHARED));
403 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE,
404 PP_FILEMAPFLAG_SHARED));
405 ASSERT_SUBTEST_SUCCESS(
406 MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
407 PP_FILEMAPFLAG_SHARED));
408 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_READ,
409 PP_FILEMAPFLAG_PRIVATE));
410 ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE,
411 PP_FILEMAPFLAG_PRIVATE));
412 ASSERT_SUBTEST_SUCCESS(
413 MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
414 PP_FILEMAPFLAG_PRIVATE));
415 // FIXME(dmichael) How to test FIXED??
bbudge 2014/01/27 18:56:44 // TODO?
dmichael (off chromium) 2014/01/27 19:20:26 The PartialRegions test actually does a FIXED mapp
416 PASS();
417 }
418
419 std::string TestFileMapping::TestPartialRegions() {
420 TestCompletionCallback callback(instance_->pp_instance(), callback_type());
421
422 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
423 pp::FileRef file_ref1(file_system, "/mapped_file1");
424 pp::FileRef file_ref2(file_system, "/mapped_file2");
425
426 callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
427 ASSERT_EQ(PP_OK, callback.result());
428
429 const int64_t page_size =
430 file_mapping_if_->GetMapPageSize(instance_->pp_instance());
431 const int64_t kNumPages = 3;
432 std::string file_contents1(kNumPages * page_size, 'a');
433
434 pp::FileIO file_io1(instance_);
435 callback.WaitForResult(file_io1.Open(file_ref1,
436 PP_FILEOPENFLAG_CREATE |
437 PP_FILEOPENFLAG_TRUNCATE |
438 PP_FILEOPENFLAG_READ |
439 PP_FILEOPENFLAG_WRITE,
440 callback.GetCallback()));
441 ASSERT_EQ(PP_OK, callback.result());
442 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
443 &file_io1,
444 0,
445 file_contents1,
446 callback_type()));
447
448 // TODO(dmichael): Use C++ interface.
449 void* address = NULL;
450 callback.WaitForResult(
451 file_mapping_if_->Map(
452 instance_->pp_instance(),
453 file_io1.pp_resource(),
454 kNumPages * page_size,
455 PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
456 PP_FILEMAPFLAG_SHARED,
457 0,
458 &address,
459 callback.GetCallback().pp_completion_callback()));
460 CHECK_CALLBACK_BEHAVIOR(callback);
461 ASSERT_EQ(PP_OK, callback.result());
462 ASSERT_NE(NULL, address);
463
464 // Unmap only the middle page.
465 void* address_of_middle_page =
466 reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(address) + page_size);
467 callback.WaitForResult(
468 file_mapping_if_->Unmap(
469 instance_->pp_instance(),
470 address_of_middle_page,
471 page_size,
472 callback.GetCallback().pp_completion_callback()));
473 CHECK_CALLBACK_BEHAVIOR(callback);
474 ASSERT_EQ(PP_OK, callback.result());
475
476 // Write another file, map it in to the middle hole that was left above.
477 pp::FileIO file_io2(instance_);
478 callback.WaitForResult(file_io2.Open(file_ref2,
479 PP_FILEOPENFLAG_CREATE |
480 PP_FILEOPENFLAG_TRUNCATE |
481 PP_FILEOPENFLAG_READ |
482 PP_FILEOPENFLAG_WRITE,
483 callback.GetCallback()));
484 ASSERT_EQ(PP_OK, callback.result());
485 // This second file will have 1 page worth of data.
486 std::string file_contents2(page_size, 'b');
487 ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
488 &file_io2,
489 0,
490 file_contents2,
491 callback_type()));
492 callback.WaitForResult(
493 file_mapping_if_->Map(
494 instance_->pp_instance(),
495 file_io2.pp_resource(),
496 page_size,
497 PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
498 PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_FIXED,
499 0,
500 &address_of_middle_page,
501 callback.GetCallback().pp_completion_callback()));
502 CHECK_CALLBACK_BEHAVIOR(callback);
503 ASSERT_EQ(PP_OK, callback.result());
504 PASS();
505
506 // Write something else to the mapped region, then unmap, and see if it
507 // gets written to both files. (Note we have to Unmap to make sure that the
508 // write is committed).
509 memset(address, 'c', kNumPages * page_size);
510 callback.WaitForResult(
511 file_mapping_if_->Unmap(
512 instance_->pp_instance(), address, kNumPages * page_size,
513 callback.GetCallback().pp_completion_callback()));
514 CHECK_CALLBACK_BEHAVIOR(callback);
515 ASSERT_EQ(PP_OK, callback.result());
516 // The first and third page should have been written with 'c', but the
517 // second page should be untouched.
518 std::string expected_file_contents1 = std::string(page_size, 'c') +
519 std::string(page_size, 'a') +
520 std::string(page_size, 'c');
521 std::string new_file_contents1;
522 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(),
523 &file_io1,
524 0,
525 &new_file_contents1,
526 callback_type()));
527 ASSERT_EQ(expected_file_contents1, new_file_contents1);
528
529 // The second file should have been entirely over-written.
530 std::string expected_file_contents2 = std::string(page_size, 'c');
531 std::string new_file_contents2;
532 ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(),
533 &file_io2,
534 0,
535 &new_file_contents2,
536 callback_type()));
537 ASSERT_EQ(expected_file_contents2, new_file_contents2);
538
539 // TODO(dmichael): Test non-zero offset
540 }
541
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698