ppapi/tests/test_url_loader.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/tests/test_url_loader.h"
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <string>
  10
  11 #include "ppapi/c/dev/ppb_testing_dev.h"
  12 #include "ppapi/c/pp_errors.h"
  13 #include "ppapi/c/ppb_file_io.h"
  14 #include "ppapi/c/ppb_url_loader.h"
  15 #include "ppapi/c/trusted/ppb_file_io_trusted.h"
  16 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
  17 #include "ppapi/cpp/dev/url_util_dev.h"
  18 #include "ppapi/cpp/file_io.h"
  19 #include "ppapi/cpp/file_ref.h"
  20 #include "ppapi/cpp/file_system.h"
  21 #include "ppapi/cpp/instance.h"
  22 #include "ppapi/cpp/module.h"
  23 #include "ppapi/cpp/url_loader.h"
  24 #include "ppapi/cpp/url_request_info.h"
  25 #include "ppapi/cpp/url_response_info.h"
  26 #include "ppapi/tests/test_utils.h"
  27 #include "ppapi/tests/testing_instance.h"
  28
  29 REGISTER_TEST_CASE(URLLoader);
  30
  31 namespace {
  32
  33 int32_t WriteEntireBuffer(PP_Instance instance,
  34                           pp::FileIO* file_io,
  35                           int32_t offset,
  36                           const std::string& data,
  37                           CallbackType callback_type) {
  38   TestCompletionCallback callback(instance, callback_type);
  39   int32_t write_offset = offset;
  40   const char* buf = data.c_str();
  41   int32_t size = data.size();
  42
  43   while (write_offset < offset + size) {
  44     callback.WaitForResult(file_io->Write(write_offset,
  45                                           &buf[write_offset - offset],
  46                                           size - write_offset + offset,
  47                                           callback.GetCallback()));
  48     if (callback.result() < 0)
  49       return callback.result();
  50     if (callback.result() == 0)
  51       return PP_ERROR_FAILED;
  52     write_offset += callback.result();
  53   }
  54
  55   return PP_OK;
  56 }
  57
  58 }  // namespace
  59
  60 TestURLLoader::TestURLLoader(TestingInstance* instance)
  61     : TestCase(instance),
  62       file_io_trusted_interface_(NULL),
  63       url_loader_trusted_interface_(NULL) {
  64 }
  65
  66 bool TestURLLoader::Init() {
  67   if (!CheckTestingInterface()) {
  68     instance_->AppendError("Testing interface not available");
  69     return false;
  70   }
  71
  72   const PPB_FileIO* file_io_interface = static_cast<const PPB_FileIO*>(
  73       pp::Module::Get()->GetBrowserInterface(PPB_FILEIO_INTERFACE));
  74   if (!file_io_interface)
  75     instance_->AppendError("FileIO interface not available");
  76
  77   file_io_trusted_interface_ = static_cast<const PPB_FileIOTrusted*>(
  78       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
  79   url_loader_trusted_interface_ = static_cast<const PPB_URLLoaderTrusted*>(
  80       pp::Module::Get()->GetBrowserInterface(PPB_URLLOADERTRUSTED_INTERFACE));
  81   if (!testing_interface_->IsOutOfProcess()) {
  82     // Trusted interfaces are not supported under NaCl.
  83 #if !(defined __native_client__)
  84     if (!file_io_trusted_interface_)
  85       instance_->AppendError("FileIOTrusted interface not available");
  86     if (!url_loader_trusted_interface_)
  87       instance_->AppendError("URLLoaderTrusted interface not available");
  88 #else
  89     if (file_io_trusted_interface_)
  90       instance_->AppendError("FileIOTrusted interface is supported by NaCl");
  91     if (url_loader_trusted_interface_)
  92       instance_->AppendError("URLLoaderTrusted interface is supported by NaCl");
  93 #endif
  94   }
  95   return EnsureRunningOverHTTP();
  96 }
  97
  98 /*
  99  * The test order is important here, as running tests out of order may cause
 100  * test timeout.
 101  *
 102  * Here is the environment:
 103  *
 104  * 1. TestServer.py only accepts one open connection at the time.
 105  * 2. HTTP socket pool keeps sockets open for several seconds after last use
 106  * (hoping that there will be another request that could reuse the connection).
 107  * 3. HTTP socket pool is separated by host/port and privacy mode (which is
 108  * based on cookies set/get permissions). So, connections to 127.0.0.1,
 109  * localhost and localhost in privacy mode cannot reuse existing socket and will
 110  * try to open another connection.
 111  *
 112  * Here is the problem:
 113  *
 114  * Original test order was repeatedly accessing 127.0.0.1, localhost and
 115  * localhost in privacy mode, causing new sockets to open and try to connect to
 116  * testserver, which they couldn't until previous connection is closed by socket
 117  * pool idle socket timeout (10 seconds).
 118  *
 119  * Because of this the test run was taking around 45 seconds, and test was
 120  * reported as 'timed out' by trybot.
 121  *
 122  * Re-ordering of tests provides more sequential access to 127.0.0.1, localhost
 123  * and localhost in privacy mode. It decreases the number of times when socket
 124  * pool doesn't have existing connection to host and has to wait, therefore
 125  * reducing total test time and ensuring its completion under 30 seconds.
 126  */
 127 void TestURLLoader::RunTests(const std::string& filter) {
 128   // These tests connect to 127.0.0.1:
 129   RUN_CALLBACK_TEST(TestURLLoader, BasicGET, filter);
 130   RUN_CALLBACK_TEST(TestURLLoader, BasicPOST, filter);
 131   RUN_CALLBACK_TEST(TestURLLoader, BasicFilePOST, filter);
 132   RUN_CALLBACK_TEST(TestURLLoader, BasicFileRangePOST, filter);
 133   RUN_CALLBACK_TEST(TestURLLoader, CompoundBodyPOST, filter);
 134   RUN_CALLBACK_TEST(TestURLLoader, EmptyDataPOST, filter);
 135   RUN_CALLBACK_TEST(TestURLLoader, BinaryDataPOST, filter);
 136   RUN_CALLBACK_TEST(TestURLLoader, CustomRequestHeader, filter);
 137   RUN_CALLBACK_TEST(TestURLLoader, FailsBogusContentLength, filter);
 138   RUN_CALLBACK_TEST(TestURLLoader, StreamToFile, filter);
 139   RUN_CALLBACK_TEST(TestURLLoader, UntrustedJavascriptURLRestriction, filter);
 140   RUN_CALLBACK_TEST(TestURLLoader, TrustedJavascriptURLRestriction, filter);
 141   RUN_CALLBACK_TEST(TestURLLoader, UntrustedHttpRequests, filter);
 142   RUN_CALLBACK_TEST(TestURLLoader, TrustedHttpRequests, filter);
 143   RUN_CALLBACK_TEST(TestURLLoader, FollowURLRedirect, filter);
 144   RUN_CALLBACK_TEST(TestURLLoader, AuditURLRedirect, filter);
 145   RUN_CALLBACK_TEST(TestURLLoader, AbortCalls, filter);
 146   RUN_CALLBACK_TEST(TestURLLoader, UntendedLoad, filter);
 147   RUN_CALLBACK_TEST(TestURLLoader, PrefetchBufferThreshold, filter);
 148   // These tests connect to localhost with privacy mode enabled:
 149   RUN_CALLBACK_TEST(TestURLLoader, UntrustedSameOriginRestriction, filter);
 150   RUN_CALLBACK_TEST(TestURLLoader, UntrustedCrossOriginRequest, filter);
 151   // These tests connect to localhost with privacy mode disabled:
 152   RUN_CALLBACK_TEST(TestURLLoader, TrustedSameOriginRestriction, filter);
 153   RUN_CALLBACK_TEST(TestURLLoader, TrustedCrossOriginRequest, filter);
 154 }
 155
 156 std::string TestURLLoader::ReadEntireFile(pp::FileIO* file_io,
 157                                           std::string* data) {
 158   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 159   char buf[256];
 160   int64_t offset = 0;
 161
 162   for (;;) {
 163     callback.WaitForResult(file_io->Read(offset, buf, sizeof(buf),
 164                            callback.GetCallback()));
 165     if (callback.result() < 0)
 166       return ReportError("FileIO::Read", callback.result());
 167     if (callback.result() == 0)
 168       break;
 169     offset += callback.result();
 170     data->append(buf, callback.result());
 171   }
 172
 173   PASS();
 174 }
 175
 176 std::string TestURLLoader::ReadEntireResponseBody(pp::URLLoader* loader,
 177                                                   std::string* body) {
 178   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 179   char buf[2];  // Small so that multiple reads are needed.
 180
 181   for (;;) {
 182     callback.WaitForResult(
 183         loader->ReadResponseBody(buf, sizeof(buf), callback.GetCallback()));
 184     if (callback.result() < 0)
 185       return ReportError("URLLoader::ReadResponseBody", callback.result());
 186     if (callback.result() == 0)
 187       break;
 188     body->append(buf, callback.result());
 189   }
 190
 191   PASS();
 192 }
 193
 194 std::string TestURLLoader::LoadAndCompareBody(
 195     const pp::URLRequestInfo& request,
 196     const std::string& expected_body) {
 197   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 198
 199   pp::URLLoader loader(instance_);
 200   callback.WaitForResult(loader.Open(request, callback.GetCallback()));
 201   CHECK_CALLBACK_BEHAVIOR(callback);
 202   ASSERT_EQ(PP_OK, callback.result());
 203
 204   pp::URLResponseInfo response_info(loader.GetResponseInfo());
 205   if (response_info.is_null())
 206     return "URLLoader::GetResponseInfo returned null";
 207   int32_t status_code = response_info.GetStatusCode();
 208   if (status_code != 200)
 209     return "Unexpected HTTP status code";
 210
 211   std::string body;
 212   std::string error = ReadEntireResponseBody(&loader, &body);
 213   if (!error.empty())
 214     return error;
 215
 216   if (body.size() != expected_body.size())
 217     return "URLLoader::ReadResponseBody returned unexpected content length";
 218   if (body != expected_body)
 219     return "URLLoader::ReadResponseBody returned unexpected content";
 220
 221   PASS();
 222 }
 223
 224 int32_t TestURLLoader::OpenFileSystem(pp::FileSystem* file_system,
 225                                       std::string* message) {
 226   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 227   callback.WaitForResult(file_system->Open(1024, callback.GetCallback()));
 228   if (callback.failed()) {
 229     message->assign(callback.errors());
 230     return callback.result();
 231   }
 232   if (callback.result() != PP_OK) {
 233     message->assign("FileSystem::Open");
 234     return callback.result();
 235   }
 236   return callback.result();
 237 }
 238
 239 int32_t TestURLLoader::PrepareFileForPost(
 240       const pp::FileRef& file_ref,
 241       const std::string& data,
 242       std::string* message) {
 243   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 244   pp::FileIO file_io(instance_);
 245   callback.WaitForResult(file_io.Open(file_ref,
 246                                       PP_FILEOPENFLAG_CREATE |
 247                                       PP_FILEOPENFLAG_TRUNCATE |
 248                                       PP_FILEOPENFLAG_WRITE,
 249                                       callback.GetCallback()));
 250   if (callback.failed()) {
 251     message->assign(callback.errors());
 252     return callback.result();
 253   }
 254   if (callback.result() != PP_OK) {
 255     message->assign("FileIO::Open failed.");
 256     return callback.result();
 257   }
 258
 259   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, data,
 260                                  callback_type());
 261   if (rv != PP_OK) {
 262     message->assign("FileIO::Write failed.");
 263     return rv;
 264   }
 265
 266   return rv;
 267 }
 268
 269 std::string TestURLLoader::GetReachableAbsoluteURL(
 270     const std::string& file_name) {
 271   // Get the absolute page URL and replace the test case file name
 272   // with the given one.
 273   pp::Var document_url(
 274       pp::PASS_REF,
 275       testing_interface_->GetDocumentURL(instance_->pp_instance(),
 276                                          NULL));
 277   std::string url(document_url.AsString());
 278   std::string old_name("test_case.html");
 279   size_t index = url.find(old_name);
 280   ASSERT_NE(index, std::string::npos);
 281   url.replace(index, old_name.length(), file_name);
 282   return url;
 283 }
 284
 285 std::string TestURLLoader::GetReachableCrossOriginURL(
 286     const std::string& file_name) {
 287   // Get an absolute URL and use it to construct a URL that will be
 288   // considered cross-origin by the CORS access control code, and yet be
 289   // reachable by the test server.
 290   std::string url = GetReachableAbsoluteURL(file_name);
 291   // Replace '127.0.0.1' with 'localhost'.
 292   std::string host("127.0.0.1");
 293   size_t index = url.find(host);
 294   ASSERT_NE(index, std::string::npos);
 295   url.replace(index, host.length(), "localhost");
 296   return url;
 297 }
 298
 299 int32_t TestURLLoader::OpenUntrusted(const std::string& method,
 300                                      const std::string& header) {
 301   pp::URLRequestInfo request(instance_);
 302   request.SetURL("/echo");
 303   request.SetMethod(method);
 304   request.SetHeaders(header);
 305
 306   return OpenUntrusted(request);
 307 }
 308
 309 int32_t TestURLLoader::OpenTrusted(const std::string& method,
 310                                    const std::string& header) {
 311   pp::URLRequestInfo request(instance_);
 312   request.SetURL("/echo");
 313   request.SetMethod(method);
 314   request.SetHeaders(header);
 315
 316   return OpenTrusted(request);
 317 }
 318
 319 int32_t TestURLLoader::OpenUntrusted(const pp::URLRequestInfo& request) {
 320   return Open(request, false);
 321 }
 322
 323 int32_t TestURLLoader::OpenTrusted(const pp::URLRequestInfo& request) {
 324   return Open(request, true);
 325 }
 326
 327 int32_t TestURLLoader::Open(const pp::URLRequestInfo& request,
 328                             bool trusted) {
 329   pp::URLLoader loader(instance_);
 330   if (trusted)
 331     url_loader_trusted_interface_->GrantUniversalAccess(loader.pp_resource());
 332   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 333   callback.WaitForResult(loader.Open(request, callback.GetCallback()));
 334   return callback.result();
 335 }
 336
 337 std::string TestURLLoader::TestBasicGET() {
 338   pp::URLRequestInfo request(instance_);
 339   request.SetURL("test_url_loader_data/hello.txt");
 340   return LoadAndCompareBody(request, "hello\n");
 341 }
 342
 343 std::string TestURLLoader::TestBasicPOST() {
 344   pp::URLRequestInfo request(instance_);
 345   request.SetURL("/echo");
 346   request.SetMethod("POST");
 347   std::string postdata("postdata");
 348   request.AppendDataToBody(postdata.data(), postdata.length());
 349   return LoadAndCompareBody(request, postdata);
 350 }
 351
 352 std::string TestURLLoader::TestBasicFilePOST() {
 353   std::string message;
 354
 355   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 356   int32_t rv = OpenFileSystem(&file_system, &message);
 357   if (rv != PP_OK)
 358     return ReportError(message.c_str(), rv);
 359
 360   pp::FileRef file_ref(file_system, "/file_post_test");
 361   std::string postdata("postdata");
 362   rv = PrepareFileForPost(file_ref, postdata, &message);
 363   if (rv != PP_OK)
 364     return ReportError(message.c_str(), rv);
 365
 366   pp::URLRequestInfo request(instance_);
 367   request.SetURL("/echo");
 368   request.SetMethod("POST");
 369   request.AppendFileToBody(file_ref, 0);
 370   return LoadAndCompareBody(request, postdata);
 371 }
 372
 373 std::string TestURLLoader::TestBasicFileRangePOST() {
 374   std::string message;
 375
 376   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 377   int32_t rv = OpenFileSystem(&file_system, &message);
 378   if (rv != PP_OK)
 379     return ReportError(message.c_str(), rv);
 380
 381   pp::FileRef file_ref(file_system, "/file_range_post_test");
 382   std::string postdata("postdatapostdata");
 383   rv = PrepareFileForPost(file_ref, postdata, &message);
 384   if (rv != PP_OK)
 385     return ReportError(message.c_str(), rv);
 386
 387   pp::URLRequestInfo request(instance_);
 388   request.SetURL("/echo");
 389   request.SetMethod("POST");
 390   request.AppendFileRangeToBody(file_ref, 4, 12, 0);
 391   return LoadAndCompareBody(request, postdata.substr(4, 12));
 392 }
 393
 394 std::string TestURLLoader::TestCompoundBodyPOST() {
 395   pp::URLRequestInfo request(instance_);
 396   request.SetURL("/echo");
 397   request.SetMethod("POST");
 398   std::string postdata1("post");
 399   request.AppendDataToBody(postdata1.data(), postdata1.length());
 400   std::string postdata2("data");
 401   request.AppendDataToBody(postdata2.data(), postdata2.length());
 402   return LoadAndCompareBody(request, postdata1 + postdata2);
 403 }
 404
 405 std::string TestURLLoader::TestEmptyDataPOST() {
 406   pp::URLRequestInfo request(instance_);
 407   request.SetURL("/echo");
 408   request.SetMethod("POST");
 409   request.AppendDataToBody("", 0);
 410   return LoadAndCompareBody(request, std::string());
 411 }
 412
 413 std::string TestURLLoader::TestBinaryDataPOST() {
 414   pp::URLRequestInfo request(instance_);
 415   request.SetURL("/echo");
 416   request.SetMethod("POST");
 417   const char postdata_chars[] =
 418       "\x00\x01\x02\x03\x04\x05postdata\xfa\xfb\xfc\xfd\xfe\xff";
 419   std::string postdata(postdata_chars,
 420                        sizeof(postdata_chars) / sizeof(postdata_chars[0]));
 421   request.AppendDataToBody(postdata.data(), postdata.length());
 422   return LoadAndCompareBody(request, postdata);
 423 }
 424
 425 std::string TestURLLoader::TestCustomRequestHeader() {
 426   pp::URLRequestInfo request(instance_);
 427   request.SetURL("/echoheader?Foo");
 428   request.SetHeaders("Foo: 1");
 429   return LoadAndCompareBody(request, "1");
 430 }
 431
 432 std::string TestURLLoader::TestFailsBogusContentLength() {
 433   pp::URLRequestInfo request(instance_);
 434   request.SetURL("/echo");
 435   request.SetMethod("POST");
 436   request.SetHeaders("Content-Length: 400");
 437   std::string postdata("postdata");
 438   request.AppendDataToBody(postdata.data(), postdata.length());
 439
 440   int32_t rv;
 441   rv = OpenUntrusted(request);
 442   if (rv != PP_ERROR_NOACCESS)
 443     return ReportError(
 444         "Untrusted request with bogus Content-Length restriction", rv);
 445
 446   PASS();
 447 }
 448
 449 std::string TestURLLoader::TestStreamToFile() {
 450   pp::URLRequestInfo request(instance_);
 451   request.SetURL("test_url_loader_data/hello.txt");
 452   request.SetStreamToFile(true);
 453
 454   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 455
 456   pp::URLLoader loader(instance_);
 457   callback.WaitForResult(loader.Open(request, callback.GetCallback()));
 458   CHECK_CALLBACK_BEHAVIOR(callback);
 459   ASSERT_EQ(PP_OK, callback.result());
 460
 461   pp::URLResponseInfo response_info(loader.GetResponseInfo());
 462   if (response_info.is_null())
 463     return "URLLoader::GetResponseInfo returned null";
 464   int32_t status_code = response_info.GetStatusCode();
 465   if (status_code != 200)
 466     return "Unexpected HTTP status code";
 467
 468   pp::FileRef body(response_info.GetBodyAsFileRef());
 469   if (body.is_null())
 470     return "URLResponseInfo::GetBody returned null";
 471
 472   callback.WaitForResult(loader.FinishStreamingToFile(callback.GetCallback()));
 473   CHECK_CALLBACK_BEHAVIOR(callback);
 474   ASSERT_EQ(PP_OK, callback.result());
 475
 476   pp::FileIO reader(instance_);
 477   callback.WaitForResult(reader.Open(body, PP_FILEOPENFLAG_READ,
 478                                      callback.GetCallback()));
 479   CHECK_CALLBACK_BEHAVIOR(callback);
 480   ASSERT_EQ(PP_OK, callback.result());
 481
 482   std::string data;
 483   std::string error = ReadEntireFile(&reader, &data);
 484   if (!error.empty())
 485     return error;
 486
 487   std::string expected_body = "hello\n";
 488   if (data.size() != expected_body.size())
 489     return "ReadEntireFile returned unexpected content length";
 490   if (data != expected_body)
 491     return "ReadEntireFile returned unexpected content";
 492
 493   // FileIOTrusted is not supported by NaCl or ppapi/proxy.
 494   if (!testing_interface_->IsOutOfProcess()) {
 495 #if !(defined __native_client__)
 496     int32_t file_descriptor = file_io_trusted_interface_->GetOSFileDescriptor(
 497         reader.pp_resource());
 498     if (file_descriptor < 0)
 499       return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
 500 #endif
 501   }
 502   PASS();
 503 }
 504
 505 // Untrusted, unintended cross-origin requests should fail.
 506 std::string TestURLLoader::TestUntrustedSameOriginRestriction() {
 507   pp::URLRequestInfo request(instance_);
 508   std::string cross_origin_url = GetReachableCrossOriginURL("test_case.html");
 509   request.SetURL(cross_origin_url);
 510
 511   int32_t rv = OpenUntrusted(request);
 512   if (rv != PP_ERROR_NOACCESS)
 513     return ReportError(
 514         "Untrusted, unintended cross-origin request restriction", rv);
 515
 516   PASS();
 517 }
 518
 519 // Trusted, unintended cross-origin requests should succeed.
 520 std::string TestURLLoader::TestTrustedSameOriginRestriction() {
 521   pp::URLRequestInfo request(instance_);
 522   std::string cross_origin_url = GetReachableCrossOriginURL("test_case.html");
 523   request.SetURL(cross_origin_url);
 524
 525   int32_t rv = OpenTrusted(request);
 526   if (rv != PP_OK)
 527     return ReportError("Trusted cross-origin request failed", rv);
 528
 529   PASS();
 530 }
 531
 532 // Untrusted, intended cross-origin requests should use CORS and succeed.
 533 std::string TestURLLoader::TestUntrustedCrossOriginRequest() {
 534   pp::URLRequestInfo request(instance_);
 535   std::string cross_origin_url = GetReachableCrossOriginURL("test_case.html");
 536   request.SetURL(cross_origin_url);
 537   request.SetAllowCrossOriginRequests(true);
 538
 539   int32_t rv = OpenUntrusted(request);
 540   if (rv != PP_OK)
 541     return ReportError(
 542         "Untrusted, intended cross-origin request failed", rv);
 543
 544   PASS();
 545 }
 546
 547 // Trusted, intended cross-origin requests should use CORS and succeed.
 548 std::string TestURLLoader::TestTrustedCrossOriginRequest() {
 549   pp::URLRequestInfo request(instance_);
 550   std::string cross_origin_url = GetReachableCrossOriginURL("test_case.html");
 551   request.SetURL(cross_origin_url);
 552   request.SetAllowCrossOriginRequests(true);
 553
 554   int32_t rv = OpenTrusted(request);
 555   if (rv != PP_OK)
 556     return ReportError("Trusted cross-origin request failed", rv);
 557
 558   PASS();
 559 }
 560
 561 // Untrusted Javascript URLs requests should fail.
 562 std::string TestURLLoader::TestUntrustedJavascriptURLRestriction() {
 563   pp::URLRequestInfo request(instance_);
 564   request.SetURL("javascript:foo = bar");
 565
 566   int32_t rv = OpenUntrusted(request);
 567   if (rv != PP_ERROR_NOACCESS)
 568     return ReportError(
 569         "Untrusted Javascript URL request restriction failed", rv);
 570
 571   PASS();
 572 }
 573
 574 // Trusted Javascript URLs requests should succeed.
 575 std::string TestURLLoader::TestTrustedJavascriptURLRestriction() {
 576   pp::URLRequestInfo request(instance_);
 577   request.SetURL("javascript:foo = bar");
 578
 579   int32_t rv = OpenTrusted(request);
 580   if (rv == PP_ERROR_NOACCESS)
 581   return ReportError(
 582       "Trusted Javascript URL request", rv);
 583
 584   PASS();
 585 }
 586
 587 std::string TestURLLoader::TestUntrustedHttpRequests() {
 588   // HTTP methods are restricted only for untrusted loaders. Forbidden
 589   // methods are CONNECT, TRACE, and TRACK, and any string that is not a
 590   // valid token (containing special characters like CR, LF).
 591   // http://www.w3.org/TR/XMLHttpRequest/
 592   {
 593     ASSERT_EQ(OpenUntrusted("cOnNeCt", std::string()), PP_ERROR_NOACCESS);
 594     ASSERT_EQ(OpenUntrusted("tRaCk", std::string()), PP_ERROR_NOACCESS);
 595     ASSERT_EQ(OpenUntrusted("tRaCe", std::string()), PP_ERROR_NOACCESS);
 596     ASSERT_EQ(
 597         OpenUntrusted("POST\x0d\x0ax-csrf-token:\x20test1234", std::string()),
 598         PP_ERROR_NOACCESS);
 599   }
 600   // HTTP methods are restricted only for untrusted loaders. Try all headers
 601   // that are forbidden by http://www.w3.org/TR/XMLHttpRequest/.
 602   {
 603     ASSERT_EQ(OpenUntrusted("GET", "Accept-Charset:\n"), PP_ERROR_NOACCESS);
 604     ASSERT_EQ(OpenUntrusted("GET", "Accept-Encoding:\n"), PP_ERROR_NOACCESS);
 605     ASSERT_EQ(OpenUntrusted("GET", "Connection:\n"), PP_ERROR_NOACCESS);
 606     ASSERT_EQ(OpenUntrusted("GET", "Content-Length:\n"), PP_ERROR_NOACCESS);
 607     ASSERT_EQ(OpenUntrusted("GET", "Cookie:\n"), PP_ERROR_NOACCESS);
 608     ASSERT_EQ(OpenUntrusted("GET", "Cookie2:\n"), PP_ERROR_NOACCESS);
 609     ASSERT_EQ(OpenUntrusted(
 610         "GET", "Content-Transfer-Encoding:\n"), PP_ERROR_NOACCESS);
 611     ASSERT_EQ(OpenUntrusted("GET", "Date:\n"), PP_ERROR_NOACCESS);
 612     ASSERT_EQ(OpenUntrusted("GET", "Expect:\n"), PP_ERROR_NOACCESS);
 613     ASSERT_EQ(OpenUntrusted("GET", "Host:\n"), PP_ERROR_NOACCESS);
 614     ASSERT_EQ(OpenUntrusted("GET", "Keep-Alive:\n"), PP_ERROR_NOACCESS);
 615     ASSERT_EQ(OpenUntrusted("GET", "Referer:\n"), PP_ERROR_NOACCESS);
 616     ASSERT_EQ(OpenUntrusted("GET", "TE:\n"), PP_ERROR_NOACCESS);
 617     ASSERT_EQ(OpenUntrusted("GET", "Trailer:\n"), PP_ERROR_NOACCESS);
 618     ASSERT_EQ(OpenUntrusted(
 619         "GET", "Transfer-Encoding:\n"), PP_ERROR_NOACCESS);
 620     ASSERT_EQ(OpenUntrusted("GET", "Upgrade:\n"), PP_ERROR_NOACCESS);
 621     ASSERT_EQ(OpenUntrusted("GET", "User-Agent:\n"), PP_ERROR_NOACCESS);
 622     ASSERT_EQ(OpenUntrusted("GET", "Via:\n"), PP_ERROR_NOACCESS);
 623     ASSERT_EQ(OpenUntrusted(
 624         "GET", "Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA==:\n"),
 625             PP_ERROR_NOACCESS);
 626     ASSERT_EQ(OpenUntrusted("GET", "Sec-foo:\n"), PP_ERROR_NOACCESS);
 627   }
 628   // Untrusted requests with custom referrer should fail.
 629   {
 630     pp::URLRequestInfo request(instance_);
 631     request.SetCustomReferrerURL("http://www.google.com/");
 632
 633     int32_t rv = OpenUntrusted(request);
 634     if (rv != PP_ERROR_NOACCESS)
 635       return ReportError(
 636           "Untrusted request with custom referrer restriction", rv);
 637   }
 638   // Untrusted requests with custom transfer encodings should fail.
 639   {
 640     pp::URLRequestInfo request(instance_);
 641     request.SetCustomContentTransferEncoding("foo");
 642
 643     int32_t rv = OpenUntrusted(request);
 644     if (rv != PP_ERROR_NOACCESS)
 645       return ReportError(
 646           "Untrusted request with content-transfer-encoding restriction", rv);
 647   }
 648
 649   PASS();
 650 }
 651
 652 std::string TestURLLoader::TestTrustedHttpRequests() {
 653   // Trusted requests can use restricted methods.
 654   {
 655     ASSERT_EQ(OpenTrusted("cOnNeCt", std::string()), PP_OK);
 656     ASSERT_EQ(OpenTrusted("tRaCk", std::string()), PP_OK);
 657     ASSERT_EQ(OpenTrusted("tRaCe", std::string()), PP_OK);
 658   }
 659   // Trusted requests can use restricted headers.
 660   {
 661     ASSERT_EQ(OpenTrusted("GET", "Accept-Charset:\n"), PP_OK);
 662     ASSERT_EQ(OpenTrusted("GET", "Accept-Encoding:\n"), PP_OK);
 663     ASSERT_EQ(OpenTrusted("GET", "Connection:\n"), PP_OK);
 664     ASSERT_EQ(OpenTrusted("GET", "Content-Length:\n"), PP_OK);
 665     ASSERT_EQ(OpenTrusted("GET", "Cookie:\n"), PP_OK);
 666     ASSERT_EQ(OpenTrusted("GET", "Cookie2:\n"), PP_OK);
 667     ASSERT_EQ(OpenTrusted(
 668         "GET", "Content-Transfer-Encoding:\n"), PP_OK);
 669     ASSERT_EQ(OpenTrusted("GET", "Date:\n"), PP_OK);
 670     ASSERT_EQ(OpenTrusted("GET", "Expect:\n"), PP_OK);
 671     ASSERT_EQ(OpenTrusted("GET", "Host:\n"), PP_OK);
 672     ASSERT_EQ(OpenTrusted("GET", "Keep-Alive:\n"), PP_OK);
 673     ASSERT_EQ(OpenTrusted("GET", "Referer:\n"), PP_OK);
 674     ASSERT_EQ(OpenTrusted("GET", "TE:\n"), PP_OK);
 675     ASSERT_EQ(OpenTrusted("GET", "Trailer:\n"), PP_OK);
 676     ASSERT_EQ(OpenTrusted("GET", "Transfer-Encoding:\n"), PP_OK);
 677     ASSERT_EQ(OpenTrusted("GET", "Upgrade:\n"), PP_OK);
 678     ASSERT_EQ(OpenTrusted("GET", "User-Agent:\n"), PP_OK);
 679     ASSERT_EQ(OpenTrusted("GET", "Via:\n"), PP_OK);
 680     ASSERT_EQ(OpenTrusted(
 681         "GET", "Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA==:\n"), PP_OK);
 682     ASSERT_EQ(OpenTrusted("GET", "Sec-foo:\n"), PP_OK);
 683   }
 684   // Trusted requests with custom referrer should succeed.
 685   {
 686     pp::URLRequestInfo request(instance_);
 687     request.SetCustomReferrerURL("http://www.google.com/");
 688
 689     int32_t rv = OpenTrusted(request);
 690     if (rv != PP_OK)
 691       return ReportError("Trusted request with custom referrer", rv);
 692   }
 693   // Trusted requests with custom transfer encodings should succeed.
 694   {
 695     pp::URLRequestInfo request(instance_);
 696     request.SetCustomContentTransferEncoding("foo");
 697
 698     int32_t rv = OpenTrusted(request);
 699     if (rv != PP_OK)
 700       return ReportError(
 701           "Trusted request with content-transfer-encoding failed", rv);
 702   }
 703
 704   PASS();
 705 }
 706
 707 // This test should cause a redirect and ensure that the loader follows it.
 708 std::string TestURLLoader::TestFollowURLRedirect() {
 709   pp::URLRequestInfo request(instance_);
 710   // This prefix causes the test server to return a 301 redirect.
 711   std::string redirect_prefix("/server-redirect?");
 712   // We need an absolute path for the redirect to actually work.
 713   std::string redirect_url =
 714       GetReachableAbsoluteURL("test_url_loader_data/hello.txt");
 715   request.SetURL(redirect_prefix.append(redirect_url));
 716   return LoadAndCompareBody(request, "hello\n");
 717 }
 718
 719 // This test should cause a redirect and ensure that the loader runs
 720 // the callback, rather than following the redirect.
 721 std::string TestURLLoader::TestAuditURLRedirect() {
 722   pp::URLRequestInfo request(instance_);
 723   // This path will cause the server to return a 301 redirect.
 724   // This prefix causes the test server to return a 301 redirect.
 725   std::string redirect_prefix("/server-redirect?");
 726   // We need an absolute path for the redirect to actually work.
 727   std::string redirect_url =
 728       GetReachableAbsoluteURL("test_url_loader_data/hello.txt");
 729   request.SetURL(redirect_prefix.append(redirect_url));
 730   request.SetFollowRedirects(false);
 731
 732   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 733
 734   pp::URLLoader loader(instance_);
 735   callback.WaitForResult(loader.Open(request, callback.GetCallback()));
 736   CHECK_CALLBACK_BEHAVIOR(callback);
 737   ASSERT_EQ(PP_OK, callback.result());
 738
 739   // Checks that the response indicates a redirect, and that the URL
 740   // is correct.
 741   pp::URLResponseInfo response_info(loader.GetResponseInfo());
 742   if (response_info.is_null())
 743     return "URLLoader::GetResponseInfo returned null";
 744   int32_t status_code = response_info.GetStatusCode();
 745   if (status_code != 301)
 746     return "Response status should be 301";
 747
 748   // Test that the paused loader can be resumed.
 749   callback.WaitForResult(loader.FollowRedirect(callback.GetCallback()));
 750   CHECK_CALLBACK_BEHAVIOR(callback);
 751   ASSERT_EQ(PP_OK, callback.result());
 752   std::string body;
 753   std::string error = ReadEntireResponseBody(&loader, &body);
 754   if (!error.empty())
 755     return error;
 756
 757   if (body != "hello\n")
 758     return "URLLoader::FollowRedirect failed";
 759
 760   PASS();
 761 }
 762
 763 std::string TestURLLoader::TestAbortCalls() {
 764   pp::URLRequestInfo request(instance_);
 765   request.SetURL("test_url_loader_data/hello.txt");
 766
 767   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 768   int32_t rv;
 769
 770   // Abort |Open()|.
 771   {
 772     rv = pp::URLLoader(instance_).Open(request, callback.GetCallback());
 773   }
 774   callback.WaitForAbortResult(rv);
 775   CHECK_CALLBACK_BEHAVIOR(callback);
 776
 777   // Abort |ReadResponseBody()|.
 778   {
 779     char buf[2] = { 0 };
 780     {
 781       pp::URLLoader loader(instance_);
 782       callback.WaitForResult(loader.Open(request, callback.GetCallback()));
 783       CHECK_CALLBACK_BEHAVIOR(callback);
 784       ASSERT_EQ(PP_OK, callback.result());
 785
 786       rv = loader.ReadResponseBody(buf, sizeof(buf), callback.GetCallback());
 787     }  // Destroy |loader|.
 788     callback.WaitForAbortResult(rv);
 789     CHECK_CALLBACK_BEHAVIOR(callback);
 790     if (rv == PP_OK_COMPLETIONPENDING) {
 791       if (buf[0] || buf[1]) {
 792         return "URLLoader::ReadResponseBody wrote data after resource "
 793                "destruction.";
 794       }
 795     }
 796   }
 797
 798   // TODO(viettrungluu): More abort tests (but add basic tests first).
 799   // Also test that Close() aborts properly. crbug.com/69457
 800
 801   PASS();
 802 }
 803
 804 std::string TestURLLoader::TestUntendedLoad() {
 805   pp::URLRequestInfo request(instance_);
 806   request.SetURL("test_url_loader_data/hello.txt");
 807   request.SetRecordDownloadProgress(true);
 808   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 809
 810   pp::URLLoader loader(instance_);
 811   callback.WaitForResult(loader.Open(request, callback.GetCallback()));
 812   CHECK_CALLBACK_BEHAVIOR(callback);
 813   ASSERT_EQ(PP_OK, callback.result());
 814
 815   // We received the response callback. Yield until the network code has called
 816   // the loader's didReceiveData and didFinishLoading methods before we give it
 817   // another callback function, to make sure the loader works with no callback.
 818   int64_t bytes_received = 0;
 819   int64_t total_bytes_to_be_received = 0;
 820   while (true) {
 821     loader.GetDownloadProgress(&bytes_received, &total_bytes_to_be_received);
 822     if (total_bytes_to_be_received <= 0)
 823       return ReportError("URLLoader::GetDownloadProgress total size",
 824           total_bytes_to_be_received);
 825     if (bytes_received == total_bytes_to_be_received)
 826       break;
 827     // Yield if we're on the main thread, so that URLLoader can receive more
 828     // data.
 829     if (pp::Module::Get()->core()->IsMainThread()) {
 830       NestedEvent event(instance_->pp_instance());
 831       event.PostSignal(10);
 832       event.Wait();
 833     }
 834   }
 835   // The loader should now have the data and have finished successfully.
 836   std::string body;
 837   std::string error = ReadEntireResponseBody(&loader, &body);
 838   if (!error.empty())
 839     return error;
 840   if (body != "hello\n")
 841     return ReportError("Couldn't read data", callback.result());
 842
 843   PASS();
 844 }
 845
 846 int32_t TestURLLoader::OpenWithPrefetchBufferThreshold(int32_t lower,
 847                                                        int32_t upper) {
 848   pp::URLRequestInfo request(instance_);
 849   request.SetURL("test_url_loader_data/hello.txt");
 850   request.SetPrefetchBufferLowerThreshold(lower);
 851   request.SetPrefetchBufferUpperThreshold(upper);
 852
 853   return OpenUntrusted(request);
 854 }
 855
 856 std::string TestURLLoader::TestPrefetchBufferThreshold() {
 857   int32_t rv = OpenWithPrefetchBufferThreshold(-1, 1);
 858   if (rv != PP_ERROR_FAILED) {
 859     return ReportError("The prefetch limits contained a negative value but "
 860                        "the URLLoader did not fail.", rv);
 861   }
 862
 863   rv = OpenWithPrefetchBufferThreshold(0, 1);
 864   if (rv != PP_OK) {
 865     return ReportError("The prefetch buffer limits were legal values but "
 866                        "the URLLoader failed.", rv);
 867   }
 868
 869   rv = OpenWithPrefetchBufferThreshold(1000, 1);
 870   if (rv != PP_ERROR_FAILED) {
 871     return ReportError("The lower buffer value was higher than the upper but "
 872                        "the URLLoader did not fail.", rv);
 873   }
 874
 875   PASS();
 876 }
 877
 878 // TODO(viettrungluu): Add tests for  Get{Upload,Download}Progress, Close
 879 // (including abort tests if applicable).