Fix PP_FileOpenFlags_Dev handling:

ppapi/tests/test_file_io.cc

 // Copyright (c) 2011 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 <stdio.h>
 #include <string.h>
 
 #include "ppapi/c/pp_errors.h"
@@ skipping 11 matching lines @@
 
 namespace {
 
 std::string ReportMismatch(const std::string& method_name,
                            const std::string& returned_result,
                            const std::string& expected_result) {
   return method_name + " returned '" + returned_result + "'; '" +
       expected_result + "' expected.";
 }
 
+std::string ReportOpenError(int32_t open_flags) {
+  static const char* kFlagNames[] = {
+    "PP_FILEOPENFLAG_READ",
+    "PP_FILEOPENFLAG_WRITE",
+    "PP_FILEOPENFLAG_CREATE",
+    "PP_FILEOPENFLAG_TRUNCATE",
+    "PP_FILEOPENFLAG_EXCLUSIVE"
+  };
+
+  std::string result = "FileIO:Open had unexpected behavior with flags: ";
+  bool first_flag = true;
+  for (int32_t mask = 1, index = 0; mask <= PP_FILEOPENFLAG_EXCLUSIVE;
+       mask <<= 1, ++index) {
+    if (mask & open_flags) {
+      if (first_flag) {
+        first_flag = false;
+      } else {
+        result += " | ";
+      }
+      result += kFlagNames[index];
+    }
+  }
+  if (first_flag)
+    result += "[None]";
+
+  return result;
+}
+
 int32_t ReadEntireFile(PP_Instance instance,
                        pp::FileIO_Dev* file_io,
                        int32_t offset,
                        std::string* data) {
   TestCompletionCallback callback(instance);
   char buf[256];
   int32_t read_offset = offset;
 
   for (;;) {
     int32_t rv = file_io->Read(read_offset, buf, sizeof(buf), callback);
@@ skipping 54 matching lines @@
   TestCompletionCallback callback(instance_->pp_instance());
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_open");
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io(instance_);
-  rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("FileIO::Open", rv);
+  std::string result;
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_READ,
+      NOT_CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | NOT_TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
 
-  // Try opening a file that doesn't exist.
-  pp::FileRef_Dev nonexistent_file_ref(file_system, "/nonexistent_file");
-  pp::FileIO_Dev nonexistent_file_io(instance_);
-  rv = nonexistent_file_io.Open(
-      nonexistent_file_ref, PP_FILEOPENFLAG_READ, callback);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_ERROR_FILENOTFOUND)
-    return ReportError("FileIO::Open", rv);
+  // Test the behavior of the power set of
+  //   { PP_FILEOPENFLAG_CREATE,
+  //     PP_FILEOPENFLAG_TRUNCATE,
+  //     PP_FILEOPENFLAG_EXCLUSIVE }.
+
+  // First of all, none of them are specificed.
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE,
+      NOT_CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | NOT_TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE,
+      CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | NOT_TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE,
+      NOT_CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | NOT_TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_TRUNCATE,
+      NOT_CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
+      PP_FILEOPENFLAG_EXCLUSIVE,
+      CREATE_IF_NOT_EXIST | NOT_OPEN_IF_EXIST | NOT_TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_TRUNCATE,
+      CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_EXCLUSIVE |
+      PP_FILEOPENFLAG_TRUNCATE,
+      NOT_CREATE_IF_NOT_EXIST | OPEN_IF_EXIST | TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
+      PP_FILEOPENFLAG_EXCLUSIVE | PP_FILEOPENFLAG_TRUNCATE,
+      CREATE_IF_NOT_EXIST | NOT_OPEN_IF_EXIST | NOT_TRUNCATE_IF_EXIST);
+  if (!result.empty())
+    return result;
+
+  // Invalid combination: PP_FILEOPENFLAG_TRUNCATE without
+  // PP_FILEOPENFLAG_WRITE.
+  result = MatchOpenExpectations(
+      &file_system,
+      PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_TRUNCATE,
+      INVALID_FLAG_COMBINATION);
+  if (!result.empty())
+    return result;
 
   PASS();
 }
 
 std::string TestFileIO::TestReadWriteSetLength() {
   TestCompletionCallback callback(instance_->pp_instance());
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_read_write_setlength");
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
   pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
 
   // Write something to the file.
   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test");
@@ skipping 93 matching lines @@
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
   pp::FileRef_Dev file_ref(file_system, "/file_touch");
   pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref,
-                    PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_WRITE,
                     callback);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
 
   // Write some data to have a non-zero file size.
   rv = file_io.Write(0, "test", 4, callback);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
@@ skipping 225 matching lines @@
       return ReportError("FileIO::Flush", rv);
     }
   }
 
   // TODO(viettrungluu): Also test that Close() aborts callbacks.
   // crbug.com/69457
 
   PASS();
 }
 
+std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
+                                              size_t open_flags,
+                                              size_t expectations) {
+  std::string bad_argument =
+      "TestFileIO::MatchOpenExpectations has invalid input arguments.";
+  bool invalid_combination = !!(expectations & INVALID_FLAG_COMBINATION);
+  if (invalid_combination) {
+    if (expectations != INVALID_FLAG_COMBINATION)
+      return bad_argument;
+  } else {
+    // Validate that one and only one of <some_expectation> and
+    // NOT_<some_expectation> is specified.
+    for (size_t remains = expectations, end = END_OF_PAIR; end != 0;
+         remains >>= 2, end >>= 2) {
+      if (!!(remains & 1) == !!(remains & 2))
+        return bad_argument;
+    }
+  }
+  bool create_if_not_exist = !!(expectations & CREATE_IF_NOT_EXIST);
+  bool open_if_exist = !!(expectations & OPEN_IF_EXIST);
+  bool truncate_if_exist = !!(expectations & TRUNCATE_IF_EXIST);
+
+  TestCompletionCallback callback(instance_->pp_instance());
+  pp::FileRef_Dev existent_file_ref(
+      *file_system, "/match_open_expectation_existent_non_empty_file");
+  pp::FileRef_Dev nonexistent_file_ref(
+      *file_system, "/match_open_expectation_nonexistent_file");
+
+  // Setup files for test.
+  {
+    int32_t rv = existent_file_ref.Delete(callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
+      return ReportError("FileRef::Delete", rv);
+
+    rv = nonexistent_file_ref.Delete(callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
+      return ReportError("FileRef::Delete", rv);
+
+    pp::FileIO_Dev existent_file_io(instance_);
+    rv = existent_file_io.Open(existent_file_ref,
+                               PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
+                               callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK)
+      return ReportError("FileIO::Open", rv);
+
+    rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io, 0,
+                           "foobar");
+    if (rv != PP_OK)
+      return ReportError("FileIO::Write", rv);
+  }
+
+  pp::FileIO_Dev existent_file_io(instance_);
+  int32_t rv = existent_file_io.Open(existent_file_ref, open_flags, callback);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if ((invalid_combination && rv == PP_OK) ||
+      (!invalid_combination && ((rv == PP_OK) != open_if_exist))) {
+    return ReportOpenError(open_flags);
+  }
+
+  if (!invalid_combination && open_if_exist) {
+    PP_FileInfo_Dev info;
+    rv = existent_file_io.Query(&info, callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK)
+      return ReportError("FileIO::Query", rv);
+
+    if (truncate_if_exist != (info.size == 0))
+      return ReportOpenError(open_flags);
+  }
+
+  pp::FileIO_Dev nonexistent_file_io(instance_);
+  rv = nonexistent_file_io.Open(nonexistent_file_ref, open_flags, callback);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if ((invalid_combination && rv == PP_OK) ||
+      (!invalid_combination && ((rv == PP_OK) != create_if_not_exist))) {
+    return ReportOpenError(open_flags);
+  }
+
+  return std::string();
+}
+
 // TODO(viettrungluu): Test Close(). crbug.com/69457