PPAPI: Add new PPB_FileRef.MakeDirectory to support exclusive operation

ppapi/tests/test_file_ref.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_ref.h"
 
 #include <stdio.h>
 
 #include <sstream>
 #include <vector>
@@ skipping 280 matching lines @@
 
 std::string TestFileRef::TestMakeDirectory() {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 
   // Open.
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
-  // MakeDirectory.
-  pp::FileRef dir_ref(file_system, "/test_dir_make_directory");
-  callback.WaitForResult(dir_ref.MakeDirectory(callback.GetCallback()));
+  // Make a directory.
+  pp::FileRef dir_ref(file_system, "/dir_make_dir");
+  callback.WaitForResult(
+      dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
-  // MakeDirectory aborted.
+  // Make a directory on the existing path without exclusive flag.
+  callback.WaitForResult(
+      dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // Making a directory should be aborted.
   int32_t rv = PP_ERROR_FAILED;
   {
-    rv = pp::FileRef(file_system, "/test_dir_make_abort")
-        .MakeDirectory(callback.GetCallback());
+    rv = pp::FileRef(file_system, "/dir_make_dir_abort")
+        .MakeDirectory(PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback());
   }
   callback.WaitForAbortResult(rv);
   CHECK_CALLBACK_BEHAVIOR(callback);
 
-  // MakeDirectoryIncludingAncestors.
-  dir_ref = pp::FileRef(file_system, "/dir_make_dir_1/dir_make_dir_2");
+  // Make nested directories.
+  dir_ref = pp::FileRef(file_system, "/dir_make_nested_dir_1/dir");
   callback.WaitForResult(
-      dir_ref.MakeDirectoryIncludingAncestors(callback.GetCallback()));
+      dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_WITH_ANCESTORS,
+                            callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
-  // MakeDirectoryIncludingAncestors aborted.
-  {
-    rv = pp::FileRef(file_system, "/dir_make_abort_1/dir_make_abort_2")
-        .MakeDirectoryIncludingAncestors(callback.GetCallback());
-  }
-  callback.WaitForAbortResult(rv);
+  dir_ref = pp::FileRef(file_system, "/dir_make_nested_dir_2/dir");
+  callback.WaitForResult(
+      dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_FILENOTFOUND, callback.result());
 
-  // MakeDirectory with nested path should fail.
-  dir_ref = pp::FileRef(file_system, "/dir_make_dir_3/dir_make_dir_4");
-  callback.WaitForResult(dir_ref.MakeDirectory(callback.GetCallback()));
+  // Ensure there is no directory on the path to test exclusive cases.
+  dir_ref = pp::FileRef(file_system, "/dir_make_dir_exclusive");
+  rv = DeleteDirectoryRecursively(&dir_ref);
+  ASSERT_TRUE(rv == PP_OK || rv == PP_ERROR_FILENOTFOUND);
+
+  // Make a directory exclusively.
+  callback.WaitForResult(
+      dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_EXCLUSIVE,
+                            callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_NE(PP_OK, callback.result());
+  ASSERT_EQ(PP_OK, callback.result());
+
+  callback.WaitForResult(
+      dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_EXCLUSIVE,
+                            callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_FILEEXISTS, callback.result());
 
   PASS();
 }
 
 std::string TestFileRef::TestQueryAndTouchFile() {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
@@ skipping 79 matching lines @@
   callback.WaitForResult(
       file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   callback.WaitForResult(file_ref.Delete(callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   pp::FileRef dir_ref(file_system, "/dir_delete");
-  callback.WaitForResult(dir_ref.MakeDirectory(callback.GetCallback()));
+  callback.WaitForResult(dir_ref.MakeDirectory(
+      PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   callback.WaitForResult(dir_ref.Delete(callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   pp::FileRef nested_dir_ref(file_system, "/dir_delete_1/dir_delete_2");
   callback.WaitForResult(
-      nested_dir_ref.MakeDirectoryIncludingAncestors(callback.GetCallback()));
+      nested_dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_WITH_ANCESTORS,
+                                   callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   // Attempt to delete the parent directory (should fail; it's non-empty).
   pp::FileRef parent_dir_ref = nested_dir_ref.GetParent();
   callback.WaitForResult(parent_dir_ref.Delete(callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
 
   pp::FileRef nonexistent_file_ref(file_system, "/nonexistent_file_delete");
@@ skipping 33 matching lines @@
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   pp::FileRef target_file_ref(file_system, "/target_file_rename");
   callback.WaitForResult(
       file_ref.Rename(target_file_ref, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   pp::FileRef dir_ref(file_system, "/dir_rename");
-  callback.WaitForResult(dir_ref.MakeDirectory(callback.GetCallback()));
+  callback.WaitForResult(dir_ref.MakeDirectory(
+      PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   pp::FileRef target_dir_ref(file_system, "/target_dir_rename");
   callback.WaitForResult(
       dir_ref.Rename(target_dir_ref, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   pp::FileRef nested_dir_ref(file_system, "/dir_rename_1/dir_rename_2");
   callback.WaitForResult(
-      nested_dir_ref.MakeDirectoryIncludingAncestors(callback.GetCallback()));
+      nested_dir_ref.MakeDirectory(PP_MAKEDIRECTORYFLAG_WITH_ANCESTORS,
+                                   callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   // Try to rename nested directory to the parent name. Should fail.
   pp::FileRef target_nested_dir_ref(file_system, "/dir_rename_1");
   callback.WaitForResult(
       nested_dir_ref.Rename(target_nested_dir_ref, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
 
@@ skipping 86 matching lines @@
 std::string TestFileRef::TestFileNameEscaping() {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   std::string test_dir_path = "/dir_for_escaping_test";
   // Create a directory in which to test.
   pp::FileRef test_dir_ref(file_system, test_dir_path.c_str());
-  callback.WaitForResult(test_dir_ref.MakeDirectory(callback.GetCallback()));
+  callback.WaitForResult(test_dir_ref.MakeDirectory(
+      PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   // Create the file with the terrible name.
   std::string full_file_path = test_dir_path + "/" + kTerribleName;
   pp::FileRef file_ref(file_system, full_file_path.c_str());
   pp::FileIO file_io(instance_);
   callback.WaitForResult(
       file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
@@ skipping 27 matching lines @@
 
   // Setup testing directories and files.
   const char* test_dir_name = "/test_get_next_file";
   const char* file_prefix = "file_";
   const char* dir_prefix = "dir_";
 
   pp::FileRef test_dir(file_system, test_dir_name);
   int32_t rv = DeleteDirectoryRecursively(&test_dir);
   ASSERT_TRUE(rv == PP_OK || rv == PP_ERROR_FILENOTFOUND);
 
-  callback.WaitForResult(test_dir.MakeDirectory(callback.GetCallback()));
+  callback.WaitForResult(test_dir.MakeDirectory(
+      PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   static const int kNumFiles = 3;
   std::set<std::string> expected_file_names;
   for (int i = 1; i <= kNumFiles; ++i) {
     std::ostringstream buffer;
     buffer << test_dir_name << '/' << file_prefix << i;
     pp::FileRef file_ref(file_system, buffer.str().c_str());
 
     pp::FileIO file_io(instance_);
     callback.WaitForResult(
         file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_EQ(PP_OK, callback.result());
 
     expected_file_names.insert(buffer.str());
   }
 
   static const int kNumDirectories = 3;
   std::set<std::string> expected_dir_names;
   for (int i = 1; i <= kNumDirectories; ++i) {
     std::ostringstream buffer;
     buffer << test_dir_name << '/' << dir_prefix << i;
     pp::FileRef file_ref(file_system, buffer.str().c_str());
 
-    callback.WaitForResult(file_ref.MakeDirectory(callback.GetCallback()));
+    callback.WaitForResult(file_ref.MakeDirectory(
+        PP_MAKEDIRECTORYFLAG_NONE, callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_EQ(PP_OK, callback.result());
 
     expected_dir_names.insert(buffer.str());
   }
 
   // Test that |ReadDirectoryEntries()| is able to fetch all
   // directories and files that we created.
   {
     TestCompletionCallbackWithOutput<DirEntries> output_callback(
@@ skipping 37 matching lines @@
   {
     rv = pp::FileRef(file_system, test_dir_name)
         .ReadDirectoryEntries(output_callback.GetCallback());
   }
   output_callback.WaitForAbortResult(rv);
   CHECK_CALLBACK_BEHAVIOR(output_callback);
 
 
   PASS();
 }