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 31 matching lines @@
   return method_name + " returned '" + returned_result + "'; '" +
       expected_result + "' expected.";
 }
 
 }  // namespace
 
 bool TestFileRef::Init() {
   return CheckTestingInterface() && EnsureRunningOverHTTP();
 }
 
+std::string TestFileRef::MakeExternalFileRef(pp::FileRef* file_ref_ext) {
+  pp::URLRequestInfo request(instance_);
+  request.SetURL("test_url_loader_data/hello.txt");
+  request.SetStreamToFile(true);
+
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);

[dmichael (off chromium), 2013/03/27 20:20:06]

callback_type()

+
+  pp::URLLoader loader(instance_);
+  int32_t rv = loader.Open(request, callback.GetCallback());
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);

[dmichael (off chromium), 2013/03/27 20:20:06]

IIRC You can use ASSERT_EQ and friends in here; they just return a string if the
assert fails.

+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return "URLLoader::Open() failed.";
+
+  pp::URLResponseInfo response_info(loader.GetResponseInfo());
+  if (response_info.is_null())
+    return "URLLoader::GetResponseInfo returned null";
+  int32_t status_code = response_info.GetStatusCode();
+  if (status_code != 200)
+    return "Unexpected HTTP status code";
+
+  *file_ref_ext = pp::FileRef(response_info.GetBodyAsFileRef());
+  if (file_ref_ext->GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
+    return "file_ref_ext expected to be external.";
+  return "";
+}
+
 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);

[dmichael (off chromium), 2013/03/27 20:20:06]

If you want, you can use RUN_CALLBACK_TEST here. That will also run the
"blocking completion callback" version of your test (the other tests in this
file don't support that yet because they're written the "old" way).

 #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 29 matching lines @@
       instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 
   pp::FileRef file_ref_pers(file_system_pers, kPersFilePath);
   if (file_ref_pers.GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALPERSISTENT)
     return "file_ref_pers expected to be persistent.";
 
   pp::FileRef file_ref_temp(file_system_temp, kTempFilePath);
   if (file_ref_temp.GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALTEMPORARY)
     return "file_ref_temp expected to be temporary.";
 
-  pp::URLRequestInfo request(instance_);
-  request.SetURL("test_url_loader_data/hello.txt");
-  request.SetStreamToFile(true);
-
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-
-  pp::URLLoader loader(instance_);
-  int32_t rv = loader.Open(request, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("URLLoader::Open force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return "URLLoader::Open() failed.";
-
-  pp::URLResponseInfo response_info(loader.GetResponseInfo());
-  if (response_info.is_null())
-    return "URLLoader::GetResponseInfo returned null";
-  int32_t status_code = response_info.GetStatusCode();
-  if (status_code != 200)
-    return "Unexpected HTTP status code";
-
-  pp::FileRef file_ref_ext(response_info.GetBodyAsFileRef());
-  if (file_ref_ext.GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
-    return "file_ref_ext expected to be external.";
-
+  pp::FileRef file_ref_ext;
+  std::string result = MakeExternalFileRef(&file_ref_ext);
+  if (!result.empty())
+    return result;
   PASS();
 }
 
 std::string TestFileRef::TestGetName() {
   pp::FileSystem file_system_pers(
       instance_, PP_FILESYSTEMTYPE_LOCALPERSISTENT);
   pp::FileSystem file_system_temp(
       instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 
   pp::FileRef file_ref_pers(file_system_pers, kPersFilePath);
@@ skipping 528 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(), 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());
+
+  pp::FileRef file_ref(file_system, "/file");
+  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());
+
+  // We touch the file so we can easily check access and modified time.
+  callback.WaitForResult(file_io.Touch(0, 0, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  TestCompletionCallbackWithOutput<PP_FileInfo> out_callback(
+      instance_->pp_instance(), callback_type());
+  out_callback.WaitForResult(file_ref.Query(
+      out_callback.GetCallbackWithOutput()));
+  CHECK_CALLBACK_BEHAVIOR(out_callback);
+  ASSERT_EQ(PP_OK, out_callback.result());
+
+  PP_FileInfo info = out_callback.output();
+  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);
+
+  // Query a file ref on an external filesystem.
+  pp::FileRef file_ref_ext;
+  std::string result = MakeExternalFileRef(&file_ref_ext);
+  if (!result.empty())
+    return result;
+  out_callback.WaitForResult(file_ref_ext.Query(
+      out_callback.GetCallbackWithOutput()));
+  CHECK_CALLBACK_BEHAVIOR(out_callback);
+  if (out_callback.result() != PP_OK)
+    return ReportError("Query() result", out_callback.result());
+  ASSERT_EQ(PP_OK, out_callback.result());
+
+  info = out_callback.output();
+  ASSERT_EQ(PP_FILETYPE_REGULAR, info.type);
+  ASSERT_EQ(PP_FILESYSTEMTYPE_EXTERNAL, info.system_type);
+
+  // We can't touch the file, so just sanity check the times.
+  ASSERT_TRUE(info.creation_time >= 0.0);
+  ASSERT_TRUE(info.last_modified_time >= 0.0);
+  ASSERT_TRUE(info.last_access_time >= 0.0);
+
+  // Query a file ref for a file that doesn't exist.
+  pp::FileRef missing_file_ref(file_system, "/missing_file");
+  out_callback.WaitForResult(missing_file_ref.Query(
+      out_callback.GetCallbackWithOutput()));
+  CHECK_CALLBACK_BEHAVIOR(out_callback);
+  ASSERT_EQ(PP_ERROR_FILENOTFOUND, out_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.GetCallback());
   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