Add a PPAPI browser tests for an issue of NaCl crash

ppapi/tests/test_file_io.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_file_io.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <sys/stat.h>
@@ skipping 166 matching lines @@
   RUN_CALLBACK_TEST(TestFileIO, OpenDirectory, filter);
   RUN_CALLBACK_TEST(TestFileIO, ReadWriteSetLength, filter);
   RUN_CALLBACK_TEST(TestFileIO, ReadToArrayWriteSetLength, filter);
   RUN_CALLBACK_TEST(TestFileIO, TouchQuery, filter);
   RUN_CALLBACK_TEST(TestFileIO, AbortCalls, filter);
   RUN_CALLBACK_TEST(TestFileIO, ParallelReads, filter);
   RUN_CALLBACK_TEST(TestFileIO, ParallelWrites, filter);
   RUN_CALLBACK_TEST(TestFileIO, NotAllowMixedReadWrite, filter);
   RUN_CALLBACK_TEST(TestFileIO, WillWriteWillSetLength, filter);
   RUN_CALLBACK_TEST(TestFileIO, RequestOSFileHandle, filter);
+  RUN_CALLBACK_TEST(TestFileIO, RequestOSFileHandleWithOpenExclusive, filter);
   RUN_CALLBACK_TEST(TestFileIO, Mmap, filter);
 
   // TODO(viettrungluu): add tests:
   //  - that PP_ERROR_PENDING is correctly returned
   //  - that operations respect the file open modes (flags)
 }
 
 std::string TestFileIO::TestOpen() {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 
@@ skipping 904 matching lines @@
   cnt = read(fd, &buf[0], msg.size());
   if (cnt < 0)
     return ReportError("read for native FD returned error", errno);
   if (cnt != static_cast<ssize_t>(msg.size()))
     return ReportError("read for native FD count mismatch", cnt);
   if (msg != buf)
     return ReportMismatch("read for native FD", buf, msg);
   PASS();
 }
 
+// Calling RequestOSFileHandle with the FileIO that is opened with
+// PP_FILEOPENFLAG_EXCLUSIVE used to cause NaCl module to crash while loading.
+// This is a regression test for crbug.com/243241.
+std::string TestFileIO::TestRequestOSFileHandleWithOpenExclusive() {
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_os_fd2");
+
+  callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
+  ASSERT_EQ(PP_OK, callback.result());
+
+  pp::FileIO_Private file_io(instance_);
+  callback.WaitForResult(file_io.Open(file_ref,
+                                      PP_FILEOPENFLAG_CREATE |
+                                      PP_FILEOPENFLAG_READ |
+                                      PP_FILEOPENFLAG_WRITE |
+                                      PP_FILEOPENFLAG_EXCLUSIVE,
+                                      callback.GetCallback()));
+  ASSERT_EQ(PP_OK, callback.result());
+
+  TestCompletionCallbackWithOutput<pp::PassFileHandle> output_callback(
+      instance_->pp_instance(), callback_type());
+  output_callback.WaitForResult(
+      file_io.RequestOSFileHandle(output_callback.GetCallback()));
+  PP_FileHandle handle = output_callback.output().Release();
+  if (handle == PP_kInvalidFileHandle)
+    return "FileIO::RequestOSFileHandle() returned a bad file handle.";
+  ASSERT_EQ(PP_OK, output_callback.result());
+
+  PASS();
+}
+
 std::string TestFileIO::TestMmap() {
 #if !defined(PPAPI_OS_WIN)
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_os_fd");
 
   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
   ASSERT_EQ(PP_OK, callback.result());
 
@@ skipping 233 matching lines @@
   if ((invalid_combination && callback.result() == PP_OK) ||
       (!invalid_combination &&
        ((callback.result() == PP_OK) != create_if_doesnt_exist))) {
     return ReportOpenError(open_flags);
   }
 
   return std::string();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457