ppapi/tests: Enable URLLoader test out-of-process and via NaCl.

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 46 matching lines @@
 
 }  // namespace
 
 TestURLLoader::TestURLLoader(TestingInstance* instance)
     : TestCase(instance),
       file_io_trusted_interface_(NULL),
       url_loader_trusted_interface_(NULL) {
 }
 
 bool TestURLLoader::Init() {
+  if (!InitTestingInterface()) {
+    instance_->AppendError("Testing interface not available");
+    return false;
+  }
+
+  const PPB_FileIO* file_io_interface = static_cast<const PPB_FileIO*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_FILEIO_INTERFACE));
+  if (testing_interface_->IsOutOfProcess() && file_io_interface) {
+    instance_->AppendError(
+        "FileIO interface is now supported by ppapi proxy: update this test!");
+  } else if (!testing_interface_->IsOutOfProcess() && !file_io_interface) {
+    instance_->AppendError("FileIO interface not available");
+  }
+
   file_io_trusted_interface_ = static_cast<const PPB_FileIOTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
-  if (!file_io_trusted_interface_) {
-    instance_->AppendError("FileIOTrusted interface not available");
-  }
   url_loader_trusted_interface_ = static_cast<const PPB_URLLoaderTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_URLLOADERTRUSTED_INTERFACE));
-  if (!url_loader_trusted_interface_) {
-    instance_->AppendError("URLLoaderTrusted interface not available");
+  if  (testing_interface_->IsOutOfProcess() && file_io_trusted_interface_) {
+    instance_->AppendError(
+        "FileIOTrusted interface is now supported by ppapi proxy: "
+        "update this test!");
+  } else if (!testing_interface_->IsOutOfProcess()) {
+    // Trusted interfaces are not supported under NaCl.
+#if !(defined __native_client__)
+    if (!file_io_trusted_interface_)
+      instance_->AppendError("FileIOTrusted interface not available");
+    if (!url_loader_trusted_interface_)
+      instance_->AppendError("URLLoaderTrusted interface not available");
+#else
+    if (file_io_trusted_interface_)
+      instance_->AppendError("FileIOTrusted interface is supported by NaCl");
+    if (url_loader_trusted_interface_)
+      instance_->AppendError("URLLoaderTrusted interface is supported by NaCl");
+#endif
   }
-  return InitTestingInterface() && EnsureRunningOverHTTP();
+  return EnsureRunningOverHTTP();
 }
 
 void TestURLLoader::RunTests(const std::string& filter) {
   RUN_TEST_FORCEASYNC_AND_NOT(BasicGET, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(BasicPOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(BasicFilePOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(BasicFileRangePOST, filter);
+  // FileIO interface is not yet supported by ppapi/proxy.
+  if (!testing_interface_->IsOutOfProcess()) {

[dmichael (off chromium), 2011/11/29 18:11:13]

Why not instead use the new way for enumerating all tests, and turn these off at
ppapi_uitest.cc, like most other tests?
I'll re-forward you the e-mail about it.

[polina, 2011/11/29 20:36:37]

These are the only two tests that are fully incompatible. All the other ones,
only have parts of the test case that's skipped. 

It is on my todo list to convert this test to your way (I have seen it). But I
was going to do this in a separate CL. I like to break up different things into
different CLs. Plus I am going on vacation tomorrow, so it would be useful to at
least get some intermediate results in.

+    RUN_TEST_FORCEASYNC_AND_NOT(BasicFilePOST, filter);
+    RUN_TEST_FORCEASYNC_AND_NOT(BasicFileRangePOST, filter);
+  }
   RUN_TEST_FORCEASYNC_AND_NOT(CompoundBodyPOST, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(EmptyDataPOST, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(BinaryDataPOST, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(CustomRequestHeader, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(FailsBogusContentLength, filter);
   // Disable portion of test which fails when the HTTP server's
   // data_dir is moved to PRODUCT_DIR.
   // http://code.google.com/p/chromium/issues/detail?id=103690
   //  RUN_TEST_FORCEASYNC_AND_NOT(SameOriginRestriction, filter);
   //  RUN_TEST_FORCEASYNC_AND_NOT(CrossOriginRequest, filter);
@@ skipping 332 matching lines @@
     return "URLResponseInfo::GetBody returned null";
 
   rv = loader.FinishStreamingToFile(callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("URLLoader::FinishStreamingToFile force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::FinishStreamingToFile", rv);
 
-  pp::FileIO reader(instance_);
-  rv = reader.Open(body, PP_FILEOPENFLAG_READ, 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);
+  // FileIO is not yet support by ppapi/proxy.

[bbudge, 2011/11/29 18:04:51]

support->supported

[polina, 2011/11/29 23:16:23]

Done.

+  if (!testing_interface_->IsOutOfProcess()) {
+    pp::FileIO reader(instance_);
+    rv = reader.Open(body, PP_FILEOPENFLAG_READ, 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 data;
-  std::string error = ReadEntireFile(&reader, &data);
-  if (!error.empty())
-    return error;
+    std::string data;
+    std::string error = ReadEntireFile(&reader, &data);
+    if (!error.empty())
+      return error;
 
-  std::string expected_body = "hello\n";
-  if (data.size() != expected_body.size())
-    return "ReadEntireFile returned unexpected content length";
-  if (data != expected_body)
-    return "ReadEntireFile returned unexpected content";
+    std::string expected_body = "hello\n";
+    if (data.size() != expected_body.size())
+      return "ReadEntireFile returned unexpected content length";
+    if (data != expected_body)
+      return "ReadEntireFile returned unexpected content";
 
-  int32_t file_descriptor = file_io_trusted_interface_->GetOSFileDescriptor(
-      reader.pp_resource());
-  if (file_descriptor < 0)
-    return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
-
+    // FileIOTrusted is not supported by NaCl or ppapi/proxy.
+    if (!testing_interface_->IsOutOfProcess()) {
+#if !(defined __native_client__)
+      int32_t file_descriptor = file_io_trusted_interface_->GetOSFileDescriptor(
+          reader.pp_resource());
+      if (file_descriptor < 0)
+        return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
+#endif
+    }
+  }
   PASS();
 }
 
 // If a cross-origin request is not specified, the load should fail only for
 // untrusted loaders.
 std::string TestURLLoader::TestSameOriginRestriction() {
   pp::URLRequestInfo request(instance_);
   std::string cross_origin_url = GetReachableCrossOriginURL();
   request.SetURL(cross_origin_url);
 
   int32_t rv;
   rv = OpenUntrusted(request);
   if (rv != PP_ERROR_NOACCESS)
     return ReportError(
         "Untrusted, unintended cross-origin request restriction", rv);
+#if !(defined __native_client__)
   rv = OpenTrusted(request);
   if (rv != PP_OK)
     return ReportError("Trusted cross-origin request", rv);
+#endif
 
   PASS();
 }
 
 // If a cross-origin request is specified, and the URL is reachable, the load
 // should succeed.
 std::string TestURLLoader::TestCrossOriginRequest() {
   pp::URLRequestInfo request(instance_);
   std::string cross_origin_url = GetReachableCrossOriginURL();
   request.SetURL(cross_origin_url);
@@ skipping 14 matching lines @@
 // Javascript URLs are only reachable by trusted loaders.
 std::string TestURLLoader::TestJavascriptURLRestriction() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("javascript:foo = bar");
 
   int32_t rv;
   rv = OpenUntrusted(request);
   if (rv != PP_ERROR_NOACCESS)
     return ReportError(
         "Untrusted Javascript URL request restriction", rv);
+#if !(defined __native_client__)
   // TODO(bbudge) Fix Javascript URLs for trusted loaders.
   // http://code.google.com/p/chromium/issues/detail?id=103062
   // rv = OpenTrusted(request);
   // if (rv == PP_ERROR_NOACCESS)
   //  return ReportError(
   //      "Trusted Javascript URL request", rv);
+#endif
 
   PASS();
 }
 
 // HTTP methods are restricted only for untrusted loaders. Forbidden
 // methods are CONNECT, TRACE, and TRACK, and any string that is not a valid
 // token (containing special characters like CR, LF).
 // http://www.w3.org/TR/XMLHttpRequest/
 std::string TestURLLoader::TestMethodRestriction() {
   ASSERT_EQ(OpenUntrusted("cOnNeCt", ""), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("tRaCk", ""), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("tRaCe", ""), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("POST\x0d\x0ax-csrf-token:\x20test1234", ""),
                           PP_ERROR_NOACCESS);
-
+#if !(defined __native_client__)
   ASSERT_EQ(OpenTrusted("cOnNeCt", ""), PP_OK);
   ASSERT_EQ(OpenTrusted("tRaCk", ""), PP_OK);
   ASSERT_EQ(OpenTrusted("tRaCe", ""), PP_OK);
+#endif
 
   PASS();
 }
 
 // HTTP methods are restricted only for untrusted loaders. Try all headers
 // that are forbidden by http://www.w3.org/TR/XMLHttpRequest/.
 std::string TestURLLoader::TestHeaderRestriction() {
   ASSERT_EQ(OpenUntrusted("GET", "Accept-Charset:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "Accept-Encoding:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "Connection:\n"), PP_ERROR_NOACCESS);
@@ skipping 11 matching lines @@
   ASSERT_EQ(OpenUntrusted("GET", "Trailer:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "Transfer-Encoding:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "Upgrade:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "User-Agent:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "Via:\n"), PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted(
       "GET", "Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA==:\n"),
           PP_ERROR_NOACCESS);
   ASSERT_EQ(OpenUntrusted("GET", "Sec-foo:\n"), PP_ERROR_NOACCESS);
 
+#if !(defined __native_client__)
   ASSERT_EQ(OpenTrusted("GET", "Accept-Charset:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Accept-Encoding:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Connection:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Content-Length:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Cookie:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Cookie2:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted(
       "GET", "Content-Transfer-Encoding:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Date:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Expect:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Host:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Keep-Alive:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Referer:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "TE:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Trailer:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Transfer-Encoding:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Upgrade:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "User-Agent:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Via:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted(
       "GET", "Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA==:\n"), PP_OK);
   ASSERT_EQ(OpenTrusted("GET", "Sec-foo:\n"), PP_OK);
+#endif
 
   PASS();
 }
 
 // Custom referrers are only allowed for trusted loaders.
 std::string TestURLLoader::TestCustomReferrer() {
   pp::URLRequestInfo request(instance_);
   request.SetCustomReferrerURL("http://www.google.com/");
 
   int32_t rv;
   rv = OpenUntrusted(request);
   if (rv != PP_ERROR_NOACCESS)
     return ReportError(
         "Untrusted request with custom referrer restriction", rv);
+#if !(defined __native_client__)
   rv = OpenTrusted(request);
   if (rv != PP_OK)
     return ReportError("Trusted request with custom referrer", rv);
-
+#endif
   PASS();
 }
 
 // Custom transfer encodings are only allowed for trusted loaders.
 std::string TestURLLoader::TestCustomContentTransferEncoding() {
   pp::URLRequestInfo request(instance_);
   request.SetCustomContentTransferEncoding("foo");
 
   int32_t rv;
   rv = OpenUntrusted(request);
   if (rv != PP_ERROR_NOACCESS)
     return ReportError(
         "Untrusted request with content-transfer-encoding restriction", rv);
+#if !(defined __native_client__)
   rv = OpenTrusted(request);
   if (rv != PP_OK)
     return ReportError("Trusted request with content-transfer-encoding", rv);
-
+#endif
   PASS();
 }
 
 // This test should cause a redirect and ensure that the loader runs
 // the callback, rather than following the redirect.
 std::string TestURLLoader::TestAuditURLRedirect() {
   pp::URLRequestInfo request(instance_);
   // This path will cause the server to return a 301 redirect.
   request.SetURL("/server-redirect?www.google.com");
   request.SetFollowRedirects(false);
@@ skipping 123 matching lines @@
   if (!error.empty())
     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).