ppapi/tests/test_file_io.cc

   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_io.h"
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <sys/stat.h>
  12 #include <sys/types.h>
  13
  14 #include <vector>
  15
  16 #include "ppapi/c/dev/ppb_testing_dev.h"
  17 #include "ppapi/c/pp_errors.h"
  18 #include "ppapi/c/ppb_file_io.h"
  19 #include "ppapi/c/private/pp_file_handle.h"
  20 #include "ppapi/c/trusted/ppb_file_io_trusted.h"
  21 #include "ppapi/cpp/file_io.h"
  22 #include "ppapi/cpp/file_ref.h"
  23 #include "ppapi/cpp/file_system.h"
  24 #include "ppapi/cpp/instance.h"
  25 #include "ppapi/cpp/module.h"
  26 #include "ppapi/cpp/private/file_io_private.h"
  27 #include "ppapi/cpp/private/pass_file_handle.h"
  28 #include "ppapi/tests/test_utils.h"
  29 #include "ppapi/tests/testing_instance.h"
  30
  31 #if defined(PPAPI_OS_WIN)
  32 # include <io.h>
  33 # include <windows.h>
  34 // TODO(hamaji): Use standard windows APIs instead of compatibility layer?
  35 # define lseek _lseek
  36 # define read _read
  37 # define write _write
  38 # define ssize_t int
  39 #else
  40 # include <sys/mman.h>
  41 # include <unistd.h>
  42 #endif
  43
  44 REGISTER_TEST_CASE(FileIO);
  45
  46 namespace {
  47
  48 std::string ReportMismatch(const std::string& method_name,
  49                            const std::string& returned_result,
  50                            const std::string& expected_result) {
  51   return method_name + " returned '" + returned_result + "'; '" +
  52       expected_result + "' expected.";
  53 }
  54
  55 std::string ReportOpenError(int32_t open_flags) {
  56   static const char* kFlagNames[] = {
  57     "PP_FILEOPENFLAG_READ",
  58     "PP_FILEOPENFLAG_WRITE",
  59     "PP_FILEOPENFLAG_CREATE",
  60     "PP_FILEOPENFLAG_TRUNCATE",
  61     "PP_FILEOPENFLAG_EXCLUSIVE"
  62   };
  63
  64   std::string result = "FileIO:Open had unexpected behavior with flags: ";
  65   bool first_flag = true;
  66   for (int32_t mask = 1, index = 0; mask <= PP_FILEOPENFLAG_EXCLUSIVE;
  67        mask <<= 1, ++index) {
  68     if (mask & open_flags) {
  69       if (first_flag) {
  70         first_flag = false;
  71       } else {
  72         result += " | ";
  73       }
  74       result += kFlagNames[index];
  75     }
  76   }
  77   if (first_flag)
  78     result += "[None]";
  79
  80   return result;
  81 }
  82
  83 int32_t ReadEntireFile(PP_Instance instance,
  84                        pp::FileIO* file_io,
  85                        int32_t offset,
  86                        std::string* data,
  87                        CallbackType callback_type) {
  88   TestCompletionCallback callback(instance, callback_type);
  89   char buf[256];
  90   int32_t read_offset = offset;
  91
  92   for (;;) {
  93     callback.WaitForResult(
  94         file_io->Read(read_offset, buf, sizeof(buf), callback.GetCallback()));
  95     if (callback.result() < 0)
  96       return callback.result();
  97     if (callback.result() == 0)
  98       break;
  99     read_offset += callback.result();
 100     data->append(buf, callback.result());
 101   }
 102
 103   return PP_OK;
 104 }
 105
 106 int32_t ReadToArrayEntireFile(PP_Instance instance,
 107                               pp::FileIO* file_io,
 108                               int32_t offset,
 109                               std::string* data,
 110                               CallbackType callback_type) {
 111   TestCompletionCallbackWithOutput< std::vector<char> > callback(
 112       instance, callback_type);
 113
 114   for (;;) {
 115     callback.WaitForResult(file_io->Read(offset, 256, callback.GetCallback()));
 116     int32_t rv = callback.result();
 117     if (rv < 0)
 118       return rv;
 119     if (rv == 0)
 120       break;
 121     const std::vector<char>& output = callback.output();
 122     assert(rv == static_cast<int32_t>(output.size()));
 123     offset += rv;
 124     data->append(output.begin(), output.end());
 125   }
 126
 127   return PP_OK;
 128 }
 129
 130 bool ReadEntireFileFromFileHandle(int fd, std::string* data) {
 131   if (lseek(fd, 0, SEEK_SET) < 0)
 132     return false;
 133   data->clear();
 134
 135   int ret;
 136   do {
 137     char buf[8192];
 138     ret = read(fd, buf, sizeof(buf));
 139     if (ret > 0)
 140       data->append(buf, ret);
 141   } while (ret > 0);
 142   return ret == 0;
 143 }
 144
 145 int32_t WriteEntireBuffer(PP_Instance instance,
 146                           pp::FileIO* file_io,
 147                           int32_t offset,
 148                           const std::string& data,
 149                           CallbackType callback_type) {
 150   TestCompletionCallback callback(instance, callback_type);
 151   int32_t write_offset = offset;
 152   const char* buf = data.c_str();
 153   int32_t size = data.size();
 154
 155   while (write_offset < offset + size) {
 156     callback.WaitForResult(file_io->Write(write_offset,
 157                                           &buf[write_offset - offset],
 158                                           size - write_offset + offset,
 159                                           callback.GetCallback()));
 160     if (callback.result() < 0)
 161       return callback.result();
 162     if (callback.result() == 0)
 163       return PP_ERROR_FAILED;
 164     write_offset += callback.result();
 165   }
 166
 167   return PP_OK;
 168 }
 169
 170 }  // namespace
 171
 172 bool TestFileIO::Init() {
 173   return CheckTestingInterface() && EnsureRunningOverHTTP();
 174 }
 175
 176 void TestFileIO::RunTests(const std::string& filter) {
 177   RUN_CALLBACK_TEST(TestFileIO, Open, filter);
 178   RUN_CALLBACK_TEST(TestFileIO, OpenDirectory, filter);
 179   RUN_CALLBACK_TEST(TestFileIO, ReadWriteSetLength, filter);
 180   RUN_CALLBACK_TEST(TestFileIO, ReadToArrayWriteSetLength, filter);
 181   RUN_CALLBACK_TEST(TestFileIO, TouchQuery, filter);
 182   RUN_CALLBACK_TEST(TestFileIO, AbortCalls, filter);
 183   RUN_CALLBACK_TEST(TestFileIO, ParallelReads, filter);
 184   RUN_CALLBACK_TEST(TestFileIO, ParallelWrites, filter);
 185   RUN_CALLBACK_TEST(TestFileIO, NotAllowMixedReadWrite, filter);
 186   RUN_CALLBACK_TEST(TestFileIO, WillWriteWillSetLength, filter);
 187   RUN_CALLBACK_TEST(TestFileIO, RequestOSFileHandle, filter);
 188   RUN_CALLBACK_TEST(TestFileIO, RequestOSFileHandleWithOpenExclusive, filter);
 189   RUN_CALLBACK_TEST(TestFileIO, Mmap, filter);
 190
 191   // TODO(viettrungluu): add tests:
 192   //  - that PP_ERROR_PENDING is correctly returned
 193   //  - that operations respect the file open modes (flags)
 194 }
 195
 196 std::string TestFileIO::TestOpen() {
 197   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 198
 199   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 200   pp::FileRef file_ref(file_system, "/file_open");
 201
 202   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 203   CHECK_CALLBACK_BEHAVIOR(callback);
 204   ASSERT_EQ(PP_OK, callback.result());
 205
 206   std::string result;
 207   result = MatchOpenExpectations(
 208       &file_system,
 209       PP_FILEOPENFLAG_READ,
 210       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 211   if (!result.empty())
 212     return result;
 213
 214   // Test the behavior of the power set of
 215   //   { PP_FILEOPENFLAG_CREATE,
 216   //     PP_FILEOPENFLAG_TRUNCATE,
 217   //     PP_FILEOPENFLAG_EXCLUSIVE }.
 218
 219   // First of all, none of them are specified.
 220   result = MatchOpenExpectations(
 221       &file_system,
 222       PP_FILEOPENFLAG_WRITE,
 223       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 224   if (!result.empty())
 225     return result;
 226
 227   result = MatchOpenExpectations(
 228       &file_system,
 229       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE,
 230       CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 231   if (!result.empty())
 232     return result;
 233
 234   result = MatchOpenExpectations(
 235       &file_system,
 236       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE,
 237       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 238   if (!result.empty())
 239     return result;
 240
 241   result = MatchOpenExpectations(
 242       &file_system,
 243       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_TRUNCATE,
 244       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | TRUNCATE_IF_EXISTS);
 245   if (!result.empty())
 246     return result;
 247
 248   result = MatchOpenExpectations(
 249       &file_system,
 250       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
 251       PP_FILEOPENFLAG_EXCLUSIVE,
 252       CREATE_IF_DOESNT_EXIST | DONT_OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 253   if (!result.empty())
 254     return result;
 255
 256   result = MatchOpenExpectations(
 257       &file_system,
 258       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_TRUNCATE,
 259       CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | TRUNCATE_IF_EXISTS);
 260   if (!result.empty())
 261     return result;
 262
 263   result = MatchOpenExpectations(
 264       &file_system,
 265       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE |
 266       PP_FILEOPENFLAG_TRUNCATE,
 267       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | TRUNCATE_IF_EXISTS);
 268   if (!result.empty())
 269     return result;
 270
 271   result = MatchOpenExpectations(
 272       &file_system,
 273       PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
 274       PP_FILEOPENFLAG_EXCLUSIVE | PP_FILEOPENFLAG_TRUNCATE,
 275       CREATE_IF_DOESNT_EXIST | DONT_OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
 276   if (!result.empty())
 277     return result;
 278
 279   // Invalid combination: PP_FILEOPENFLAG_TRUNCATE without
 280   // PP_FILEOPENFLAG_WRITE.
 281   result = MatchOpenExpectations(
 282       &file_system,
 283       PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_TRUNCATE,
 284       INVALID_FLAG_COMBINATION);
 285   if (!result.empty())
 286     return result;
 287
 288   PASS();
 289 }
 290
 291 std::string TestFileIO::TestOpenDirectory() {
 292   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 293
 294   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 295   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 296   CHECK_CALLBACK_BEHAVIOR(callback);
 297   ASSERT_EQ(PP_OK, callback.result());
 298
 299   // Make a directory.
 300   pp::FileRef dir_ref(file_system, "/test_dir_open_directory");
 301   callback.WaitForResult(dir_ref.MakeDirectory(callback.GetCallback()));
 302   CHECK_CALLBACK_BEHAVIOR(callback);
 303   ASSERT_EQ(PP_OK, callback.result());
 304
 305   // Open the directory. This is expected to fail since directories cannot be
 306   // opened.
 307   pp::FileIO file_io(instance_);
 308   callback.WaitForResult(file_io.Open(dir_ref, PP_FILEOPENFLAG_READ,
 309                                       callback.GetCallback()));
 310   CHECK_CALLBACK_BEHAVIOR(callback);
 311   ASSERT_EQ(PP_ERROR_NOTAFILE, callback.result());
 312
 313   PASS();
 314 }
 315
 316 std::string TestFileIO::TestReadWriteSetLength() {
 317   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 318
 319   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 320   pp::FileRef file_ref(file_system, "/file_read_write_setlength");
 321   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 322   CHECK_CALLBACK_BEHAVIOR(callback);
 323   ASSERT_EQ(PP_OK, callback.result());
 324
 325   pp::FileIO file_io(instance_);
 326   callback.WaitForResult(file_io.Open(file_ref,
 327                                       PP_FILEOPENFLAG_CREATE |
 328                                       PP_FILEOPENFLAG_TRUNCATE |
 329                                       PP_FILEOPENFLAG_READ |
 330                                       PP_FILEOPENFLAG_WRITE,
 331                                       callback.GetCallback()));
 332   CHECK_CALLBACK_BEHAVIOR(callback);
 333   ASSERT_EQ(PP_OK, callback.result());
 334
 335   // Write something to the file.
 336   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 337                                  "test_test", callback_type());
 338   ASSERT_EQ(PP_OK, rv);
 339
 340   // Attempt to read a negative number of bytes; it should fail.
 341   char buf[256];
 342   callback.WaitForResult(file_io.Read(0,
 343                                       buf,
 344                                       -1,
 345                                       callback.GetCallback()));
 346   CHECK_CALLBACK_BEHAVIOR(callback);
 347   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
 348
 349   // Read the entire file.
 350   std::string read_buffer;
 351   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 352                       callback_type());
 353   ASSERT_EQ(PP_OK, rv);
 354   ASSERT_EQ(std::string("test_test"), read_buffer);
 355
 356   // Truncate the file.
 357   callback.WaitForResult(file_io.SetLength(4, callback.GetCallback()));
 358   CHECK_CALLBACK_BEHAVIOR(callback);
 359   ASSERT_EQ(PP_OK, callback.result());
 360
 361   // Check the file contents.
 362   read_buffer.clear();
 363   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 364                       callback_type());
 365   ASSERT_EQ(PP_OK, rv);
 366   ASSERT_EQ(std::string("test"), read_buffer);
 367
 368   // Try to read past the end of the file.
 369   read_buffer.clear();
 370   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 100, &read_buffer,
 371                       callback_type());
 372   ASSERT_EQ(PP_OK, rv);
 373   ASSERT_TRUE(read_buffer.empty());
 374
 375   // Write past the end of the file. The file should be zero-padded.
 376   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test",
 377                          callback_type());
 378   ASSERT_EQ(PP_OK, rv);
 379
 380   // Check the contents of the file.
 381   read_buffer.clear();
 382   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 383                       callback_type());
 384   ASSERT_EQ(PP_OK, rv);
 385   ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer);
 386
 387   // Extend the file.
 388   callback.WaitForResult(file_io.SetLength(16, callback.GetCallback()));
 389   CHECK_CALLBACK_BEHAVIOR(callback);
 390   ASSERT_EQ(PP_OK, callback.result());
 391
 392   // Check the contents of the file.
 393   read_buffer.clear();
 394   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 395                       callback_type());
 396   ASSERT_EQ(PP_OK, rv);
 397   ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer);
 398
 399   // Write in the middle of the file.
 400   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test",
 401                          callback_type());
 402   ASSERT_EQ(PP_OK, rv);
 403
 404   // Check the contents of the file.
 405   read_buffer.clear();
 406   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
 407                       callback_type());
 408   ASSERT_EQ(PP_OK, rv);
 409   ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer);
 410
 411   // Read from the middle of the file.
 412   read_buffer.clear();
 413   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 4, &read_buffer,
 414                       callback_type());
 415   ASSERT_EQ(PP_OK, rv);
 416   ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer);
 417
 418   // Append to the end of the file.
 419   pp::FileIO file_io2(instance_);
 420   callback.WaitForResult(file_io2.Open(file_ref,
 421                                        PP_FILEOPENFLAG_CREATE |
 422                                        PP_FILEOPENFLAG_READ |
 423                                        PP_FILEOPENFLAG_APPEND,
 424                                        callback.GetCallback()));
 425   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io2, 0, "appended",
 426                          callback_type());
 427   ASSERT_EQ(PP_OK, rv);
 428   read_buffer.clear();
 429   rv = ReadEntireFile(instance_->pp_instance(), &file_io2, 0, &read_buffer,
 430                       callback_type());
 431   ASSERT_EQ(PP_OK, rv);
 432   ASSERT_EQ(std::string("testtesttest\0\0\0\0appended", 24), read_buffer);
 433
 434   PASS();
 435 }
 436
 437 // This is basically a copy of TestReadWriteSetLength, but with the new Read
 438 // API.  With this test case, we can make sure the two Read's have the same
 439 // behavior.
 440 std::string TestFileIO::TestReadToArrayWriteSetLength() {
 441   if (callback_type() == PP_BLOCKING) {
 442     // This test does not make sense for blocking callbacks.
 443     PASS();
 444   }
 445   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 446
 447   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 448   pp::FileRef file_ref(file_system, "/file_read_write_setlength");
 449   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 450   CHECK_CALLBACK_BEHAVIOR(callback);
 451   ASSERT_EQ(PP_OK, callback.result());
 452
 453   pp::FileIO file_io(instance_);
 454   callback.WaitForResult(file_io.Open(file_ref,
 455                                       PP_FILEOPENFLAG_CREATE |
 456                                       PP_FILEOPENFLAG_TRUNCATE |
 457                                       PP_FILEOPENFLAG_READ |
 458                                       PP_FILEOPENFLAG_WRITE,
 459                                       callback.GetCallback()));
 460   CHECK_CALLBACK_BEHAVIOR(callback);
 461   ASSERT_EQ(PP_OK, callback.result());
 462
 463   // Write something to the file.
 464   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 465                                  "test_test", callback_type());
 466   ASSERT_EQ(PP_OK, rv);
 467
 468   TestCompletionCallbackWithOutput< std::vector<char> > callback2(
 469       instance_->pp_instance(), callback_type());
 470   // Attempt to read a negative number of bytes; it should fail.
 471   callback2.WaitForResult(file_io.Read(0, -1, callback2.GetCallback()));
 472   CHECK_CALLBACK_BEHAVIOR(callback2);
 473   ASSERT_EQ(PP_ERROR_FAILED, callback2.result());
 474
 475   // Read the entire file.
 476   std::string read_buffer;
 477   read_buffer.reserve(10);
 478   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 479                              &read_buffer, callback_type());
 480   ASSERT_EQ(PP_OK, rv);
 481   ASSERT_EQ(std::string("test_test"), read_buffer);
 482
 483   // Truncate the file.
 484   callback.WaitForResult(file_io.SetLength(4, callback.GetCallback()));
 485   CHECK_CALLBACK_BEHAVIOR(callback);
 486   ASSERT_EQ(PP_OK, rv);
 487
 488   // Check the file contents.
 489   read_buffer.clear();
 490   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 491                              &read_buffer, callback_type());
 492   ASSERT_EQ(PP_OK, rv);
 493   ASSERT_EQ(std::string("test"), read_buffer);
 494
 495   // Try to read past the end of the file.
 496   read_buffer.clear();
 497   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 100,
 498                              &read_buffer, callback_type());
 499   ASSERT_EQ(PP_OK, rv);
 500   ASSERT_TRUE(read_buffer.empty());
 501
 502   // Write past the end of the file. The file should be zero-padded.
 503   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test",
 504                          callback_type());
 505   ASSERT_EQ(PP_OK, rv);
 506
 507   // Check the contents of the file.
 508   read_buffer.clear();
 509   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 510                              &read_buffer, callback_type());
 511   ASSERT_EQ(PP_OK, rv);
 512   ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer);
 513
 514   // Extend the file.
 515   callback.WaitForResult(file_io.SetLength(16, callback.GetCallback()));
 516   CHECK_CALLBACK_BEHAVIOR(callback);
 517   ASSERT_EQ(PP_OK, callback.result());
 518
 519   // Check the contents of the file.
 520   read_buffer.clear();
 521   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 522                              &read_buffer, callback_type());
 523   ASSERT_EQ(PP_OK, rv);
 524   ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer);
 525
 526   // Write in the middle of the file.
 527   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test",
 528                          callback_type());
 529   ASSERT_EQ(PP_OK, rv);
 530
 531   // Check the contents of the file.
 532   read_buffer.clear();
 533   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
 534                              &read_buffer, callback_type());
 535   ASSERT_EQ(PP_OK, rv);
 536   ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer);
 537
 538   // Read from the middle of the file.
 539   read_buffer.clear();
 540   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 4,
 541                              &read_buffer, callback_type());
 542   ASSERT_EQ(PP_OK, rv);
 543   ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer);
 544
 545   PASS();
 546 }
 547
 548 std::string TestFileIO::TestTouchQuery() {
 549   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 550
 551   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 552   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 553   CHECK_CALLBACK_BEHAVIOR(callback);
 554   ASSERT_EQ(PP_OK, callback.result());
 555
 556   pp::FileRef file_ref(file_system, "/file_touch");
 557   pp::FileIO file_io(instance_);
 558   callback.WaitForResult(file_io.Open(file_ref,
 559                                       PP_FILEOPENFLAG_CREATE |
 560                                       PP_FILEOPENFLAG_TRUNCATE |
 561                                       PP_FILEOPENFLAG_WRITE,
 562                                       callback.GetCallback()));
 563   CHECK_CALLBACK_BEHAVIOR(callback);
 564   ASSERT_EQ(PP_OK, callback.result());
 565
 566   // Write some data to have a non-zero file size.
 567   callback.WaitForResult(file_io.Write(0, "test", 4, callback.GetCallback()));
 568   CHECK_CALLBACK_BEHAVIOR(callback);
 569   ASSERT_EQ(4, callback.result());
 570
 571   const PP_Time last_access_time = 123 * 24 * 3600.0;
 572   // last_modified_time's granularity is 2 seconds
 573   // NOTE: In NaCl on Windows, NaClDescIO uses _fstat64 to retrieve file info.
 574   // This function returns strange values for very small time values (near the
 575   // Unix Epoch). For a value like 246.0, it returns -1. For larger values, it
 576   // returns values that are exactly an hour less. The value below is handled
 577   // correctly, and is only 100 days after the start of Unix time.
 578   const PP_Time last_modified_time = 100 * 24 * 3600.0;
 579   callback.WaitForResult(file_io.Touch(last_access_time, last_modified_time,
 580                                        callback.GetCallback()));
 581   CHECK_CALLBACK_BEHAVIOR(callback);
 582   ASSERT_EQ(PP_OK, callback.result());
 583
 584   PP_FileInfo info;
 585   callback.WaitForResult(file_io.Query(&info, callback.GetCallback()));
 586   CHECK_CALLBACK_BEHAVIOR(callback);
 587   ASSERT_EQ(PP_OK, callback.result());
 588
 589   if ((info.size != 4) ||
 590       (info.type != PP_FILETYPE_REGULAR) ||
 591       (info.system_type != PP_FILESYSTEMTYPE_LOCALTEMPORARY) ||
 592       (info.last_access_time != last_access_time) ||
 593       (info.last_modified_time != last_modified_time))
 594     return "FileIO::Query() has returned bad data.";
 595
 596   // Call |Query()| again, to make sure it works a second time.
 597   callback.WaitForResult(file_io.Query(&info, callback.GetCallback()));
 598   CHECK_CALLBACK_BEHAVIOR(callback);
 599   ASSERT_EQ(PP_OK, callback.result());
 600
 601   PASS();
 602 }
 603
 604 std::string TestFileIO::TestAbortCalls() {
 605   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 606
 607   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 608   pp::FileRef file_ref(file_system, "/file_abort_calls");
 609   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 610   CHECK_CALLBACK_BEHAVIOR(callback);
 611   ASSERT_EQ(PP_OK, callback.result());
 612
 613   int32_t rv = PP_ERROR_FAILED;
 614   // First, create a file on which to do ops.
 615   {
 616     pp::FileIO file_io(instance_);
 617     callback.WaitForResult(
 618         file_io.Open(file_ref,
 619                      PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
 620                      callback.GetCallback()));
 621     CHECK_CALLBACK_BEHAVIOR(callback);
 622     ASSERT_EQ(PP_OK, callback.result());
 623
 624     // N.B.: Should write at least 3 bytes.
 625     rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 626                            "foobarbazquux", callback_type());
 627     ASSERT_EQ(PP_OK, rv);
 628   }
 629
 630   // Abort |Open()|.
 631   {
 632     rv = pp::FileIO(instance_)
 633         .Open(file_ref, PP_FILEOPENFLAG_READ, callback.GetCallback());
 634   }
 635   callback.WaitForAbortResult(rv);
 636   CHECK_CALLBACK_BEHAVIOR(callback);
 637
 638   // Abort |Query()|.
 639   {
 640     PP_FileInfo info = { 0 };
 641     // Save a copy and make sure |info| doesn't get written to if it is aborted.
 642     PP_FileInfo info_copy;
 643     memcpy(&info_copy, &info, sizeof(info));
 644     {
 645       pp::FileIO file_io(instance_);
 646       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
 647                                           callback.GetCallback()));
 648       CHECK_CALLBACK_BEHAVIOR(callback);
 649       ASSERT_EQ(PP_OK, callback.result());
 650
 651       rv = file_io.Query(&info, callback.GetCallback());
 652     }  // Destroy |file_io|.
 653     callback.WaitForResult(rv);
 654     CHECK_CALLBACK_BEHAVIOR(callback);
 655     if (callback_type() == PP_BLOCKING) {
 656       ASSERT_EQ(callback.result(), PP_OK);
 657       // The operation completed synchronously, so |info| should have changed.
 658       ASSERT_NE(0, memcmp(&info_copy, &info, sizeof(info)));
 659     } else {
 660       ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
 661       ASSERT_EQ(0, memcmp(&info_copy, &info, sizeof(info)));
 662     }
 663   }
 664
 665   // Abort |Touch()|.
 666   {
 667     {
 668       pp::FileIO file_io(instance_);
 669       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 670                                           callback.GetCallback()));
 671       CHECK_CALLBACK_BEHAVIOR(callback);
 672       ASSERT_EQ(PP_OK, callback.result());
 673
 674       rv = file_io.Touch(0, 0, callback.GetCallback());
 675     }  // Destroy |file_io|.
 676     callback.WaitForAbortResult(rv);
 677     CHECK_CALLBACK_BEHAVIOR(callback);
 678   }
 679
 680   // Abort |Read()|.
 681   {
 682     char buf[3] = { 0 };
 683     {
 684       pp::FileIO file_io(instance_);
 685       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
 686                                           callback.GetCallback()));
 687       CHECK_CALLBACK_BEHAVIOR(callback);
 688       ASSERT_EQ(PP_OK, callback.result());
 689
 690       rv = file_io.Read(0, buf, sizeof(buf), callback.GetCallback());
 691     }  // Destroy |file_io|.
 692     // Save a copy to make sure buf isn't written to in the async case.
 693     char buf_copy[3];
 694     memcpy(&buf_copy, &buf, sizeof(buf));
 695     callback.WaitForResult(rv);
 696     CHECK_CALLBACK_BEHAVIOR(callback);
 697     if (callback_type() == PP_BLOCKING) {
 698       ASSERT_EQ(callback.result(), sizeof(buf));
 699     } else {
 700       ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
 701       ASSERT_EQ(0, memcmp(&buf_copy, &buf, sizeof(buf)));
 702     }
 703   }
 704
 705   // Abort |Write()|.
 706   {
 707     char buf[3] = { 0 };
 708     {
 709       pp::FileIO file_io(instance_);
 710       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 711                                           callback.GetCallback()));
 712       CHECK_CALLBACK_BEHAVIOR(callback);
 713       ASSERT_EQ(PP_OK, callback.result());
 714
 715       rv = file_io.Write(0, buf, sizeof(buf), callback.GetCallback());
 716     }  // Destroy |file_io|.
 717     callback.WaitForResult(rv);
 718     CHECK_CALLBACK_BEHAVIOR(callback);
 719     if (callback_type() == PP_BLOCKING)
 720       ASSERT_EQ(callback.result(), sizeof(buf));
 721     else
 722       ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
 723   }
 724
 725   // Abort |SetLength()|.
 726   {
 727     {
 728       pp::FileIO file_io(instance_);
 729       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
 730                                           callback.GetCallback()));
 731       CHECK_CALLBACK_BEHAVIOR(callback);
 732       ASSERT_EQ(PP_OK, callback.result());
 733
 734       rv = file_io.SetLength(3, callback.GetCallback());
 735     }  // Destroy |file_io|.
 736     callback.WaitForAbortResult(rv);
 737     CHECK_CALLBACK_BEHAVIOR(callback);
 738   }
 739
 740   // Abort |Flush|.
 741   {
 742     {
 743       pp::FileIO file_io(instance_);
 744       callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
 745                                           callback.GetCallback()));
 746       CHECK_CALLBACK_BEHAVIOR(callback);
 747       ASSERT_EQ(PP_OK, callback.result());
 748
 749       rv = file_io.Flush(callback.GetCallback());
 750     }  // Destroy |file_io|.
 751     callback.WaitForAbortResult(rv);
 752     CHECK_CALLBACK_BEHAVIOR(callback);
 753   }
 754
 755   PASS();
 756 }
 757
 758 std::string TestFileIO::TestParallelReads() {
 759   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 760   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 761   pp::FileRef file_ref(file_system, "/file_parallel_reads");
 762   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 763   CHECK_CALLBACK_BEHAVIOR(callback);
 764   ASSERT_EQ(PP_OK, callback.result());
 765
 766   pp::FileIO file_io(instance_);
 767   callback.WaitForResult(file_io.Open(file_ref,
 768                                       PP_FILEOPENFLAG_CREATE |
 769                                       PP_FILEOPENFLAG_TRUNCATE |
 770                                       PP_FILEOPENFLAG_READ |
 771                                       PP_FILEOPENFLAG_WRITE,
 772                                       callback.GetCallback()));
 773   CHECK_CALLBACK_BEHAVIOR(callback);
 774   ASSERT_EQ(PP_OK, callback.result());
 775
 776   // Set up testing contents.
 777   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
 778                                  "abcdefghijkl", callback_type());
 779   ASSERT_EQ(PP_OK, rv);
 780
 781   // Parallel read operations.
 782   const char* border = "__border__";
 783   const int32_t border_size = strlen(border);
 784
 785   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
 786   int32_t read_offset_1 = 0;
 787   int32_t size_1 = 3;
 788   std::vector<char> extended_buf_1(border_size * 2 + size_1);
 789   char* buf_1 = &extended_buf_1[border_size];
 790   memcpy(&extended_buf_1[0], border, border_size);
 791   memcpy(buf_1 + size_1, border, border_size);
 792
 793   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 794   int32_t read_offset_2 = size_1;
 795   int32_t size_2 = 9;
 796   std::vector<char> extended_buf_2(border_size * 2 + size_2);
 797   char* buf_2 = &extended_buf_2[border_size];
 798   memcpy(&extended_buf_2[0], border, border_size);
 799   memcpy(buf_2 + size_2, border, border_size);
 800
 801   int32_t rv_1 = PP_OK;
 802   int32_t rv_2 = PP_OK;
 803   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
 804     if (size_1 > 0) {
 805       rv_1 = file_io.Read(read_offset_1, buf_1, size_1,
 806                           callback_1.GetCallback());
 807     }
 808     if (size_2 > 0) {
 809       rv_2 = file_io.Read(read_offset_2, buf_2, size_2,
 810                           callback_2.GetCallback());
 811     }
 812     if (size_1 > 0) {
 813       callback_1.WaitForResult(rv_1);
 814       CHECK_CALLBACK_BEHAVIOR(callback_1);
 815       ASSERT_TRUE(callback_1.result() > 0);
 816       read_offset_1 += callback_1.result();
 817       buf_1 += callback_1.result();
 818       size_1 -= callback_1.result();
 819     }
 820
 821     if (size_2 > 0) {
 822       callback_2.WaitForResult(rv_2);
 823       CHECK_CALLBACK_BEHAVIOR(callback_2);
 824       ASSERT_TRUE(callback_2.result() > 0);
 825       read_offset_2 += callback_2.result();
 826       buf_2 += callback_2.result();
 827       size_2 -= callback_2.result();
 828     }
 829   }
 830
 831   // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s).
 832   ASSERT_EQ(0, size_1);
 833   ASSERT_EQ(0, size_2);
 834
 835   // Make sure every read operation writes into the correct buffer.
 836   const char expected_result_1[] = "__border__abc__border__";
 837   const char expected_result_2[] = "__border__defghijkl__border__";
 838   ASSERT_TRUE(strncmp(&extended_buf_1[0], expected_result_1,
 839                       strlen(expected_result_1)) == 0);
 840   ASSERT_TRUE(strncmp(&extended_buf_2[0], expected_result_2,
 841                       strlen(expected_result_2)) == 0);
 842   PASS();
 843 }
 844
 845 std::string TestFileIO::TestParallelWrites() {
 846   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 847   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 848   pp::FileRef file_ref(file_system, "/file_parallel_writes");
 849   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 850   CHECK_CALLBACK_BEHAVIOR(callback);
 851   ASSERT_EQ(PP_OK, callback.result());
 852
 853   pp::FileIO file_io(instance_);
 854   callback.WaitForResult(file_io.Open(file_ref,
 855                                       PP_FILEOPENFLAG_CREATE |
 856                                       PP_FILEOPENFLAG_TRUNCATE |
 857                                       PP_FILEOPENFLAG_READ |
 858                                       PP_FILEOPENFLAG_WRITE,
 859                                       callback.GetCallback()));
 860   CHECK_CALLBACK_BEHAVIOR(callback);
 861   ASSERT_EQ(PP_OK, callback.result());
 862
 863   // Parallel write operations.
 864   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
 865   int32_t write_offset_1 = 0;
 866   const char* buf_1 = "abc";
 867   int32_t size_1 = strlen(buf_1);
 868
 869   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 870   int32_t write_offset_2 = size_1;
 871   const char* buf_2 = "defghijkl";
 872   int32_t size_2 = strlen(buf_2);
 873
 874   int32_t rv_1 = PP_OK;
 875   int32_t rv_2 = PP_OK;
 876   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
 877     if (size_1 > 0) {
 878       rv_1 = file_io.Write(write_offset_1, buf_1, size_1,
 879                            callback_1.GetCallback());
 880     }
 881     if (size_2 > 0) {
 882       rv_2 = file_io.Write(write_offset_2, buf_2, size_2,
 883                            callback_2.GetCallback());
 884     }
 885
 886     if (size_1 > 0) {
 887       callback_1.WaitForResult(rv_1);
 888       CHECK_CALLBACK_BEHAVIOR(callback_1);
 889       ASSERT_TRUE(callback_1.result() > 0);
 890       write_offset_1 += callback_1.result();
 891       buf_1 += callback_1.result();
 892       size_1 -= callback_1.result();
 893     }
 894
 895     if (size_2 > 0) {
 896       callback_2.WaitForResult(rv_2);
 897       CHECK_CALLBACK_BEHAVIOR(callback_2);
 898       ASSERT_TRUE(callback_2.result() > 0);
 899       write_offset_2 += callback_2.result();
 900       buf_2 += callback_2.result();
 901       size_2 -= callback_2.result();
 902     }
 903   }
 904
 905   // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s).
 906   ASSERT_EQ(0, size_1);
 907   ASSERT_EQ(0, size_2);
 908
 909   // Check the file contents.
 910   std::string read_buffer;
 911   int32_t rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0,
 912                               &read_buffer, callback_type());
 913   ASSERT_EQ(PP_OK, rv);
 914   ASSERT_EQ(std::string("abcdefghijkl"), read_buffer);
 915
 916   PASS();
 917 }
 918
 919 std::string TestFileIO::TestNotAllowMixedReadWrite() {
 920   if (callback_type() == PP_BLOCKING) {
 921     // This test does not make sense for blocking callbacks.
 922     PASS();
 923   }
 924   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 925
 926   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 927   pp::FileRef file_ref(file_system, "/file_not_allow_mixed_read_write");
 928   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 929   CHECK_CALLBACK_BEHAVIOR(callback);
 930   ASSERT_EQ(PP_OK, callback.result());
 931
 932   pp::FileIO file_io(instance_);
 933   callback.WaitForResult(file_io.Open(file_ref,
 934                                       PP_FILEOPENFLAG_CREATE |
 935                                       PP_FILEOPENFLAG_TRUNCATE |
 936                                       PP_FILEOPENFLAG_READ |
 937                                       PP_FILEOPENFLAG_WRITE,
 938                                       callback.GetCallback()));
 939   CHECK_CALLBACK_BEHAVIOR(callback);
 940   ASSERT_EQ(PP_OK, callback.result());
 941
 942   TestCompletionCallback callback_1(instance_->pp_instance(), PP_REQUIRED);
 943   int32_t write_offset_1 = 0;
 944   const char* buf_1 = "mnopqrstuvw";
 945   int32_t rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 946                                callback_1.GetCallback());
 947   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 948
 949   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 950   int32_t read_offset_2 = 4;
 951   char buf_2[3];
 952   callback_2.WaitForResult(file_io.Read(read_offset_2, buf_2, sizeof(buf_2),
 953                                         callback_2.GetCallback()));
 954   CHECK_CALLBACK_BEHAVIOR(callback_2);
 955   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 956   callback_1.WaitForResult(rv_1);
 957   CHECK_CALLBACK_BEHAVIOR(callback_1);
 958
 959   // Cannot query while a write is pending.
 960   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 961                        callback_1.GetCallback());
 962   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 963   PP_FileInfo info;
 964   callback_2.WaitForResult(file_io.Query(&info, callback_2.GetCallback()));
 965   CHECK_CALLBACK_BEHAVIOR(callback_2);
 966   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 967   callback_1.WaitForResult(rv_1);
 968   CHECK_CALLBACK_BEHAVIOR(callback_1);
 969
 970   // Cannot touch while a write is pending.
 971   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 972                        callback_1.GetCallback());
 973   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 974   callback_2.WaitForResult(file_io.Touch(1234.0, 5678.0,
 975                            callback_2.GetCallback()));
 976   CHECK_CALLBACK_BEHAVIOR(callback_2);
 977   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 978   callback_1.WaitForResult(rv_1);
 979   CHECK_CALLBACK_BEHAVIOR(callback_1);
 980
 981   // Cannot set length while a write is pending.
 982   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
 983                        callback_1.GetCallback());
 984   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 985   callback_2.WaitForResult(file_io.SetLength(123, callback_2.GetCallback()));
 986   CHECK_CALLBACK_BEHAVIOR(callback_2);
 987   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
 988   callback_1.WaitForResult(rv_1);
 989   CHECK_CALLBACK_BEHAVIOR(callback_1);
 990
 991   PASS();
 992 }
 993
 994 std::string TestFileIO::TestWillWriteWillSetLength() {
 995   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 996
 997   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 998   pp::FileRef file_ref(file_system, "/file_will_write");
 999   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1000   CHECK_CALLBACK_BEHAVIOR(callback);
1001   ASSERT_EQ(PP_OK, callback.result());
1002
1003   pp::FileIO file_io(instance_);
1004   callback.WaitForResult(file_io.Open(file_ref,
1005                                       PP_FILEOPENFLAG_CREATE |
1006                                       PP_FILEOPENFLAG_TRUNCATE |
1007                                       PP_FILEOPENFLAG_READ |
1008                                       PP_FILEOPENFLAG_WRITE,
1009                                       callback.GetCallback()));
1010   CHECK_CALLBACK_BEHAVIOR(callback);
1011   ASSERT_EQ(PP_OK, callback.result());
1012
1013   const PPB_FileIOTrusted* trusted = static_cast<const PPB_FileIOTrusted*>(
1014       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
1015   ASSERT_TRUE(trusted);
1016
1017   // Get file descriptor. This is only supported in-process for now, so don't
1018   // test out of process.
1019   const PPB_Testing_Dev* testing_interface = GetTestingInterface();
1020   if (testing_interface && !testing_interface->IsOutOfProcess()) {
1021     int32_t fd = trusted->GetOSFileDescriptor(file_io.pp_resource());
1022     ASSERT_TRUE(fd >= 0);
1023   }
1024
1025   // Calling WillWrite.
1026   callback.WaitForResult(trusted->WillWrite(
1027       file_io.pp_resource(), 0, 9,
1028       callback.GetCallback().pp_completion_callback()));
1029   CHECK_CALLBACK_BEHAVIOR(callback);
1030   ASSERT_EQ(9, callback.result());
1031
1032   // Writing the actual data.
1033   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
1034                                  "test_test", callback_type());
1035   ASSERT_EQ(PP_OK, rv);
1036
1037   std::string read_buffer;
1038   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
1039                       callback_type());
1040   ASSERT_EQ(PP_OK, rv);
1041   ASSERT_EQ(std::string("test_test"), read_buffer);
1042
1043   // Calling WillSetLength.
1044   callback.WaitForResult(trusted->WillSetLength(
1045       file_io.pp_resource(), 4,
1046       callback.GetCallback().pp_completion_callback()));
1047   CHECK_CALLBACK_BEHAVIOR(callback);
1048   ASSERT_EQ(PP_OK, rv);
1049
1050   // Calling actual SetLength.
1051   callback.WaitForResult(file_io.SetLength(4, callback.GetCallback()));
1052   CHECK_CALLBACK_BEHAVIOR(callback);
1053   ASSERT_EQ(PP_OK, rv);
1054
1055   read_buffer.clear();
1056   rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
1057                       callback_type());
1058   ASSERT_EQ(PP_OK, rv);
1059   ASSERT_EQ(std::string("test"), read_buffer);
1060
1061   PASS();
1062 }
1063
1064 std::string TestFileIO::TestRequestOSFileHandle() {
1065   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1066
1067   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
1068   pp::FileRef file_ref(file_system, "/file_os_fd");
1069
1070   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1071   ASSERT_EQ(PP_OK, callback.result());
1072
1073   pp::FileIO_Private file_io(instance_);
1074   callback.WaitForResult(file_io.Open(file_ref,
1075                                       PP_FILEOPENFLAG_CREATE |
1076                                       PP_FILEOPENFLAG_TRUNCATE |
1077                                       PP_FILEOPENFLAG_READ |
1078                                       PP_FILEOPENFLAG_WRITE,
1079                                       callback.GetCallback()));
1080   ASSERT_EQ(PP_OK, callback.result());
1081
1082   TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
1083       instance_->pp_instance(), callback_type());
1084   output_callback.WaitForResult(
1085       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1086   PP_FileHandle handle = output_callback.output().Release();
1087   ASSERT_EQ(PP_OK, output_callback.result());
1088
1089   if (handle == PP_kInvalidFileHandle)
1090     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1091 #if defined(PPAPI_OS_WIN)
1092   int fd = _open_osfhandle(reinterpret_cast<intptr_t>(handle),
1093                            _O_RDWR | _O_BINARY);
1094 #else
1095   int fd = handle;
1096 #endif
1097   if (fd < 0)
1098     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
1099
1100   // Check write(2) for the native FD.
1101   const std::string msg = "foobar";
1102   ssize_t cnt = write(fd, msg.data(), msg.size());
1103   if (cnt < 0)
1104     return ReportError("write for native FD returned error", errno);
1105   if (cnt != static_cast<ssize_t>(msg.size()))
1106     return ReportError("write for native FD count mismatch", cnt);
1107
1108   // Check lseek(2) for the native FD.
1109   off_t off = lseek(fd, 0, SEEK_CUR);
1110   if (off == static_cast<off_t>(-1))
1111     return ReportError("lseek for native FD returned error", errno);
1112   if (off != static_cast<off_t>(msg.size()))
1113     return ReportError("lseek for native FD offset mismatch", off);
1114
1115   off = lseek(fd, 0, SEEK_SET);
1116   if (off == static_cast<off_t>(-1))
1117     return ReportError("lseek for native FD returned error", errno);
1118   if (off != 0)
1119     return ReportError("lseek for native FD offset mismatch", off);
1120
1121   // Check read(2) for the native FD.
1122   std::string buf(msg.size(), '\0');
1123   cnt = read(fd, &buf[0], msg.size());
1124   if (cnt < 0)
1125     return ReportError("read for native FD returned error", errno);
1126   if (cnt != static_cast<ssize_t>(msg.size()))
1127     return ReportError("read for native FD count mismatch", cnt);
1128   if (msg != buf)
1129     return ReportMismatch("read for native FD", buf, msg);
1130   PASS();
1131 }
1132
1133 // Calling RequestOSFileHandle with the FileIO that is opened with
1134 // PP_FILEOPENFLAG_EXCLUSIVE used to cause NaCl module to crash while loading.
1135 // This is a regression test for crbug.com/243241.
1136 std::string TestFileIO::TestRequestOSFileHandleWithOpenExclusive() {
1137   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1138
1139   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
1140   pp::FileRef file_ref(file_system, "/file_os_fd2");
1141
1142   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1143   ASSERT_EQ(PP_OK, callback.result());
1144
1145   // Open with PP_FILEOPENFLAG_CREATE and PP_FILEOPENFLAG_EXCLUSIVE will fail
1146   // if the file already exists. Delete it here to make sure it does not.
1147   callback.WaitForResult(file_ref.Delete(callback.GetCallback()));
1148
1149   pp::FileIO_Private file_io(instance_);
1150   callback.WaitForResult(file_io.Open(file_ref,
1151                                       PP_FILEOPENFLAG_CREATE |
1152                                       PP_FILEOPENFLAG_READ |
1153                                       PP_FILEOPENFLAG_WRITE |
1154                                       PP_FILEOPENFLAG_EXCLUSIVE,
1155                                       callback.GetCallback()));
1156   ASSERT_EQ(PP_OK, callback.result());
1157
1158   TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
1159       instance_->pp_instance(), callback_type());
1160   output_callback.WaitForResult(
1161       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1162   PP_FileHandle handle = output_callback.output().Release();
1163   if (handle == PP_kInvalidFileHandle)
1164     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1165   ASSERT_EQ(PP_OK, output_callback.result());
1166
1167   PASS();
1168 }
1169
1170 std::string TestFileIO::TestMmap() {
1171 #if !defined(PPAPI_OS_WIN)
1172   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1173
1174   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
1175   pp::FileRef file_ref(file_system, "/file_os_fd");
1176
1177   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
1178   ASSERT_EQ(PP_OK, callback.result());
1179
1180   pp::FileIO_Private file_io(instance_);
1181   callback.WaitForResult(file_io.Open(file_ref,
1182                                       PP_FILEOPENFLAG_CREATE |
1183                                       PP_FILEOPENFLAG_TRUNCATE |
1184                                       PP_FILEOPENFLAG_READ |
1185                                       PP_FILEOPENFLAG_WRITE,
1186                                       callback.GetCallback()));
1187   ASSERT_EQ(PP_OK, callback.result());
1188
1189   TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
1190       instance_->pp_instance(), callback_type());
1191   output_callback.WaitForResult(
1192       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1193   PP_FileHandle handle = output_callback.output().Release();
1194   ASSERT_EQ(PP_OK, output_callback.result());
1195
1196   if (handle == PP_kInvalidFileHandle)
1197     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1198   int fd = handle;
1199   if (fd < 0)
1200     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
1201
1202   // Check write(2) for the native FD.
1203   const std::string msg = "foobar";
1204   ssize_t cnt = write(fd, msg.data(), msg.size());
1205   if (cnt < 0)
1206     return ReportError("write for native FD returned error", errno);
1207   if (cnt != static_cast<ssize_t>(msg.size()))
1208     return ReportError("write for native FD count mismatch", cnt);
1209
1210   // BEGIN mmap(2) test with a file handle opened in READ-WRITE mode.
1211   // Check mmap(2) for read.
1212   {
1213     char* mapped = reinterpret_cast<char*>(
1214         mmap(NULL, msg.size(), PROT_READ, MAP_PRIVATE, fd, 0));
1215     if (mapped == MAP_FAILED)
1216       return ReportError("mmap(r) for native FD returned errno", errno);
1217     // Make sure the buffer is cleared.
1218     std::string buf = std::string(msg.size(), '\0');
1219     memcpy(&buf[0], mapped, msg.size());
1220     if (msg != buf)
1221       return ReportMismatch("mmap(r) for native FD", buf, msg);
1222     int r = munmap(mapped, msg.size());
1223     if (r < 0)
1224       return ReportError("munmap for native FD returned error", errno);
1225   }
1226
1227   // Check mmap(2) for write with MAP_PRIVATE
1228   {
1229     char* mapped = reinterpret_cast<char*>(
1230         mmap(NULL, msg.size(), PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0));
1231     if (mapped == MAP_FAILED)
1232       return ReportError("mmap(r) for native FD returned errno", errno);
1233     // Make sure the file is not polluted by writing to privage mmap.
1234     strncpy(mapped, "baz", 3);
1235     std::string read_buffer;
1236     ASSERT_TRUE(ReadEntireFileFromFileHandle(fd, &read_buffer));
1237     if (msg != read_buffer)
1238       return ReportMismatch("file content != msg", read_buffer, msg);
1239     int r = munmap(mapped, msg.size());
1240     if (r < 0)
1241       return ReportError("munmap for native FD returned error", errno);
1242   }
1243
1244   // Check mmap(2) for write with MAP_SHARED.
1245   {
1246     char* mapped = reinterpret_cast<char*>(
1247         mmap(NULL, msg.size(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
1248     if (mapped == MAP_FAILED)
1249       return ReportError("mmap(w) for native FD returned errno", errno);
1250     // s/foo/baz/
1251     strncpy(mapped, "baz", 3);
1252     std::string read_buffer;
1253     ASSERT_TRUE(ReadEntireFileFromFileHandle(fd, &read_buffer));
1254     if (read_buffer != "bazbar")
1255       return ReportMismatch("file content != msg", read_buffer, "bazbar");
1256     int r = munmap(mapped, msg.size());
1257     if (r < 0)
1258       return ReportError("munmap for native FD returned error", errno);
1259   }
1260   // END mmap(2) test with a file handle opened in READ-WRITE mode.
1261
1262   if (close(fd) < 0)
1263     return ReportError("close for native FD returned error", errno);
1264
1265   // BEGIN mmap(2) test with a file handle opened in READONLY mode.
1266   file_io = pp::FileIO_Private(instance_);
1267   callback.WaitForResult(file_io.Open(file_ref,
1268                                       PP_FILEOPENFLAG_READ,
1269                                       callback.GetCallback()));
1270   ASSERT_EQ(PP_OK, callback.result());
1271
1272   output_callback = TestCompletionCallbackWithOutput<pp::PassFileHandle>(
1273       instance_->pp_instance(), callback_type());
1274   output_callback.WaitForResult(
1275       file_io.RequestOSFileHandle(output_callback.GetCallback()));
1276   handle = output_callback.output().Release();
1277   ASSERT_EQ(PP_OK, output_callback.result());
1278
1279   if (handle == PP_kInvalidFileHandle)
1280     return "FileIO::RequestOSFileHandle() returned a bad file handle.";
1281   fd = handle;
1282   if (fd < 0)
1283     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
1284
1285   const std::string msg2 = "bazbar";
1286
1287   // Check mmap(2) for read.
1288   {
1289     char* mapped = reinterpret_cast<char*>(
1290         mmap(NULL, msg2.size(), PROT_READ, MAP_PRIVATE, fd, 0));
1291     if (mapped == MAP_FAILED)
1292       return ReportError("mmap(r) for native FD returned errno", errno);
1293     // Make sure the buffer is cleared.
1294     std::string buf = std::string(msg2.size(), '\0');
1295     memcpy(&buf[0], mapped, msg2.size());
1296     if (msg2 != buf)
1297       return ReportMismatch("mmap(r) for native FD", buf, msg2);
1298     int r = munmap(mapped, msg2.size());
1299     if (r < 0)
1300       return ReportError("munmap for native FD returned error", errno);
1301   }
1302
1303   // Check mmap(2) for write with MAP_PRIVATE
1304   {
1305     char* mapped = reinterpret_cast<char*>(
1306         mmap(NULL, msg2.size(), PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0));
1307     if (mapped == MAP_FAILED)
1308       return ReportError("mmap(r) for native FD returned errno", errno);
1309     // Make sure the file is not polluted by writing to privage mmap.
1310     strncpy(mapped, "baz", 3);
1311     std::string read_buffer;
1312     ASSERT_TRUE(ReadEntireFileFromFileHandle(fd, &read_buffer));
1313     if (msg2 != read_buffer)
1314       return ReportMismatch("file content != msg2", read_buffer, msg2);
1315     int r = munmap(mapped, msg2.size());
1316     if (r < 0)
1317       return ReportError("munmap for native FD returned error", errno);
1318   }
1319
1320   // Check mmap(2) for write with MAP_SHARED.
1321   {
1322     char* mapped = reinterpret_cast<char*>(
1323         mmap(NULL, msg2.size(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
1324     if (mapped != MAP_FAILED)
1325       return ReportError("mmap(w) for native FD must fail when opened readonly",
1326                          -1);
1327   }
1328   // END mmap(2) test with a file handle opened in READONLY mode.
1329
1330   if (close(fd) < 0)
1331     return ReportError("close for native FD returned error", errno);
1332 #endif  // !defined(PPAPI_OS_WIN)
1333
1334   PASS();
1335 }
1336
1337 std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system,
1338                                               size_t open_flags,
1339                                               size_t expectations) {
1340   std::string bad_argument =
1341       "TestFileIO::MatchOpenExpectations has invalid input arguments.";
1342   bool invalid_combination = !!(expectations & INVALID_FLAG_COMBINATION);
1343   if (invalid_combination) {
1344     if (expectations != INVALID_FLAG_COMBINATION)
1345       return bad_argument;
1346   } else {
1347     // Validate that one and only one of <some_expectation> and
1348     // DONT_<some_expectation> is specified.
1349     for (size_t remains = expectations, end = END_OF_OPEN_EXPECATION_PAIRS;
1350          end != 0; remains >>= 2, end >>= 2) {
1351       if (!!(remains & 1) == !!(remains & 2))
1352         return bad_argument;
1353     }
1354   }
1355   bool create_if_doesnt_exist = !!(expectations & CREATE_IF_DOESNT_EXIST);
1356   bool open_if_exists = !!(expectations & OPEN_IF_EXISTS);
1357   bool truncate_if_exists = !!(expectations & TRUNCATE_IF_EXISTS);
1358
1359   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
1360   pp::FileRef existent_file_ref(
1361       *file_system, "/match_open_expectation_existent_non_empty_file");
1362   pp::FileRef nonexistent_file_ref(
1363       *file_system, "/match_open_expectation_nonexistent_file");
1364
1365   // Setup files for test.
1366   {
1367     callback.WaitForResult(existent_file_ref.Delete(callback.GetCallback()));
1368     CHECK_CALLBACK_BEHAVIOR(callback);
1369     ASSERT_TRUE(callback.result() == PP_OK ||
1370                 callback.result() == PP_ERROR_FILENOTFOUND);
1371     callback.WaitForResult(nonexistent_file_ref.Delete(callback.GetCallback()));
1372     CHECK_CALLBACK_BEHAVIOR(callback);
1373     ASSERT_TRUE(callback.result() == PP_OK ||
1374                 callback.result() == PP_ERROR_FILENOTFOUND);
1375
1376     pp::FileIO existent_file_io(instance_);
1377     callback.WaitForResult(existent_file_io.Open(
1378         existent_file_ref,
1379         PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
1380         callback.GetCallback()));
1381     CHECK_CALLBACK_BEHAVIOR(callback);
1382     ASSERT_EQ(PP_OK, callback.result());
1383     int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io,
1384                                    0, "foobar", callback_type());
1385     ASSERT_EQ(PP_OK, rv);
1386   }
1387
1388   pp::FileIO existent_file_io(instance_);
1389   callback.WaitForResult(existent_file_io.Open(existent_file_ref, open_flags,
1390                                                callback.GetCallback()));
1391   CHECK_CALLBACK_BEHAVIOR(callback);
1392   if ((invalid_combination && callback.result() == PP_OK) ||
1393       (!invalid_combination &&
1394        ((callback.result() == PP_OK) != open_if_exists))) {
1395     return ReportOpenError(open_flags);
1396   }
1397
1398   if (!invalid_combination && open_if_exists) {
1399     PP_FileInfo info;
1400     callback.WaitForResult(existent_file_io.Query(&info,
1401                                                   callback.GetCallback()));
1402     CHECK_CALLBACK_BEHAVIOR(callback);
1403     ASSERT_EQ(PP_OK, callback.result());
1404     if (truncate_if_exists != (info.size == 0))
1405       return ReportOpenError(open_flags);
1406   }
1407
1408   pp::FileIO nonexistent_file_io(instance_);
1409   callback.WaitForResult(nonexistent_file_io.Open(nonexistent_file_ref,
1410                                                   open_flags,
1411                                                   callback.GetCallback()));
1412   CHECK_CALLBACK_BEHAVIOR(callback);
1413   if ((invalid_combination && callback.result() == PP_OK) ||
1414       (!invalid_combination &&
1415        ((callback.result() == PP_OK) != create_if_doesnt_exist))) {
1416     return ReportOpenError(open_flags);
1417   }
1418
1419   return std::string();
1420 }
1421
1422 // TODO(viettrungluu): Test Close(). crbug.com/69457