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 // Tests PPB_URLRequestInfo interface. 6 7 #include "ppapi/tests/test_url_request.h" 8 9 #include <string.h> 10 #include <string> 11 12 #include "ppapi/c/ppb_file_io.h" 13 #include "ppapi/cpp/completion_callback.h" 14 #include "ppapi/cpp/file_io.h" 15 #include "ppapi/cpp/file_ref.h" 16 #include "ppapi/cpp/file_system.h" 17 #include "ppapi/cpp/instance.h" 18 #include "ppapi/cpp/var.h" 19 #include "ppapi/tests/test_utils.h" 20 #include "ppapi/tests/testing_instance.h" 21 22 REGISTER_TEST_CASE(URLRequest); 23 24 namespace { 25 // TODO(polina): move these to test_case.h/cc since other NaCl tests use them? 26 27 const PP_Resource kInvalidResource = 0; 28 const PP_Instance kInvalidInstance = 0; 29 30 // These should not exist. 31 // The bottom 2 bits are used to differentiate between different id types. 32 // 00 - module, 01 - instance, 10 - resource, 11 - var. 33 const PP_Instance kNotAnInstance = 0xFFFFF0; 34 const PP_Resource kNotAResource = 0xAAAAA0; 35 } 36 37 TestURLRequest::TestURLRequest(TestingInstance* instance) 38 : TestCase(instance), 39 ppb_url_request_interface_(NULL), 40 ppb_url_loader_interface_(NULL), 41 ppb_url_response_interface_(NULL), 42 ppb_core_interface_(NULL), 43 ppb_var_interface_(NULL) { 44 } 45 46 bool TestURLRequest::Init() { 47 ppb_url_request_interface_ = static_cast<const PPB_URLRequestInfo*>( 48 pp::Module::Get()->GetBrowserInterface(PPB_URLREQUESTINFO_INTERFACE)); 49 ppb_url_loader_interface_ = static_cast<const PPB_URLLoader*>( 50 pp::Module::Get()->GetBrowserInterface(PPB_URLLOADER_INTERFACE)); 51 ppb_url_response_interface_ = static_cast<const PPB_URLResponseInfo*>( 52 pp::Module::Get()->GetBrowserInterface(PPB_URLRESPONSEINFO_INTERFACE)); 53 ppb_core_interface_ = static_cast<const PPB_Core*>( 54 pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE)); 55 ppb_var_interface_ = static_cast<const PPB_Var*>( 56 pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE)); 57 if (!ppb_url_request_interface_) 58 instance_->AppendError("PPB_URLRequestInfo interface not available"); 59 if (!ppb_url_response_interface_) 60 instance_->AppendError("PPB_URLResponseInfo interface not available"); 61 if (!ppb_core_interface_) 62 instance_->AppendError("PPB_Core interface not available"); 63 if (!ppb_var_interface_) 64 instance_->AppendError("PPB_Var interface not available"); 65 if (!ppb_url_loader_interface_) { 66 instance_->AppendError("PPB_URLLoader interface not available"); 67 } 68 return EnsureRunningOverHTTP(); 69 } 70 71 void TestURLRequest::RunTests(const std::string& filter) { 72 RUN_TEST(CreateAndIsURLRequestInfo, filter); 73 RUN_TEST(SetProperty, filter); 74 RUN_TEST(AppendDataToBody, filter); 75 RUN_TEST(AppendFileToBody, filter); 76 RUN_TEST(Stress, filter); 77 } 78 79 PP_Var TestURLRequest::PP_MakeString(const char* s) { 80 return ppb_var_interface_->VarFromUtf8(s, strlen(s)); 81 } 82 83 // Tests 84 // PP_Resource Create(PP_Instance instance) 85 // PP_Bool IsURLRequestInfo(PP_Resource resource) 86 std::string TestURLRequest::TestCreateAndIsURLRequestInfo() { 87 // Create: Invalid / non-existent instance -> invalid resource. 88 ASSERT_EQ(ppb_url_request_interface_->Create(kInvalidInstance), 89 kInvalidResource); 90 ASSERT_EQ(ppb_url_request_interface_->Create(kNotAnInstance), 91 kInvalidResource); 92 93 // Create: Valid instance -> valid resource. 94 PP_Resource url_request = ppb_url_request_interface_->Create( 95 instance_->pp_instance()); 96 ASSERT_NE(url_request, kInvalidResource); 97 98 // IsURLRequestInfo: 99 // Invalid / non-existent / non-URLRequestInfo resource -> false. 100 ASSERT_NE(PP_TRUE, 101 ppb_url_request_interface_->IsURLRequestInfo(kInvalidResource)); 102 ASSERT_NE(PP_TRUE, 103 ppb_url_request_interface_->IsURLRequestInfo(kNotAResource)); 104 105 PP_Resource url_loader = 106 ppb_url_loader_interface_->Create(instance_->pp_instance()); 107 ASSERT_NE(kInvalidResource, url_loader); 108 109 ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_loader)); 110 ppb_url_loader_interface_->Close(url_loader); 111 ppb_core_interface_->ReleaseResource(url_loader); 112 113 // IsURLRequestInfo: Current URLRequestInfo resource -> true. 114 std::string error; 115 if (PP_FALSE == ppb_url_request_interface_->IsURLRequestInfo(url_request)) 116 error = "IsURLRequestInfo() failed with a current URLRequestInfo resource"; 117 118 // IsURLRequestInfo: Released URLRequestInfo resource -> false. 119 ppb_core_interface_->ReleaseResource(url_request); 120 ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_request)); 121 122 return error; // == PASS() if empty. 123 } 124 125 // Tests 126 // PP_Bool SetProperty(PP_Resource request, 127 // PP_URLRequestProperty property, 128 // struct PP_Var value); 129 std::string TestURLRequest::TestSetProperty() { 130 struct PropertyTestData { 131 PropertyTestData(PP_URLRequestProperty prop, 132 const std::string& name, 133 PP_Var value, PP_Bool expected) : 134 property(prop), property_name(name), 135 var(value), expected_value(expected) { 136 // var has ref count of 1 on creation. 137 } 138 PP_URLRequestProperty property; 139 std::string property_name; 140 PP_Var var; // Instance owner is responsible for releasing this var. 141 PP_Bool expected_value; 142 }; 143 144 // All bool properties should accept PP_TRUE and PP_FALSE, while rejecting 145 // all other variable types. 146 #define TEST_BOOL(_name) \ 147 PropertyTestData(ID_STR(_name), PP_MakeBool(PP_TRUE), PP_TRUE), \ 148 PropertyTestData(ID_STR(_name), PP_MakeBool(PP_FALSE), PP_TRUE), \ 149 PropertyTestData(ID_STR(_name), PP_MakeUndefined(), PP_FALSE), \ 150 PropertyTestData(ID_STR(_name), PP_MakeNull(), PP_FALSE), \ 151 PropertyTestData(ID_STR(_name), PP_MakeInt32(0), PP_FALSE), \ 152 PropertyTestData(ID_STR(_name), PP_MakeDouble(0.0), PP_FALSE) 153 154 // These property types are always invalid for string properties. 155 #define TEST_STRING_INVALID(_name) \ 156 PropertyTestData(ID_STR(_name), PP_MakeNull(), PP_FALSE), \ 157 PropertyTestData(ID_STR(_name), PP_MakeBool(PP_FALSE), PP_FALSE), \ 158 PropertyTestData(ID_STR(_name), PP_MakeInt32(0), PP_FALSE), \ 159 PropertyTestData(ID_STR(_name), PP_MakeDouble(0.0), PP_FALSE) 160 161 #define TEST_INT_INVALID(_name) \ 162 PropertyTestData(ID_STR(_name), PP_MakeUndefined(), PP_FALSE), \ 163 PropertyTestData(ID_STR(_name), PP_MakeNull(), PP_FALSE), \ 164 PropertyTestData(ID_STR(_name), PP_MakeBool(PP_FALSE), PP_FALSE), \ 165 PropertyTestData(ID_STR(_name), PP_MakeString("notint"), PP_FALSE), \ 166 PropertyTestData(ID_STR(_name), PP_MakeDouble(0.0), PP_FALSE) 167 168 // SetProperty accepts plenty of invalid values (malformed urls, negative 169 // thresholds, etc). Error checking is delayed until request opening (aka url 170 // loading). 171 #define ID_STR(arg) arg, #arg 172 PropertyTestData test_data[] = { 173 TEST_BOOL(PP_URLREQUESTPROPERTY_STREAMTOFILE), 174 TEST_BOOL(PP_URLREQUESTPROPERTY_FOLLOWREDIRECTS), 175 TEST_BOOL(PP_URLREQUESTPROPERTY_RECORDDOWNLOADPROGRESS), 176 TEST_BOOL(PP_URLREQUESTPROPERTY_RECORDUPLOADPROGRESS), 177 TEST_BOOL(PP_URLREQUESTPROPERTY_ALLOWCROSSORIGINREQUESTS), 178 TEST_BOOL(PP_URLREQUESTPROPERTY_ALLOWCREDENTIALS), 179 TEST_STRING_INVALID(PP_URLREQUESTPROPERTY_URL), 180 TEST_STRING_INVALID(PP_URLREQUESTPROPERTY_METHOD), 181 TEST_STRING_INVALID(PP_URLREQUESTPROPERTY_HEADERS), 182 TEST_STRING_INVALID(PP_URLREQUESTPROPERTY_CUSTOMREFERRERURL), 183 TEST_STRING_INVALID(PP_URLREQUESTPROPERTY_CUSTOMCONTENTTRANSFERENCODING), 184 TEST_STRING_INVALID(PP_URLREQUESTPROPERTY_CUSTOMUSERAGENT), 185 TEST_INT_INVALID(PP_URLREQUESTPROPERTY_PREFETCHBUFFERUPPERTHRESHOLD), 186 TEST_INT_INVALID(PP_URLREQUESTPROPERTY_PREFETCHBUFFERLOWERTHRESHOLD), 187 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_URL), 188 PP_MakeString("http://www.google.com"), PP_TRUE), 189 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_URL), 190 PP_MakeString("foo.jpg"), PP_TRUE), 191 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_METHOD), 192 PP_MakeString("GET"), PP_TRUE), 193 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_METHOD), 194 PP_MakeString("POST"), PP_TRUE), 195 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_HEADERS), 196 PP_MakeString("Accept: text/plain"), PP_TRUE), 197 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_HEADERS), 198 PP_MakeString(""), PP_TRUE), 199 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_CUSTOMREFERRERURL), 200 PP_MakeString("http://www.google.com"), PP_TRUE), 201 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_CUSTOMREFERRERURL), 202 PP_MakeString(""), PP_TRUE), 203 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_CUSTOMREFERRERURL), 204 PP_MakeUndefined(), PP_TRUE), 205 PropertyTestData( 206 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMCONTENTTRANSFERENCODING), 207 PP_MakeString("base64"), PP_TRUE), 208 PropertyTestData( 209 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMCONTENTTRANSFERENCODING), 210 PP_MakeString(""), PP_TRUE), 211 PropertyTestData( 212 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMCONTENTTRANSFERENCODING), 213 PP_MakeUndefined(), PP_TRUE), 214 PropertyTestData( 215 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMUSERAGENT), 216 PP_MakeString("My Crazy Plugin"), PP_TRUE), 217 PropertyTestData( 218 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMUSERAGENT), 219 PP_MakeString(""), PP_TRUE), 220 PropertyTestData( 221 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMUSERAGENT), 222 PP_MakeUndefined(), PP_TRUE), 223 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_URL), 224 PP_MakeUndefined(), PP_FALSE), 225 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_METHOD), 226 PP_MakeUndefined(), PP_FALSE), 227 PropertyTestData( 228 ID_STR(PP_URLREQUESTPROPERTY_HEADERS), 229 PP_MakeString("Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA=="), 230 PP_TRUE), 231 PropertyTestData( 232 ID_STR(PP_URLREQUESTPROPERTY_HEADERS), 233 PP_MakeString("Accept-Encoding: *\n" 234 "Accept-Charset: iso-8859-5, unicode-1-1;q=0.8"), 235 PP_TRUE), 236 PropertyTestData( 237 ID_STR(PP_URLREQUESTPROPERTY_PREFETCHBUFFERUPPERTHRESHOLD), 238 PP_MakeInt32(0), PP_TRUE), 239 PropertyTestData( 240 ID_STR(PP_URLREQUESTPROPERTY_PREFETCHBUFFERUPPERTHRESHOLD), 241 PP_MakeInt32(100), PP_TRUE), 242 PropertyTestData( 243 ID_STR(PP_URLREQUESTPROPERTY_PREFETCHBUFFERLOWERTHRESHOLD), 244 PP_MakeInt32(0), PP_TRUE), 245 PropertyTestData( 246 ID_STR(PP_URLREQUESTPROPERTY_PREFETCHBUFFERLOWERTHRESHOLD), 247 PP_MakeInt32(100), PP_TRUE), 248 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_URL), 249 PP_MakeString("::::::::::::"), PP_TRUE), 250 PropertyTestData(ID_STR(PP_URLREQUESTPROPERTY_METHOD), 251 PP_MakeString("INVALID"), PP_TRUE), 252 PropertyTestData( 253 ID_STR(PP_URLREQUESTPROPERTY_CUSTOMCONTENTTRANSFERENCODING), 254 PP_MakeString("invalid"), PP_TRUE), 255 PropertyTestData( 256 ID_STR(PP_URLREQUESTPROPERTY_PREFETCHBUFFERUPPERTHRESHOLD), 257 PP_MakeInt32(-100), PP_TRUE), 258 PropertyTestData( 259 ID_STR(PP_URLREQUESTPROPERTY_PREFETCHBUFFERLOWERTHRESHOLD), 260 PP_MakeInt32(-100), PP_TRUE), 261 262 }; 263 std::string error; 264 265 PP_Resource url_request = ppb_url_request_interface_->Create( 266 instance_->pp_instance()); 267 if (url_request == kInvalidResource) 268 error = "Failed to create a URLRequestInfo"; 269 270 // Loop over all test data even if we encountered an error to release vars. 271 for (size_t i = 0; 272 i < sizeof(test_data) / sizeof(test_data[0]); 273 ++i) { 274 if (error.empty() && test_data[i].expected_value != 275 ppb_url_request_interface_->SetProperty(url_request, 276 test_data[i].property, 277 test_data[i].var)) { 278 pp::Var var(pp::Var::DontManage(), test_data[i].var); 279 error = std::string("Setting property ") + 280 test_data[i].property_name + " to " + var.DebugString() + 281 " did not return " + (test_data[i].expected_value ? "True" : "False"); 282 error = test_data[i].property_name; 283 } 284 ppb_var_interface_->Release(test_data[i].var); 285 } 286 287 ppb_core_interface_->ReleaseResource(url_request); 288 return error; // == PASS() if empty. 289 } 290 291 std::string TestURLRequest::LoadAndCompareBody( 292 PP_Resource url_request, const std::string& expected_body) { 293 TestCompletionCallback callback(instance_->pp_instance(), PP_REQUIRED); 294 295 PP_Resource url_loader = 296 ppb_url_loader_interface_->Create(instance_->pp_instance()); 297 ASSERT_NE(kInvalidResource, url_loader); 298 299 callback.WaitForResult(ppb_url_loader_interface_->Open( 300 url_loader, url_request, 301 callback.GetCallback().pp_completion_callback())); 302 CHECK_CALLBACK_BEHAVIOR(callback); 303 ASSERT_EQ(PP_OK, callback.result()); 304 305 std::string error; 306 PP_Resource url_response = 307 ppb_url_loader_interface_->GetResponseInfo(url_loader); 308 if (url_response == kInvalidResource) { 309 error = "PPB_URLLoader::GetResponseInfo() returned invalid resource"; 310 } else { 311 PP_Var status = ppb_url_response_interface_->GetProperty( 312 url_response, PP_URLRESPONSEPROPERTY_STATUSCODE); 313 if (status.type != PP_VARTYPE_INT32 && status.value.as_int != 200) 314 error = ReportError("PPB_URLLoader::Open() status", status.value.as_int); 315 316 std::string actual_body; 317 for (; error.empty();) { // Read the entire body in this loop. 318 const size_t kBufferSize = 32; 319 char buf[kBufferSize]; 320 callback.WaitForResult(ppb_url_loader_interface_->ReadResponseBody( 321 url_loader, buf, kBufferSize, 322 callback.GetCallback().pp_completion_callback())); 323 if (callback.failed()) 324 error.assign(callback.errors()); 325 else if (callback.result() < PP_OK) 326 error.assign(ReportError("PPB_URLLoader::ReadResponseBody()", 327 callback.result())); 328 if (callback.result() <= PP_OK || callback.failed()) 329 break; 330 actual_body.append(buf, callback.result()); 331 } 332 if (actual_body != expected_body) 333 error = "PPB_URLLoader::ReadResponseBody() read unexpected response."; 334 } 335 ppb_core_interface_->ReleaseResource(url_response); 336 337 ppb_url_loader_interface_->Close(url_loader); 338 ppb_core_interface_->ReleaseResource(url_loader); 339 return error; 340 } 341 342 // Tests 343 // PP_Bool AppendDataToBody( 344 // PP_Resource request, const void* data, uint32_t len); 345 std::string TestURLRequest::TestAppendDataToBody() { 346 PP_Resource url_request = ppb_url_request_interface_->Create( 347 instance_->pp_instance()); 348 ASSERT_NE(url_request, kInvalidResource); 349 350 std::string postdata("sample postdata"); 351 PP_Var post_string_var = PP_MakeString("POST"); 352 PP_Var echo_string_var = PP_MakeString("/echo"); 353 354 // NULL pointer causes a crash. In general PPAPI implementation does not 355 // test for NULL because they are just a special case of bad pointers that 356 // are not detectable if set to point to an object that does not exist. 357 358 // Invalid resource should fail. 359 ASSERT_EQ(PP_FALSE, ppb_url_request_interface_->AppendDataToBody( 360 kInvalidResource, postdata.data(), postdata.length())); 361 362 // Append data and POST to echoing web server. 363 ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->SetProperty( 364 url_request, PP_URLREQUESTPROPERTY_METHOD, post_string_var)); 365 ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->SetProperty( 366 url_request, PP_URLREQUESTPROPERTY_URL, echo_string_var)); 367 368 // Append data to body and verify the body is what we expect. 369 ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->AppendDataToBody( 370 url_request, postdata.data(), postdata.length())); 371 std::string error = LoadAndCompareBody(url_request, postdata); 372 373 ppb_var_interface_->Release(post_string_var); 374 ppb_var_interface_->Release(echo_string_var); 375 ppb_core_interface_->ReleaseResource(url_request); 376 return error; // == PASS() if empty. 377 } 378 379 std::string TestURLRequest::TestAppendFileToBody() { 380 PP_Resource url_request = ppb_url_request_interface_->Create( 381 instance_->pp_instance()); 382 ASSERT_NE(url_request, kInvalidResource); 383 384 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 385 386 pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); 387 callback.WaitForResult(file_system.Open(1024, callback.GetCallback())); 388 CHECK_CALLBACK_BEHAVIOR(callback); 389 ASSERT_EQ(PP_OK, callback.result()); 390 391 pp::FileRef ref(file_system, "/test_file"); 392 pp::FileIO io(instance_); 393 callback.WaitForResult(io.Open(ref, 394 PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE, 395 callback.GetCallback())); 396 CHECK_CALLBACK_BEHAVIOR(callback); 397 ASSERT_EQ(PP_OK, callback.result()); 398 399 std::string append_data = "hello\n"; 400 callback.WaitForResult(io.Write(0, 401 append_data.c_str(), 402 append_data.size(), 403 callback.GetCallback())); 404 CHECK_CALLBACK_BEHAVIOR(callback); 405 ASSERT_EQ(static_cast<int32_t>(append_data.size()), callback.result()); 406 407 PP_Var post_string_var = PP_MakeString("POST"); 408 PP_Var echo_string_var = PP_MakeString("/echo"); 409 410 // NULL pointer causes a crash. In general PPAPI implementation does not 411 // test for NULL because they are just a special case of bad pointers that 412 // are not detectable if set to point to an object that does not exist. 413 414 // Invalid resource should fail. 415 ASSERT_EQ(PP_FALSE, ppb_url_request_interface_->AppendFileToBody( 416 kInvalidResource, ref.pp_resource(), 0, -1, 0)); 417 418 // Append data and POST to echoing web server. 419 ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->SetProperty( 420 url_request, PP_URLREQUESTPROPERTY_METHOD, post_string_var)); 421 ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->SetProperty( 422 url_request, PP_URLREQUESTPROPERTY_URL, echo_string_var)); 423 424 // Append file to body and verify the body is what we expect. 425 ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->AppendFileToBody( 426 url_request, ref.pp_resource(), 0, -1, 0)); 427 std::string error = LoadAndCompareBody(url_request, append_data); 428 429 ppb_var_interface_->Release(post_string_var); 430 ppb_var_interface_->Release(echo_string_var); 431 ppb_core_interface_->ReleaseResource(url_request); 432 return error; // == PASS() if empty. 433 } 434 435 // Allocates and manipulates a large number of resources. 436 std::string TestURLRequest::TestStress() { 437 const int kManyResources = 500; 438 PP_Resource url_request_info[kManyResources]; 439 440 std::string error; 441 int num_created = kManyResources; 442 for (int i = 0; i < kManyResources; i++) { 443 url_request_info[i] = ppb_url_request_interface_->Create( 444 instance_->pp_instance()); 445 if (url_request_info[i] == kInvalidResource) { 446 error = "Create() failed"; 447 } else if (PP_FALSE == ppb_url_request_interface_->IsURLRequestInfo( 448 url_request_info[i])) { 449 error = "IsURLRequestInfo() failed"; 450 } else if (PP_FALSE == ppb_url_request_interface_->SetProperty( 451 url_request_info[i], 452 PP_URLREQUESTPROPERTY_STREAMTOFILE, 453 PP_MakeBool(PP_FALSE))) { 454 error = "SetProperty() failed"; 455 } 456 if (!error.empty()) { 457 num_created = i + 1; 458 break; 459 } 460 } 461 for (int i = 0; i < num_created; i++) { 462 ppb_core_interface_->ReleaseResource(url_request_info[i]); 463 if (PP_TRUE == 464 ppb_url_request_interface_->IsURLRequestInfo(url_request_info[i])) 465 error = "IsURLREquestInfo() succeeded after release"; 466 } 467 return error; // == PASS() if empty. 468 } 469
