PPB_URLRequestInfo::AppendFileToBody using sync ipc

ppapi/tests/test_url_loader.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_url_loader.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <string>
 
@@ skipping 27 matching lines @@
       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
   if (!file_io_trusted_interface_) {
     instance_->AppendError("FileIOTrusted interface not available");
   }
   return InitTestingInterface() && EnsureRunningOverHTTP();
 }
 
 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);
   RUN_TEST_FORCEASYNC_AND_NOT(CustomRequestHeader);
   RUN_TEST_FORCEASYNC_AND_NOT(IgnoresBogusContentLength);
   RUN_TEST_FORCEASYNC_AND_NOT(SameOriginRestriction);
   RUN_TEST_FORCEASYNC_AND_NOT(JavascriptURLRestriction);
   RUN_TEST_FORCEASYNC_AND_NOT(CrossOriginRequest);
   RUN_TEST_FORCEASYNC_AND_NOT(StreamToFile);
   RUN_TEST_FORCEASYNC_AND_NOT(AuditURLRedirect);
@@ skipping 17 matching lines @@
       return ReportError("FileIO::Read", rv);
     if (rv == 0)
       break;
     offset += rv;
     data->append(buf, rv);
   }
 
   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_);
   char buf[2];  // Small so that multiple reads are needed.
 
   for (;;) {
     int32_t rv = loader->ReadResponseBody(buf, sizeof(buf), callback);
     if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
       return ReportError("URLLoader::ReadResponseBody force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
@@ skipping 50 matching lines @@
 
 std::string TestURLLoader::TestBasicPOST() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("/echo");
   request.SetMethod("POST");
   std::string postdata("postdata");
   request.AppendDataToBody(postdata.data(), postdata.length());
   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");
   request.SetMethod("POST");
   std::string postdata1("post");
   request.AppendDataToBody(postdata1.data(), postdata1.length());
   std::string postdata2("data");
   request.AppendDataToBody(postdata2.data(), postdata2.length());
   return LoadAndCompareBody(request, postdata1 + postdata2);
 }
@@ skipping 316 matching lines @@
     return error;
   if (body != "hello\n")
     return ReportError("Couldn't read data", rv);
 
   PASS();
 }
 
 // TODO(viettrungluu): Add tests for FollowRedirect,
 // Get{Upload,Download}Progress, Close (including abort tests if applicable).
 // TODO(darin): Add a test for GrantUniversalAccess.