ppapi/tests/test_file_mapping.cc

   1 // Copyright 2014 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 = static_cast<int32_t>(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     // TODO(dmichael): Make sure our Pepper documentation reflects this.
 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   RUN_CALLBACK_TEST(TestFileMapping, BadParameters, filter);
 204   RUN_CALLBACK_TEST(TestFileMapping, Map, filter);
 205   RUN_CALLBACK_TEST(TestFileMapping, PartialRegions, filter);
 206 }
 207
 208 std::string TestFileMapping::TestBadParameters() {
 209   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 210
 211   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 212   pp::FileRef file_ref(file_system, "/mapped_file");
 213
 214   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 215   ASSERT_EQ(PP_OK, callback.result());
 216
 217   const int64_t page_size =
 218       file_mapping_if_->GetMapPageSize(instance_->pp_instance());
 219   // const int64_t kNumPages = 4;
 220   // Make a string that's big enough that it spans 3 pages, plus a little extra.
 221   //std::string file_contents((page_size * (kNumPages - 1)) + 128, 'a');
 222   std::string file_contents(page_size, 'a');
 223
 224   pp::FileIO file_io(instance_);
 225   callback.WaitForResult(file_io.Open(file_ref,
 226                                       PP_FILEOPENFLAG_CREATE |
 227                                       PP_FILEOPENFLAG_TRUNCATE |
 228                                       PP_FILEOPENFLAG_READ |
 229                                       PP_FILEOPENFLAG_WRITE,
 230                                       callback.GetCallback()));
 231   ASSERT_EQ(PP_OK, callback.result());
 232   ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
 233                                      &file_io,
 234                                      0,
 235                                      file_contents,
 236                                      callback_type()));
 237
 238   // Bad instance.
 239   void* address = NULL;
 240   callback.WaitForResult(
 241       file_mapping_if_->Map(
 242           PP_Instance(0xbadbad),
 243           file_io.pp_resource(),
 244           page_size,
 245           PP_FILEMAPPROTECTION_READ,
 246           PP_FILEMAPFLAG_PRIVATE,
 247           0,
 248           &address,
 249           callback.GetCallback().pp_completion_callback()));
 250   CHECK_CALLBACK_BEHAVIOR(callback);
 251   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 252   ASSERT_EQ(NULL, address);
 253
 254   // Bad resource.
 255   callback.WaitForResult(
 256       file_mapping_if_->Map(
 257           instance_->pp_instance(),
 258           PP_Resource(0xbadbad),
 259           page_size,
 260           PP_FILEMAPPROTECTION_READ,
 261           PP_FILEMAPFLAG_PRIVATE,
 262           0,
 263           &address,
 264           callback.GetCallback().pp_completion_callback()));
 265   CHECK_CALLBACK_BEHAVIOR(callback);
 266   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 267   ASSERT_EQ(NULL, address);
 268
 269   // Length too big.
 270   callback.WaitForResult(
 271       file_mapping_if_->Map(
 272           instance_->pp_instance(),
 273           file_io.pp_resource(),
 274           std::numeric_limits<int64_t>::max(),
 275           PP_FILEMAPPROTECTION_READ,
 276           PP_FILEMAPFLAG_PRIVATE,
 277           0,
 278           &address,
 279           callback.GetCallback().pp_completion_callback()));
 280   CHECK_CALLBACK_BEHAVIOR(callback);
 281   ASSERT_EQ(PP_ERROR_NOMEMORY, callback.result());
 282   ASSERT_EQ(NULL, address);
 283
 284   // Length too small.
 285   callback.WaitForResult(
 286       file_mapping_if_->Map(
 287           instance_->pp_instance(),
 288           file_io.pp_resource(),
 289           -1,
 290           PP_FILEMAPPROTECTION_READ,
 291           PP_FILEMAPFLAG_PRIVATE,
 292           0,
 293           &address,
 294           callback.GetCallback().pp_completion_callback()));
 295   CHECK_CALLBACK_BEHAVIOR(callback);
 296   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 297   ASSERT_EQ(NULL, address);
 298   // TODO(dmichael): Check & test length that is not a multiple of page size???
 299
 300   // Bad protection.
 301   callback.WaitForResult(
 302       file_mapping_if_->Map(
 303           instance_->pp_instance(),
 304           file_io.pp_resource(),
 305           page_size,
 306           ~static_cast<uint32_t>(PP_FILEMAPPROTECTION_READ),
 307           PP_FILEMAPFLAG_PRIVATE,
 308           0,
 309           &address,
 310           callback.GetCallback().pp_completion_callback()));
 311   CHECK_CALLBACK_BEHAVIOR(callback);
 312   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 313   ASSERT_EQ(NULL, address);
 314
 315   // No flags.
 316   callback.WaitForResult(
 317       file_mapping_if_->Map(
 318           instance_->pp_instance(),
 319           file_io.pp_resource(),
 320           page_size,
 321           PP_FILEMAPPROTECTION_READ,
 322           0,
 323           0,
 324           &address,
 325           callback.GetCallback().pp_completion_callback()));
 326   CHECK_CALLBACK_BEHAVIOR(callback);
 327   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 328   ASSERT_EQ(NULL, address);
 329
 330   // Both flags.
 331   callback.WaitForResult(
 332       file_mapping_if_->Map(
 333           instance_->pp_instance(),
 334           file_io.pp_resource(),
 335           page_size,
 336           PP_FILEMAPPROTECTION_READ,
 337           PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_PRIVATE,
 338           0,
 339           &address,
 340           callback.GetCallback().pp_completion_callback()));
 341   CHECK_CALLBACK_BEHAVIOR(callback);
 342   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 343   ASSERT_EQ(NULL, address);
 344
 345   // Bad flags.
 346   callback.WaitForResult(
 347       file_mapping_if_->Map(
 348           instance_->pp_instance(),
 349           file_io.pp_resource(),
 350           page_size,
 351           PP_FILEMAPPROTECTION_READ,
 352           ~static_cast<uint32_t>(PP_FILEMAPFLAG_SHARED),
 353           0,
 354           &address,
 355           callback.GetCallback().pp_completion_callback()));
 356   CHECK_CALLBACK_BEHAVIOR(callback);
 357   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 358   ASSERT_EQ(NULL, address);
 359
 360   // Bad offset; not a multiple of page size.
 361   callback.WaitForResult(
 362       file_mapping_if_->Map(
 363           instance_->pp_instance(),
 364           file_io.pp_resource(),
 365           page_size,
 366           PP_FILEMAPPROTECTION_READ,
 367           ~static_cast<uint32_t>(PP_FILEMAPFLAG_SHARED),
 368           1,
 369           &address,
 370           callback.GetCallback().pp_completion_callback()));
 371   CHECK_CALLBACK_BEHAVIOR(callback);
 372   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 373   ASSERT_EQ(NULL, address);
 374
 375   // Unmap NULL.
 376   callback.WaitForResult(
 377       file_mapping_if_->Unmap(
 378           instance_->pp_instance(),
 379           NULL,
 380           page_size,
 381           callback.GetCallback().pp_completion_callback()));
 382   CHECK_CALLBACK_BEHAVIOR(callback);
 383   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 384
 385   // Unmap bad address.
 386   callback.WaitForResult(
 387       file_mapping_if_->Unmap(
 388           instance_->pp_instance(),
 389           reinterpret_cast<const void*>(0xdeadbeef),
 390           page_size,
 391           callback.GetCallback().pp_completion_callback()));
 392   CHECK_CALLBACK_BEHAVIOR(callback);
 393   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 394
 395   PASS();
 396 }
 397
 398 std::string TestFileMapping::TestMap() {
 399   ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_READ,
 400                                             PP_FILEMAPFLAG_SHARED));
 401   ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE,
 402                                             PP_FILEMAPFLAG_SHARED));
 403   ASSERT_SUBTEST_SUCCESS(
 404       MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
 405                          PP_FILEMAPFLAG_SHARED));
 406   ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_READ,
 407                                             PP_FILEMAPFLAG_PRIVATE));
 408   ASSERT_SUBTEST_SUCCESS(MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE,
 409                                             PP_FILEMAPFLAG_PRIVATE));
 410   ASSERT_SUBTEST_SUCCESS(
 411       MapAndCheckResults(PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
 412                          PP_FILEMAPFLAG_PRIVATE));
 413   PASS();
 414 }
 415
 416 std::string TestFileMapping::TestPartialRegions() {
 417   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 418
 419   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 420   pp::FileRef file_ref1(file_system, "/mapped_file1");
 421   pp::FileRef file_ref2(file_system, "/mapped_file2");
 422
 423   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 424   ASSERT_EQ(PP_OK, callback.result());
 425
 426   const int64_t page_size =
 427       file_mapping_if_->GetMapPageSize(instance_->pp_instance());
 428   const int64_t kNumPages = 3;
 429   std::string file_contents1(kNumPages * page_size, 'a');
 430
 431   pp::FileIO file_io1(instance_);
 432   callback.WaitForResult(file_io1.Open(file_ref1,
 433                                        PP_FILEOPENFLAG_CREATE |
 434                                        PP_FILEOPENFLAG_TRUNCATE |
 435                                        PP_FILEOPENFLAG_READ |
 436                                        PP_FILEOPENFLAG_WRITE,
 437                                        callback.GetCallback()));
 438   ASSERT_EQ(PP_OK, callback.result());
 439   ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
 440                                      &file_io1,
 441                                      0,
 442                                      file_contents1,
 443                                      callback_type()));
 444
 445   // TODO(dmichael): Use C++ interface.
 446   void* address = NULL;
 447   callback.WaitForResult(
 448       file_mapping_if_->Map(
 449           instance_->pp_instance(),
 450           file_io1.pp_resource(),
 451           kNumPages * page_size,
 452           PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
 453           PP_FILEMAPFLAG_SHARED,
 454           0,
 455           &address,
 456           callback.GetCallback().pp_completion_callback()));
 457   CHECK_CALLBACK_BEHAVIOR(callback);
 458   ASSERT_EQ(PP_OK, callback.result());
 459   ASSERT_NE(NULL, address);
 460
 461   // Unmap only the middle page.
 462   void* address_of_middle_page =
 463       reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(address) + page_size);
 464   callback.WaitForResult(
 465       file_mapping_if_->Unmap(
 466           instance_->pp_instance(),
 467           address_of_middle_page,
 468           page_size,
 469           callback.GetCallback().pp_completion_callback()));
 470   CHECK_CALLBACK_BEHAVIOR(callback);
 471   ASSERT_EQ(PP_OK, callback.result());
 472
 473   // Write another file, map it in to the middle hole that was left above.
 474   pp::FileIO file_io2(instance_);
 475   callback.WaitForResult(file_io2.Open(file_ref2,
 476                                        PP_FILEOPENFLAG_CREATE |
 477                                        PP_FILEOPENFLAG_TRUNCATE |
 478                                        PP_FILEOPENFLAG_READ |
 479                                        PP_FILEOPENFLAG_WRITE,
 480                                        callback.GetCallback()));
 481   ASSERT_EQ(PP_OK, callback.result());
 482   // This second file will have 1 page worth of data.
 483   std::string file_contents2(page_size, 'b');
 484   ASSERT_EQ(PP_OK, WriteEntireBuffer(instance_->pp_instance(),
 485                                      &file_io2,
 486                                      0,
 487                                      file_contents2,
 488                                      callback_type()));
 489   callback.WaitForResult(
 490       file_mapping_if_->Map(
 491           instance_->pp_instance(),
 492           file_io2.pp_resource(),
 493           page_size,
 494           PP_FILEMAPPROTECTION_WRITE | PP_FILEMAPPROTECTION_READ,
 495           PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_FIXED,
 496           0,
 497           &address_of_middle_page,
 498           callback.GetCallback().pp_completion_callback()));
 499   CHECK_CALLBACK_BEHAVIOR(callback);
 500   ASSERT_EQ(PP_OK, callback.result());
 501
 502   // Write something else to the mapped region, then unmap, and see if it
 503   // gets written to both files. (Note we have to Unmap to make sure that the
 504   // write is committed).
 505   memset(address, 'c', kNumPages * page_size);
 506   callback.WaitForResult(
 507       file_mapping_if_->Unmap(
 508           instance_->pp_instance(), address, kNumPages * page_size,
 509           callback.GetCallback().pp_completion_callback()));
 510   CHECK_CALLBACK_BEHAVIOR(callback);
 511   ASSERT_EQ(PP_OK, callback.result());
 512   // The first and third page should have been written with 'c', but the
 513   // second page should be untouched.
 514   std::string expected_file_contents1 = std::string(page_size, 'c') +
 515                                         std::string(page_size, 'a') +
 516                                         std::string(page_size, 'c');
 517   std::string new_file_contents1;
 518   ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(),
 519                                   &file_io1,
 520                                   0,
 521                                   &new_file_contents1,
 522                                   callback_type()));
 523   ASSERT_EQ(expected_file_contents1, new_file_contents1);
 524
 525   // The second file should have been entirely over-written.
 526   std::string expected_file_contents2 = std::string(page_size, 'c');
 527   std::string new_file_contents2;
 528   ASSERT_EQ(PP_OK, ReadEntireFile(instance_->pp_instance(),
 529                                   &file_io2,
 530                                   0,
 531                                   &new_file_contents2,
 532                                   callback_type()));
 533   ASSERT_EQ(expected_file_contents2, new_file_contents2);
 534
 535   // TODO(dmichael): Test non-zero offset
 536
 537   PASS();
 538 }
 539