| OLD | NEW |
|---|
| (Empty) |
| 1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" | |
| 2 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> | |
| 3 <html> | |
| 4 <!-- Copyright 2009 Google Inc. All rights reserved. --> | |
| 5 <head> | |
| 6 <title> SRPC Parameter Passing Test </title> | |
| 7 <META HTTP-EQUIV="Pragma" CONTENT="no-cache" /> | |
| 8 <META HTTP-EQUIV="Expires" CONTENT="-1" /> | |
| 9 <style type="text/css"> | |
| 10 td.notrun { background-color: skyblue } | |
| 11 td.pass { background-color: lime } | |
| 12 td.fail { background-color: red } | |
| 13 </style> | |
| 14 <script type="application/x-javascript"> | |
| 15 //<![CDATA[ | |
| 16 var SetTestResult = function(element_id, result) { | |
| 17 var element = document.getElementById(element_id); | |
| 18 element.className = result; | |
| 19 } | |
| 20 | |
| 21 // The NaCl module. | |
| 22 var server; | |
| 23 // The default socket address for the plugin. | |
| 24 var default_addr; | |
| 25 // The count of failing tests. Set from the queue length, and decremented | |
| 26 // whenever a test passes. | |
| 27 var failing_count; | |
| 28 | |
| 29 // The queue of small tests. | |
| 30 var testQueue = [ ]; | |
| 31 var appendTest = function(test_descr) { | |
| 32 testQueue[testQueue.length] = test_descr; | |
| 33 } | |
| 34 | |
| 35 var expectPass = function(element, has_return, fp) { | |
| 36 appendTest(new Array('pass', element, has_return, fp)); | |
| 37 } | |
| 38 | |
| 39 var expectFail = function(element, fp) { | |
| 40 appendTest(new Array('fail', element, fp)); | |
| 41 } | |
| 42 | |
| 43 // Tests passing scalar types. | |
| 44 var ScalarTypes = function() { | |
| 45 expectPass('bool_passret', | |
| 46 true, | |
| 47 function() { | |
| 48 if (!server.bool(true) && server.bool(false)) { | |
| 49 return true; | |
| 50 } | |
| 51 }); | |
| 52 expectFail('int_as_bool', | |
| 53 function() { | |
| 54 return server.bool(1); | |
| 55 }); | |
| 56 expectFail('array_as_bool', | |
| 57 function() { | |
| 58 return server.bool(new Array(10)); | |
| 59 }); | |
| 60 expectFail('handle_as_bool', | |
| 61 function() { | |
| 62 return server.bool(server.__defaultSocketAddress()); | |
| 63 }); | |
| 64 expectPass('double_passret', | |
| 65 true, | |
| 66 function() { | |
| 67 var dval = 3.1415; | |
| 68 if (server.double(dval) == -dval) { | |
| 69 return true; | |
| 70 } | |
| 71 }); | |
| 72 expectFail('bool_as_double', | |
| 73 function() { | |
| 74 return server.double(true); | |
| 75 }); | |
| 76 expectFail('array_as_double', | |
| 77 function() { | |
| 78 return server.double(new Array(10)); | |
| 79 }); | |
| 80 expectFail('handle_as_double', | |
| 81 function() { | |
| 82 return server.double(server.__defaultSocketAddress()); | |
| 83 }); | |
| 84 expectPass('int_passret', | |
| 85 true, | |
| 86 function() { | |
| 87 var ival = 12345; | |
| 88 if (server.int(ival) == -ival) { | |
| 89 return true; | |
| 90 } | |
| 91 }); | |
| 92 expectFail('bool_as_int', | |
| 93 function() { | |
| 94 return server.int(true); | |
| 95 }); | |
| 96 expectFail('array_as_int', | |
| 97 function() { | |
| 98 return server.int(new Array(10)); | |
| 99 }); | |
| 100 expectFail('handle_as_int', | |
| 101 function() { | |
| 102 return server.int(server.__defaultSocketAddress()); | |
| 103 }); | |
| 104 } | |
| 105 | |
| 106 // Tests passing array types. | |
| 107 var ArrayTypes = function() { | |
| 108 expectPass('chararr_passret', | |
| 109 true, | |
| 110 function() { | |
| 111 var carr = [ 72, 101, 108, 108, 111 ]; // Hello | |
| 112 var ret_arr = server.char_array(carr, 5); | |
| 113 if (ret_arr[0] == carr[4] && | |
| 114 ret_arr[1] == carr[3] && | |
| 115 ret_arr[2] == carr[2] && | |
| 116 ret_arr[3] == carr[1] && | |
| 117 ret_arr[4] == carr[0]) { | |
| 118 return true; | |
| 119 } | |
| 120 }); | |
| 121 expectFail('bool_as_char_array', | |
| 122 function() { | |
| 123 return server.char_array(true); | |
| 124 }); | |
| 125 expectFail('int_as_char_array', | |
| 126 function() { | |
| 127 return server.char_array(1); | |
| 128 }); | |
| 129 expectFail('double_as_char_array', | |
| 130 function() { | |
| 131 return server.char_array(1.5); | |
| 132 }); | |
| 133 expectFail('handle_as_char_array', | |
| 134 function() { | |
| 135 return server.char_array(server.__defaultSocketAddress()); | |
| 136 }); | |
| 137 expectPass('doublearr_passret', | |
| 138 true, | |
| 139 function() { | |
| 140 var darr = [ 3.1, 1.4, 4.1, 1.5, 5.9 ]; | |
| 141 var ret_arr = server.double_array(darr, 5); | |
| 142 if (ret_arr[0] == darr[4] && | |
| 143 ret_arr[1] == darr[3] && | |
| 144 ret_arr[2] == darr[2] && | |
| 145 ret_arr[3] == darr[1] && | |
| 146 ret_arr[4] == darr[0]) { | |
| 147 return true; | |
| 148 } | |
| 149 }); | |
| 150 expectFail('bool_as_double_array', | |
| 151 function() { | |
| 152 return server.double_array(true); | |
| 153 }); | |
| 154 expectFail('int_as_double_array', | |
| 155 function() { | |
| 156 return server.double_array(1); | |
| 157 }); | |
| 158 expectFail('double_as_double_array', | |
| 159 function() { | |
| 160 return server.double_array(1.0); | |
| 161 }); | |
| 162 expectFail('handle_as_double_array', | |
| 163 function() { | |
| 164 return server.double_array(server.__defaultSocketAddress()); | |
| 165 }); | |
| 166 expectPass('intarr_passret', | |
| 167 true, | |
| 168 function() { | |
| 169 var iarr = [ 1, 2, 3, 4, 5 ]; | |
| 170 var ret_arr = server.int_array(iarr, 5); | |
| 171 if (ret_arr[0] == iarr[4] && | |
| 172 ret_arr[1] == iarr[3] && | |
| 173 ret_arr[2] == iarr[2] && | |
| 174 ret_arr[3] == iarr[1] && | |
| 175 ret_arr[4] == iarr[0]) { | |
| 176 return true; | |
| 177 } | |
| 178 }); | |
| 179 expectFail('bool_as_int_array', | |
| 180 function() { | |
| 181 return server.int_array(true); | |
| 182 }); | |
| 183 expectFail('int_as_int_array', | |
| 184 function() { | |
| 185 return server.int_array(1); | |
| 186 }); | |
| 187 expectFail('double_as_int_array', | |
| 188 function() { | |
| 189 return server.int_array(1.0); | |
| 190 }); | |
| 191 expectFail('handle_as_int_array', | |
| 192 function() { | |
| 193 return server.int_array(server.__defaultSocketAddress()); | |
| 194 }); | |
| 195 } | |
| 196 | |
| 197 // Tests passing more complex or special-purpose types. | |
| 198 var SpecialTypes = function() { | |
| 199 expectPass('string_send', | |
| 200 true, | |
| 201 function() { | |
| 202 var str = 'one more test'; | |
| 203 var ret = server.string(str); | |
| 204 if (str.length == ret) { | |
| 205 return true; | |
| 206 } | |
| 207 }); | |
| 208 expectPass('string_return', | |
| 209 true, | |
| 210 function() { | |
| 211 var ret = server.stringret(0); | |
| 212 if ('string' == typeof(ret)) { | |
| 213 return true; | |
| 214 } | |
| 215 }); | |
| 216 expectFail('bool_as_string', | |
| 217 function() { | |
| 218 return server.string(true); | |
| 219 }); | |
| 220 expectFail('int_as_string', | |
| 221 function() { | |
| 222 return server.string(1); | |
| 223 }); | |
| 224 expectFail('double_as_string', | |
| 225 function() { | |
| 226 return server.string(1); | |
| 227 }); | |
| 228 expectFail('array_as_string', | |
| 229 function() { | |
| 230 var iarr = [ 1, 2, 3, 4, 5 ]; | |
| 231 return server.string(iarr); | |
| 232 }); | |
| 233 expectPass('handle_send', | |
| 234 false, | |
| 235 function() { | |
| 236 var hnd = server.__defaultSocketAddress(); | |
| 237 server.handle(hnd); | |
| 238 }); | |
| 239 expectPass('handle_return', | |
| 240 true, | |
| 241 function() { | |
| 242 var ret = server.handleret(); | |
| 243 if ('object' == typeof(ret)) { | |
| 244 return true; | |
| 245 } | |
| 246 }); | |
| 247 expectPass('invalid_handle_return', | |
| 248 true, | |
| 249 function() { | |
| 250 var ret = server.invalid_handle_ret(); | |
| 251 if ('object' == typeof(ret)) { | |
| 252 return true; | |
| 253 } | |
| 254 }); | |
| 255 expectPass('invalid_handle_send', | |
| 256 false, | |
| 257 function() { | |
| 258 var ret = server.invalid_handle_ret(); | |
| 259 if ('object' == typeof(ret)) { | |
| 260 server.invalid_handle(ret); | |
| 261 } | |
| 262 }); | |
| 263 expectFail('bool_as_handle', | |
| 264 function() { | |
| 265 return server.handle(true); | |
| 266 }); | |
| 267 expectFail('int_as_handle', | |
| 268 function() { | |
| 269 return server.handle(1); | |
| 270 }); | |
| 271 expectFail('double_as_handle', | |
| 272 function() { | |
| 273 return server.handle(1); | |
| 274 }); | |
| 275 expectFail('array_as_handle', | |
| 276 function() { | |
| 277 var iarr = [ 1, 2, 3, 4, 5 ]; | |
| 278 return server.handle(iarr); | |
| 279 }); | |
| 280 } | |
| 281 | |
| 282 // Functions to support running each of the tests. | |
| 283 var testExpectedPass = function(element, has_return, fp) { | |
| 284 var result = undefined; | |
| 285 try { | |
| 286 result = fp(); | |
| 287 if (has_return && (undefined == result)) { | |
| 288 SetTestResult(element, 'fail'); | |
| 289 } else { | |
| 290 SetTestResult(element, 'pass'); | |
| 291 --failing_count; | |
| 292 } | |
| 293 } catch (string) { | |
| 294 SetTestResult(element, 'fail'); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 var testExpectedFail = function(element, fp) { | |
| 299 var result = undefined; | |
| 300 try { | |
| 301 result = fp(); | |
| 302 SetTestResult(element, 'fail'); | |
| 303 } catch (string) { | |
| 304 if (undefined == result) { | |
| 305 SetTestResult(element, 'pass'); | |
| 306 --failing_count; | |
| 307 } else { | |
| 308 SetTestResult(element, 'fail'); | |
| 309 } | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 var RunAllTests = function() { | |
| 314 var i; | |
| 315 var len = testQueue.length; | |
| 316 // All tests are considered failure until they have run successfully. | |
| 317 // This catches runs that end prematurely. | |
| 318 failing_count = len; | |
| 319 for (i = 0; i < len; ++i) { | |
| 320 var test_descr = testQueue[i]; | |
| 321 if ('pass' == test_descr[0]) { | |
| 322 testExpectedPass(test_descr[1], test_descr[2], test_descr[3]); | |
| 323 } else { | |
| 324 testExpectedFail(test_descr[1], test_descr[2]); | |
| 325 } | |
| 326 } | |
| 327 } | |
| 328 | |
| 329 var EnqueueAndRunTests = function() { | |
| 330 // Setup -- abort entire test if this fails. | |
| 331 try { | |
| 332 // If these fail at the beginning, all the tests will abort. | |
| 333 // Otherwise more specific tests are done on them. | |
| 334 default_addr = server.__defaultSocketAddress(); | |
| 335 } catch (string) { | |
| 336 window.alert('Socket address test setup failed.'); | |
| 337 return; | |
| 338 } | |
| 339 // Enqueue the tests. | |
| 340 ScalarTypes(); | |
| 341 ArrayTypes(); | |
| 342 SpecialTypes(); | |
| 343 // Run them all. | |
| 344 RunAllTests(); | |
| 345 } | |
| 346 //]]> | |
| 347 </script> | |
| 348 </head> | |
| 349 <body onload="nacllib.waitForModulesAndRunTests();" | |
| 350 onunload="nacllib.cleanUp();" > | |
| 351 <h1> SRPC Parameter Passing Test </h1> | |
| 352 <table cellspacing=5 cellpadding=5 border=5 summary="Test status table"> | |
| 353 <tr> | |
| 354 <td> | |
| 355 </td> | |
| 356 <td> | |
| 357 <b> Scalar types </b> | |
| 358 </td> | |
| 359 <td> | |
| 360 <b> Array types </b> | |
| 361 </td> | |
| 362 <td> | |
| 363 <b> Special types </b> | |
| 364 </td> | |
| 365 </tr> | |
| 366 <tr> | |
| 367 <td> | |
| 368 <b> Boolean </b> | |
| 369 </td> | |
| 370 <td valign=top> | |
| 371 <table summary="Boolean test status"> | |
| 372 <tr> | |
| 373 <td id="bool_passret" class="notrun"> | |
| 374 pass/return | |
| 375 </td> | |
| 376 </tr> | |
| 377 <tr> | |
| 378 <td id="int_as_bool" class="notrun"> | |
| 379 int as bool | |
| 380 </td> | |
| 381 </tr> | |
| 382 <tr> | |
| 383 <td id="array_as_bool" class="notrun"> | |
| 384 array as bool | |
| 385 </td> | |
| 386 </tr> | |
| 387 <tr> | |
| 388 <td id="handle_as_bool" class="notrun"> | |
| 389 handle as bool | |
| 390 </td> | |
| 391 </tr> | |
| 392 </table> | |
| 393 </td> | |
| 394 <td valign=top> | |
| 395 </td> | |
| 396 <td valign=top> | |
| 397 </td> | |
| 398 </tr> | |
| 399 <tr> | |
| 400 <td> | |
| 401 <b> Character (1-byte) </b> | |
| 402 </td> | |
| 403 <td valign=top> | |
| 404 </td> | |
| 405 <td valign=top> | |
| 406 <table summary="Character test status"> | |
| 407 <tr> | |
| 408 <td id="chararr_passret" class="notrun"> | |
| 409 pass/return | |
| 410 </td> | |
| 411 </tr> | |
| 412 <tr> | |
| 413 <td id="bool_as_char_array" class="notrun"> | |
| 414 bool as char array | |
| 415 </td> | |
| 416 </tr> | |
| 417 <tr> | |
| 418 <td id="int_as_char_array" class="notrun"> | |
| 419 int as char array | |
| 420 </td> | |
| 421 </tr> | |
| 422 <tr> | |
| 423 <td id="double_as_char_array" class="notrun"> | |
| 424 double as char array | |
| 425 </td> | |
| 426 </tr> | |
| 427 <tr> | |
| 428 <td id="handle_as_char_array" class="notrun"> | |
| 429 handle as char array | |
| 430 </td> | |
| 431 </tr> | |
| 432 </table> | |
| 433 </td> | |
| 434 <td> | |
| 435 </td> | |
| 436 </tr> | |
| 437 <tr> | |
| 438 <td> | |
| 439 <b> Double (8-byte fp) </b> | |
| 440 </td> | |
| 441 <td valign=top> | |
| 442 <table summary="Double test status"> | |
| 443 <tr> | |
| 444 <td id="double_passret" class="notrun"> | |
| 445 pass/return | |
| 446 </td> | |
| 447 </tr> | |
| 448 <tr> | |
| 449 <td id="bool_as_double" class="notrun"> | |
| 450 bool as double | |
| 451 </td> | |
| 452 </tr> | |
| 453 <tr> | |
| 454 <td id="array_as_double" class="notrun"> | |
| 455 array as double | |
| 456 </td> | |
| 457 </tr> | |
| 458 <tr> | |
| 459 <td id="handle_as_double" class="notrun"> | |
| 460 handle as double | |
| 461 </td> | |
| 462 </tr> | |
| 463 </table> | |
| 464 </td> | |
| 465 <td valign=top> | |
| 466 <table summary="Double array test status"> | |
| 467 <tr> | |
| 468 <td id="doublearr_passret" class="notrun"> | |
| 469 pass/return | |
| 470 </td> | |
| 471 </tr> | |
| 472 <tr> | |
| 473 <td id="bool_as_double_array" class="notrun"> | |
| 474 bool as double array | |
| 475 </td> | |
| 476 </tr> | |
| 477 <tr> | |
| 478 <td id="int_as_double_array" class="notrun"> | |
| 479 int as double array | |
| 480 </td> | |
| 481 </tr> | |
| 482 <tr> | |
| 483 <td id="double_as_double_array" class="notrun"> | |
| 484 double as double array | |
| 485 </td> | |
| 486 </tr> | |
| 487 <tr> | |
| 488 <td id="handle_as_double_array" class="notrun"> | |
| 489 handle as double array | |
| 490 </td> | |
| 491 </tr> | |
| 492 </table> | |
| 493 </td> | |
| 494 <td> | |
| 495 </td> | |
| 496 </tr> | |
| 497 <tr> | |
| 498 <td> | |
| 499 <b> Integer (4-byte) </b> | |
| 500 </td> | |
| 501 <td valign=top> | |
| 502 <table summary="Integer test status"> | |
| 503 <tr> | |
| 504 <td id="int_passret" class="notrun"> | |
| 505 pass/return | |
| 506 </td> | |
| 507 </tr> | |
| 508 <tr> | |
| 509 <td id="bool_as_int" class="notrun"> | |
| 510 bool as int | |
| 511 </td> | |
| 512 </tr> | |
| 513 <tr> | |
| 514 <td id="array_as_int" class="notrun"> | |
| 515 array as int | |
| 516 </td> | |
| 517 </tr> | |
| 518 <tr> | |
| 519 <td id="handle_as_int" class="notrun"> | |
| 520 handle as int | |
| 521 </td> | |
| 522 </tr> | |
| 523 </table> | |
| 524 </td> | |
| 525 <td valign=top> | |
| 526 <table summary="Integer array test status"> | |
| 527 <tr> | |
| 528 <td id="intarr_passret" class="notrun"> | |
| 529 pass/return | |
| 530 </td> | |
| 531 </tr> | |
| 532 <tr> | |
| 533 <td id="bool_as_int_array" class="notrun"> | |
| 534 bool as int array | |
| 535 </td> | |
| 536 </tr> | |
| 537 <tr> | |
| 538 <td id="int_as_int_array" class="notrun"> | |
| 539 int as int array | |
| 540 </td> | |
| 541 </tr> | |
| 542 <tr> | |
| 543 <td id="double_as_int_array" class="notrun"> | |
| 544 double as int array | |
| 545 </td> | |
| 546 </tr> | |
| 547 <tr> | |
| 548 <td id="handle_as_int_array" class="notrun"> | |
| 549 handle as int array | |
| 550 </td> | |
| 551 </tr> | |
| 552 </table> | |
| 553 </td> | |
| 554 <td valign=top> | |
| 555 </td> | |
| 556 </tr> | |
| 557 <tr> | |
| 558 <td> | |
| 559 <b> Strings (NUL-terminated) </b> | |
| 560 </td> | |
| 561 <td valign=top> | |
| 562 </td> | |
| 563 <td valign=top> | |
| 564 </td> | |
| 565 <td valign=top> | |
| 566 <table summary="String tests status"> | |
| 567 <tr> | |
| 568 <td id="string_send" class="notrun"> | |
| 569 send to NaCl | |
| 570 </td> | |
| 571 </tr> | |
| 572 <tr> | |
| 573 <td id="bool_as_string" class="notrun"> | |
| 574 bool as string | |
| 575 </td> | |
| 576 </tr> | |
| 577 <tr> | |
| 578 <td id="int_as_string" class="notrun"> | |
| 579 int as string | |
| 580 </td> | |
| 581 </tr> | |
| 582 <tr> | |
| 583 <td id="double_as_string" class="notrun"> | |
| 584 double as string | |
| 585 </td> | |
| 586 </tr> | |
| 587 <tr> | |
| 588 <td id="array_as_string" class="notrun"> | |
| 589 array as string | |
| 590 </td> | |
| 591 </tr> | |
| 592 <tr> | |
| 593 <td id="string_return" class="notrun"> | |
| 594 return from NaCl | |
| 595 </td> | |
| 596 </tr> | |
| 597 </table> | |
| 598 </td> | |
| 599 </tr> | |
| 600 <tr> | |
| 601 <td> | |
| 602 <b> Handle (descriptor) </b> | |
| 603 </td> | |
| 604 <td valign=top> | |
| 605 <table summary="Handle tests"> | |
| 606 </table> | |
| 607 </td> | |
| 608 <td valign=top> | |
| 609 <table summary="Handle tests"> | |
| 610 </table> | |
| 611 </td> | |
| 612 <td valign=top> | |
| 613 <table summary="Handle tests status"> | |
| 614 <tr> | |
| 615 <td id="handle_send" class="notrun"> | |
| 616 send to NaCl | |
| 617 </td> | |
| 618 </tr> | |
| 619 <tr> | |
| 620 <td id="bool_as_handle" class="notrun"> | |
| 621 bool as handle | |
| 622 </td> | |
| 623 </tr> | |
| 624 <tr> | |
| 625 <td id="int_as_handle" class="notrun"> | |
| 626 int as handle | |
| 627 </td> | |
| 628 </tr> | |
| 629 <tr> | |
| 630 <td id="double_as_handle" class="notrun"> | |
| 631 double as handle | |
| 632 </td> | |
| 633 </tr> | |
| 634 <tr> | |
| 635 <td id="array_as_handle" class="notrun"> | |
| 636 array as handle | |
| 637 </td> | |
| 638 </tr> | |
| 639 <tr> | |
| 640 <td id="handle_return" class="notrun"> | |
| 641 return from NaCl | |
| 642 </td> | |
| 643 </tr> | |
| 644 <tr> | |
| 645 <td id="invalid_handle_send" class="notrun"> | |
| 646 send invalid to NaCl | |
| 647 </td> | |
| 648 </tr> | |
| 649 <tr> | |
| 650 <td id="invalid_handle_return" class="notrun"> | |
| 651 return invalid from NaCl | |
| 652 </td> | |
| 653 </tr> | |
| 654 </table> | |
| 655 </td> | |
| 656 </tr> | |
| 657 </table> | |
| 658 | |
| 659 <table summary="The color codes used for identifying test outcomes"> | |
| 660 <tr> <td align="center"> <em> Legend </em> </td> </tr> | |
| 661 <tr> <td align="center" class="notrun"> Test not run </td> </tr> | |
| 662 <tr> <td align="center" class="pass"> Test passed </td> </tr> | |
| 663 <tr> <td align="center" class="fail"> Test failed </td> </tr> | |
| 664 </table> | |
| 665 <p> | |
| 666 <b> | |
| 667 NOTE: Some versions of some WebKit-based browsers do not correctly report | |
| 668 JavaScript exceptions raised by NPAPI plugins. This can cause some of | |
| 669 the above tests to spuriously report failure. | |
| 670 </b> | |
| 671 </p> | |
| 672 | |
| 673 <div id=status>NO-STATUS</div> | |
| 674 | |
| 675 <embed type="application/x-ppapi-nacl-srpc" id="nacl_server" | |
| 676 name="nacl_module" width="0" height="0" src="srpc_test.nexe" /> | |
| 677 | |
| 678 <script type="text/javascript" src="nacl_js_lib.js"></script> | |
| 679 <script type="text/javascript"> | |
| 680 //<![CDATA[ | |
| 681 var nacllib = new NaclLib("nacl_module", "status", 500); | |
| 682 | |
| 683 nacllib.test = function() { | |
| 684 server = document.getElementById("nacl_server"); | |
| 685 EnqueueAndRunTests(); | |
| 686 if (0 == testQueue.length) { | |
| 687 return "No tests run."; | |
| 688 } else if (0 != failing_count) { | |
| 689 return "Tests failed."; | |
| 690 } else { | |
| 691 return ""; | |
| 692 } | |
| 693 } | |
| 694 //]]> | |
| 695 </script> | |
| 696 </body> | |
| 697 </html> | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 6452010:
Remove the x-ppapi-nacl-srpc and x-nacl-srpc mime types in favor of the singl... (Closed)
Base URL: svn://svn.chromium.org/native_client/trunk/src/native_client/