Add Query() support to FileRef

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 <vector>
 
 #include "ppapi/c/pp_errors.h"
@@ skipping 41 matching lines @@
 void TestFileRef::RunTests(const std::string& filter) {
   RUN_TEST_FORCEASYNC_AND_NOT(Create, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(GetFileSystemType, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(GetName, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(GetPath, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(GetParent, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(MakeDirectory, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(QueryAndTouchFile, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(DeleteFileAndDirectory, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(RenameFileAndDirectory, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(Query, filter);
 #ifndef PPAPI_OS_NACL  // NaCl can't run this test yet.
   RUN_TEST_FORCEASYNC_AND_NOT(FileNameEscaping, filter);
 #endif
 }
 
 std::string TestFileRef::TestCreate() {
   std::vector<std::string> invalid_paths;
   invalid_paths.push_back("invalid_path");  // no '/' at the first character
   invalid_paths.push_back("");  // empty path
   // The following are directory traversal checks
@@ skipping 600 matching lines @@
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Rename not aborted.";
   } else if (rv != PP_OK) {
     return ReportError("FileSystem::Rename", rv);
   }
 
   PASS();
 }
 
+std::string TestFileRef::TestQuery() {
+  TestCompletionCallback callback(instance_->pp_instance());
+
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  callback.WaitForResult(file_system.Open(1024, callback));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  pp::FileRef file_ref(file_system, "/file");
+  pp::FileIO file_io(instance_);
+  callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE,
+                                      callback));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  // We touch the file so we can easily check access and modified time.
+  callback.WaitForResult(file_io.Touch(0, 0, callback));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  PP_FileInfo info;
+  callback.WaitForResult(file_ref.Query(&info, callback));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  ASSERT_EQ(0, info.size);
+  ASSERT_EQ(PP_FILETYPE_REGULAR, info.type);
+  ASSERT_EQ(PP_FILESYSTEMTYPE_LOCALTEMPORARY, info.system_type);
+  ASSERT_DOUBLE_EQ(0.0, info.last_access_time);
+  ASSERT_DOUBLE_EQ(0.0, info.last_modified_time);
+
+  pp::FileRef missing_file_ref(file_system, "/missing_file");
+  callback.WaitForResult(missing_file_ref.Query(&info, callback));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_FILENOTFOUND, callback.result());
+
+  PASS();
+}
+
 #ifndef PPAPI_OS_NACL
 std::string TestFileRef::TestFileNameEscaping() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ skipping 39 matching lines @@
       return "Entry was not found.";
     if (entries.size() != 1)
       return "Directory had too many entries.";
     if (entries.front().file_ref().GetName().AsString() != kTerribleName)
       return "Entry name did not match.";
   }
 
   PASS();
 }
 #endif