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()) {
+    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 supported by ppapi/proxy.
+  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).