PPB_URLRequestInfo::AppendFileToBody using sync ipc

ppapi/tests/test_url_loader.cc

Index: ppapi/tests/test_url_loader.cc
diff --git a/ppapi/tests/test_url_loader.cc b/ppapi/tests/test_url_loader.cc
index fd0cfd51175880d037c835768a9bf655e3d23b95..116750ee8293cc69935a58ded528fee6928017f1 100644
--- a/ppapi/tests/test_url_loader.cc
+++ b/ppapi/tests/test_url_loader.cc
@@ -45,6 +45,8 @@ bool TestURLLoader::Init() {
 void TestURLLoader::RunTest() {
   RUN_TEST_FORCEASYNC_AND_NOT(BasicGET);
   RUN_TEST_FORCEASYNC_AND_NOT(BasicPOST);
+  RUN_TEST_FORCEASYNC_AND_NOT(BasicFilePOST);
+  RUN_TEST_FORCEASYNC_AND_NOT(BasicFileRangePOST);
   RUN_TEST_FORCEASYNC_AND_NOT(CompoundBodyPOST);
   RUN_TEST_FORCEASYNC_AND_NOT(EmptyDataPOST);
   RUN_TEST_FORCEASYNC_AND_NOT(BinaryDataPOST);
@@ -82,6 +84,30 @@ std::string TestURLLoader::ReadEntireFile(pp::FileIO* file_io,
   PASS();
 }
 
+int32_t WriteEntireBuffer(PP_Instance instance,

[michaeln, 2011/08/17 00:16:24]

should this be static or in an anon namespace or maybe another private method?

[kinuko, 2011/08/17 07:55:28]

Put this in an anon namespace and placed at top over other TestURLLoader
methods.

+                          pp::FileIO* file_io,
+                          int32_t offset,
+                          const std::string& data) {
+  TestCompletionCallback callback(instance);
+  int32_t write_offset = offset;
+  const char* buf = data.c_str();
+  int32_t size = data.size();
+
+  while (write_offset < offset + size) {
+    int32_t rv = file_io->Write(write_offset, &buf[write_offset - offset],
+                                size - write_offset + offset, callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv < 0)
+      return rv;
+    if (rv == 0)
+      return PP_ERROR_FAILED;
+    write_offset += rv;
+  }
+
+  return PP_OK;
+}
+
 std::string TestURLLoader::ReadEntireResponseBody(pp::URLLoader* loader,
                                                   std::string* body) {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
@@ -152,6 +178,82 @@ std::string TestURLLoader::TestBasicPOST() {
   return LoadAndCompareBody(request, postdata);
 }
 
+std::string TestURLLoader::TestBasicFilePOST() {
+  TestCompletionCallback callback(instance_->pp_instance(), false);
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);

[darin (slow to review), 2011/08/16 17:28:36]

it looks like TestBasicFilePOST and TestBasicFileRangePOST share a ton of code. 
there should probably be a helper function for the shared code.

[ericu, 2011/08/17 01:14:31]

+1

[kinuko, 2011/08/17 07:55:28]

Done.

+  pp::FileRef file_ref(file_system, "/file_post_test");
+  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)
+    return ReportError("FileSystem::Open", rv);
+
+  pp::FileIO file_io(instance_);
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
+
+  std::string postdata("postdata");
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, postdata);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
+
+  pp::URLRequestInfo request(instance_);
+  request.SetURL("/echo");
+  request.SetMethod("POST");
+  request.AppendFileToBody(file_ref, 0);
+  return LoadAndCompareBody(request, postdata);
+}
+
+std::string TestURLLoader::TestBasicFileRangePOST() {
+  TestCompletionCallback callback(instance_->pp_instance(), false);
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_post_test");
+  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)
+    return ReportError("FileSystem::Open", rv);
+
+  pp::FileIO file_io(instance_);
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
+
+  std::string postdata("postdatapostdata");
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, postdata);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
+
+  pp::URLRequestInfo request(instance_);
+  request.SetURL("/echo");
+  request.SetMethod("POST");
+  request.AppendFileRangeToBody(file_ref, 4, 12, 0);
+  return LoadAndCompareBody(request, postdata.substr(4, 12));
+}
+
 std::string TestURLLoader::TestCompoundBodyPOST() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("/echo");