third_party/mojo/src/nacl_bindings/mojo_syscall.cc

   1 // Copyright 2014 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 // WARNING this file was generated by generate_nacl_bindings.py
   6 // Do not edit by hand.
   7
   8 #include "nacl_bindings/mojo_syscall.h"
   9
  10 #include <stdio.h>
  11
  12 #include "mojo/public/c/system/core.h"
  13 #include "nacl_bindings/mojo_syscall_internal.h"
  14 #include "native_client/src/public/chrome_main.h"
  15 #include "native_client/src/public/nacl_app.h"
  16 #include "native_client/src/trusted/desc/nacl_desc_custom.h"
  17
  18 MojoHandle g_mojo_handle = MOJO_HANDLE_INVALID;
  19
  20 namespace {
  21
  22 MojoResult _MojoGetInitialHandle(MojoHandle* handle) {
  23   *handle = g_mojo_handle;
  24   return MOJO_RESULT_OK;
  25 }
  26
  27 void MojoDescDestroy(void* handle) {
  28 }
  29
  30 ssize_t MojoDescSendMsg(void* handle,
  31                         const struct NaClImcTypedMsgHdr* msg,
  32                         int flags) {
  33   struct NaClApp* nap = static_cast<struct NaClApp*>(handle);
  34
  35   if (msg->iov_length != 1 || msg->ndesc_length != 0) {
  36     return -1;
  37   }
  38
  39   uint32_t volatile* params = static_cast<uint32_t volatile*>(msg->iov[0].base);
  40   size_t num_params = msg->iov[0].length / sizeof(*params);
  41
  42   if (num_params < 1) {
  43     return -1;
  44   }
  45
  46   uint32_t msg_type = params[0];
  47   switch (msg_type) {
  48     case 0: {
  49       if (num_params != 5) {
  50         return -1;
  51       }
  52       const struct MojoCreateSharedBufferOptions* options;
  53       uint64_t num_bytes_value;
  54       MojoHandle volatile* shared_buffer_handle_ptr;
  55       MojoHandle shared_buffer_handle_value;
  56       MojoResult volatile* result_ptr;
  57       MojoResult result_value;
  58       {
  59         ScopedCopyLock copy_lock(nap);
  60         if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) {
  61           return -1;
  62         }
  63         if (!ConvertScalarInput(nap, params[2], &num_bytes_value)) {
  64           return -1;
  65         }
  66         if (!ConvertScalarInOut(nap, params[3], false,
  67                                 &shared_buffer_handle_value,
  68                                 &shared_buffer_handle_ptr)) {
  69           return -1;
  70         }
  71         if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
  72           return -1;
  73         }
  74       }
  75
  76       result_value = MojoCreateSharedBuffer(options, num_bytes_value,
  77                                             &shared_buffer_handle_value);
  78
  79       {
  80         ScopedCopyLock copy_lock(nap);
  81         *shared_buffer_handle_ptr = shared_buffer_handle_value;
  82         *result_ptr = result_value;
  83       }
  84
  85       return 0;
  86     }
  87     case 1: {
  88       if (num_params != 5) {
  89         return -1;
  90       }
  91       MojoHandle buffer_handle_value;
  92       const struct MojoDuplicateBufferHandleOptions* options;
  93       MojoHandle volatile* new_buffer_handle_ptr;
  94       MojoHandle new_buffer_handle_value;
  95       MojoResult volatile* result_ptr;
  96       MojoResult result_value;
  97       {
  98         ScopedCopyLock copy_lock(nap);
  99         if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) {
 100           return -1;
 101         }
 102         if (!ConvertExtensibleStructInput(nap, params[2], true, &options)) {
 103           return -1;
 104         }
 105         if (!ConvertScalarInOut(nap, params[3], false, &new_buffer_handle_value,
 106                                 &new_buffer_handle_ptr)) {
 107           return -1;
 108         }
 109         if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
 110           return -1;
 111         }
 112       }
 113
 114       result_value = MojoDuplicateBufferHandle(buffer_handle_value, options,
 115                                                &new_buffer_handle_value);
 116
 117       {
 118         ScopedCopyLock copy_lock(nap);
 119         *new_buffer_handle_ptr = new_buffer_handle_value;
 120         *result_ptr = result_value;
 121       }
 122
 123       return 0;
 124     }
 125     case 2:
 126       fprintf(stderr, "MojoMapBuffer not implemented\n");
 127       return -1;
 128     case 3:
 129       fprintf(stderr, "MojoUnmapBuffer not implemented\n");
 130       return -1;
 131     case 4: {
 132       if (num_params != 5) {
 133         return -1;
 134       }
 135       const struct MojoCreateDataPipeOptions* options;
 136       MojoHandle volatile* data_pipe_producer_handle_ptr;
 137       MojoHandle data_pipe_producer_handle_value;
 138       MojoHandle volatile* data_pipe_consumer_handle_ptr;
 139       MojoHandle data_pipe_consumer_handle_value;
 140       MojoResult volatile* result_ptr;
 141       MojoResult result_value;
 142       {
 143         ScopedCopyLock copy_lock(nap);
 144         if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) {
 145           return -1;
 146         }
 147         if (!ConvertScalarInOut(nap, params[2], false,
 148                                 &data_pipe_producer_handle_value,
 149                                 &data_pipe_producer_handle_ptr)) {
 150           return -1;
 151         }
 152         if (!ConvertScalarInOut(nap, params[3], false,
 153                                 &data_pipe_consumer_handle_value,
 154                                 &data_pipe_consumer_handle_ptr)) {
 155           return -1;
 156         }
 157         if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
 158           return -1;
 159         }
 160       }
 161
 162       result_value =
 163           MojoCreateDataPipe(options, &data_pipe_producer_handle_value,
 164                              &data_pipe_consumer_handle_value);
 165
 166       {
 167         ScopedCopyLock copy_lock(nap);
 168         *data_pipe_producer_handle_ptr = data_pipe_producer_handle_value;
 169         *data_pipe_consumer_handle_ptr = data_pipe_consumer_handle_value;
 170         *result_ptr = result_value;
 171       }
 172
 173       return 0;
 174     }
 175     case 5: {
 176       if (num_params != 6) {
 177         return -1;
 178       }
 179       MojoHandle data_pipe_producer_handle_value;
 180       const void* elements;
 181       uint32_t volatile* num_bytes_ptr;
 182       uint32_t num_bytes_value;
 183       MojoWriteDataFlags flags_value;
 184       MojoResult volatile* result_ptr;
 185       MojoResult result_value;
 186       {
 187         ScopedCopyLock copy_lock(nap);
 188         if (!ConvertScalarInput(nap, params[1],
 189                                 &data_pipe_producer_handle_value)) {
 190           return -1;
 191         }
 192         if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value,
 193                                 &num_bytes_ptr)) {
 194           return -1;
 195         }
 196         if (!ConvertScalarInput(nap, params[4], &flags_value)) {
 197           return -1;
 198         }
 199         if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
 200           return -1;
 201         }
 202         if (!ConvertArray(nap, params[2], num_bytes_value, 1, false,
 203                           &elements)) {
 204           return -1;
 205         }
 206       }
 207
 208       result_value = MojoWriteData(data_pipe_producer_handle_value, elements,
 209                                    &num_bytes_value, flags_value);
 210
 211       {
 212         ScopedCopyLock copy_lock(nap);
 213         *num_bytes_ptr = num_bytes_value;
 214         *result_ptr = result_value;
 215       }
 216
 217       return 0;
 218     }
 219     case 6:
 220       fprintf(stderr, "MojoBeginWriteData not implemented\n");
 221       return -1;
 222     case 7: {
 223       if (num_params != 4) {
 224         return -1;
 225       }
 226       MojoHandle data_pipe_producer_handle_value;
 227       uint32_t num_bytes_written_value;
 228       MojoResult volatile* result_ptr;
 229       MojoResult result_value;
 230       {
 231         ScopedCopyLock copy_lock(nap);
 232         if (!ConvertScalarInput(nap, params[1],
 233                                 &data_pipe_producer_handle_value)) {
 234           return -1;
 235         }
 236         if (!ConvertScalarInput(nap, params[2], &num_bytes_written_value)) {
 237           return -1;
 238         }
 239         if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) {
 240           return -1;
 241         }
 242       }
 243
 244       result_value = MojoEndWriteData(data_pipe_producer_handle_value,
 245                                       num_bytes_written_value);
 246
 247       {
 248         ScopedCopyLock copy_lock(nap);
 249         *result_ptr = result_value;
 250       }
 251
 252       return 0;
 253     }
 254     case 8: {
 255       if (num_params != 6) {
 256         return -1;
 257       }
 258       MojoHandle data_pipe_consumer_handle_value;
 259       void* elements;
 260       uint32_t volatile* num_bytes_ptr;
 261       uint32_t num_bytes_value;
 262       MojoReadDataFlags flags_value;
 263       MojoResult volatile* result_ptr;
 264       MojoResult result_value;
 265       {
 266         ScopedCopyLock copy_lock(nap);
 267         if (!ConvertScalarInput(nap, params[1],
 268                                 &data_pipe_consumer_handle_value)) {
 269           return -1;
 270         }
 271         if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value,
 272                                 &num_bytes_ptr)) {
 273           return -1;
 274         }
 275         if (!ConvertScalarInput(nap, params[4], &flags_value)) {
 276           return -1;
 277         }
 278         if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
 279           return -1;
 280         }
 281         if (!ConvertArray(nap, params[2], num_bytes_value, 1, false,
 282                           &elements)) {
 283           return -1;
 284         }
 285       }
 286
 287       result_value = MojoReadData(data_pipe_consumer_handle_value, elements,
 288                                   &num_bytes_value, flags_value);
 289
 290       {
 291         ScopedCopyLock copy_lock(nap);
 292         *num_bytes_ptr = num_bytes_value;
 293         *result_ptr = result_value;
 294       }
 295
 296       return 0;
 297     }
 298     case 9:
 299       fprintf(stderr, "MojoBeginReadData not implemented\n");
 300       return -1;
 301     case 10: {
 302       if (num_params != 4) {
 303         return -1;
 304       }
 305       MojoHandle data_pipe_consumer_handle_value;
 306       uint32_t num_bytes_read_value;
 307       MojoResult volatile* result_ptr;
 308       MojoResult result_value;
 309       {
 310         ScopedCopyLock copy_lock(nap);
 311         if (!ConvertScalarInput(nap, params[1],
 312                                 &data_pipe_consumer_handle_value)) {
 313           return -1;
 314         }
 315         if (!ConvertScalarInput(nap, params[2], &num_bytes_read_value)) {
 316           return -1;
 317         }
 318         if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) {
 319           return -1;
 320         }
 321       }
 322
 323       result_value = MojoEndReadData(data_pipe_consumer_handle_value,
 324                                      num_bytes_read_value);
 325
 326       {
 327         ScopedCopyLock copy_lock(nap);
 328         *result_ptr = result_value;
 329       }
 330
 331       return 0;
 332     }
 333     case 11: {
 334       if (num_params != 2) {
 335         return -1;
 336       }
 337       MojoTimeTicks volatile* result_ptr;
 338       MojoTimeTicks result_value;
 339       {
 340         ScopedCopyLock copy_lock(nap);
 341         if (!ConvertScalarOutput(nap, params[1], false, &result_ptr)) {
 342           return -1;
 343         }
 344       }
 345
 346       result_value = MojoGetTimeTicksNow();
 347
 348       {
 349         ScopedCopyLock copy_lock(nap);
 350         *result_ptr = result_value;
 351       }
 352
 353       return 0;
 354     }
 355     case 12: {
 356       if (num_params != 3) {
 357         return -1;
 358       }
 359       MojoHandle handle_value;
 360       MojoResult volatile* result_ptr;
 361       MojoResult result_value;
 362       {
 363         ScopedCopyLock copy_lock(nap);
 364         if (!ConvertScalarInput(nap, params[1], &handle_value)) {
 365           return -1;
 366         }
 367         if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) {
 368           return -1;
 369         }
 370       }
 371
 372       result_value = MojoClose(handle_value);
 373
 374       {
 375         ScopedCopyLock copy_lock(nap);
 376         *result_ptr = result_value;
 377       }
 378
 379       return 0;
 380     }
 381     case 13: {
 382       if (num_params != 6) {
 383         return -1;
 384       }
 385       MojoHandle handle_value;
 386       MojoHandleSignals signals_value;
 387       MojoDeadline deadline_value;
 388       MojoHandleSignalsState volatile* signals_state_ptr;
 389       MojoHandleSignalsState signals_state_value;
 390       MojoResult volatile* result_ptr;
 391       MojoResult result_value;
 392       {
 393         ScopedCopyLock copy_lock(nap);
 394         if (!ConvertScalarInput(nap, params[1], &handle_value)) {
 395           return -1;
 396         }
 397         if (!ConvertScalarInput(nap, params[2], &signals_value)) {
 398           return -1;
 399         }
 400         if (!ConvertScalarInput(nap, params[3], &deadline_value)) {
 401           return -1;
 402         }
 403         if (!ConvertScalarOutput(nap, params[4], true, &signals_state_ptr)) {
 404           return -1;
 405         }
 406         if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
 407           return -1;
 408         }
 409       }
 410
 411       result_value = MojoWait(handle_value, signals_value, deadline_value,
 412                               signals_state_ptr ? &signals_state_value : NULL);
 413
 414       {
 415         ScopedCopyLock copy_lock(nap);
 416         if (signals_state_ptr != NULL) {
 417           memcpy_volatile_out(signals_state_ptr, &signals_state_value,
 418                               sizeof(MojoHandleSignalsState));
 419         }
 420         *result_ptr = result_value;
 421       }
 422
 423       return 0;
 424     }
 425     case 14: {
 426       if (num_params != 8) {
 427         return -1;
 428       }
 429       const MojoHandle* handles;
 430       const MojoHandleSignals* signals;
 431       uint32_t num_handles_value;
 432       MojoDeadline deadline_value;
 433       uint32_t volatile* result_index_ptr;
 434       uint32_t result_index_value;
 435       struct MojoHandleSignalsState* signals_states;
 436       MojoResult volatile* result_ptr;
 437       MojoResult result_value;
 438       {
 439         ScopedCopyLock copy_lock(nap);
 440         if (!ConvertScalarInput(nap, params[3], &num_handles_value)) {
 441           return -1;
 442         }
 443         if (!ConvertScalarInput(nap, params[4], &deadline_value)) {
 444           return -1;
 445         }
 446         if (!ConvertScalarInOut(nap, params[5], true, &result_index_value,
 447                                 &result_index_ptr)) {
 448           return -1;
 449         }
 450         if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) {
 451           return -1;
 452         }
 453         if (!ConvertArray(nap, params[1], num_handles_value, sizeof(*handles),
 454                           false, &handles)) {
 455           return -1;
 456         }
 457         if (!ConvertArray(nap, params[2], num_handles_value, sizeof(*signals),
 458                           false, &signals)) {
 459           return -1;
 460         }
 461         if (!ConvertArray(nap, params[6], num_handles_value,
 462                           sizeof(*signals_states), true, &signals_states)) {
 463           return -1;
 464         }
 465       }
 466
 467       result_value = MojoWaitMany(
 468           handles, signals, num_handles_value, deadline_value,
 469           result_index_ptr ? &result_index_value : NULL, signals_states);
 470
 471       {
 472         ScopedCopyLock copy_lock(nap);
 473         if (result_index_ptr != NULL) {
 474           *result_index_ptr = result_index_value;
 475         }
 476         *result_ptr = result_value;
 477       }
 478
 479       return 0;
 480     }
 481     case 15: {
 482       if (num_params != 5) {
 483         return -1;
 484       }
 485       const struct MojoCreateMessagePipeOptions* options;
 486       MojoHandle volatile* message_pipe_handle0_ptr;
 487       MojoHandle message_pipe_handle0_value;
 488       MojoHandle volatile* message_pipe_handle1_ptr;
 489       MojoHandle message_pipe_handle1_value;
 490       MojoResult volatile* result_ptr;
 491       MojoResult result_value;
 492       {
 493         ScopedCopyLock copy_lock(nap);
 494         if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) {
 495           return -1;
 496         }
 497         if (!ConvertScalarInOut(nap, params[2], false,
 498                                 &message_pipe_handle0_value,
 499                                 &message_pipe_handle0_ptr)) {
 500           return -1;
 501         }
 502         if (!ConvertScalarInOut(nap, params[3], false,
 503                                 &message_pipe_handle1_value,
 504                                 &message_pipe_handle1_ptr)) {
 505           return -1;
 506         }
 507         if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
 508           return -1;
 509         }
 510       }
 511
 512       result_value = MojoCreateMessagePipe(options, &message_pipe_handle0_value,
 513                                            &message_pipe_handle1_value);
 514
 515       {
 516         ScopedCopyLock copy_lock(nap);
 517         *message_pipe_handle0_ptr = message_pipe_handle0_value;
 518         *message_pipe_handle1_ptr = message_pipe_handle1_value;
 519         *result_ptr = result_value;
 520       }
 521
 522       return 0;
 523     }
 524     case 16: {
 525       if (num_params != 8) {
 526         return -1;
 527       }
 528       MojoHandle message_pipe_handle_value;
 529       const void* bytes;
 530       uint32_t num_bytes_value;
 531       const MojoHandle* handles;
 532       uint32_t num_handles_value;
 533       MojoWriteMessageFlags flags_value;
 534       MojoResult volatile* result_ptr;
 535       MojoResult result_value;
 536       {
 537         ScopedCopyLock copy_lock(nap);
 538         if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) {
 539           return -1;
 540         }
 541         if (!ConvertScalarInput(nap, params[3], &num_bytes_value)) {
 542           return -1;
 543         }
 544         if (!ConvertScalarInput(nap, params[5], &num_handles_value)) {
 545           return -1;
 546         }
 547         if (!ConvertScalarInput(nap, params[6], &flags_value)) {
 548           return -1;
 549         }
 550         if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) {
 551           return -1;
 552         }
 553         if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) {
 554           return -1;
 555         }
 556         if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles),
 557                           true, &handles)) {
 558           return -1;
 559         }
 560       }
 561
 562       result_value =
 563           MojoWriteMessage(message_pipe_handle_value, bytes, num_bytes_value,
 564                            handles, num_handles_value, flags_value);
 565
 566       {
 567         ScopedCopyLock copy_lock(nap);
 568         *result_ptr = result_value;
 569       }
 570
 571       return 0;
 572     }
 573     case 17: {
 574       if (num_params != 8) {
 575         return -1;
 576       }
 577       MojoHandle message_pipe_handle_value;
 578       void* bytes;
 579       uint32_t volatile* num_bytes_ptr;
 580       uint32_t num_bytes_value;
 581       MojoHandle* handles;
 582       uint32_t volatile* num_handles_ptr;
 583       uint32_t num_handles_value;
 584       MojoReadMessageFlags flags_value;
 585       MojoResult volatile* result_ptr;
 586       MojoResult result_value;
 587       {
 588         ScopedCopyLock copy_lock(nap);
 589         if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) {
 590           return -1;
 591         }
 592         if (!ConvertScalarInOut(nap, params[3], true, &num_bytes_value,
 593                                 &num_bytes_ptr)) {
 594           return -1;
 595         }
 596         if (!ConvertScalarInOut(nap, params[5], true, &num_handles_value,
 597                                 &num_handles_ptr)) {
 598           return -1;
 599         }
 600         if (!ConvertScalarInput(nap, params[6], &flags_value)) {
 601           return -1;
 602         }
 603         if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) {
 604           return -1;
 605         }
 606         if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) {
 607           return -1;
 608         }
 609         if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles),
 610                           true, &handles)) {
 611           return -1;
 612         }
 613       }
 614
 615       result_value = MojoReadMessage(
 616           message_pipe_handle_value, bytes,
 617           num_bytes_ptr ? &num_bytes_value : NULL, handles,
 618           num_handles_ptr ? &num_handles_value : NULL, flags_value);
 619
 620       {
 621         ScopedCopyLock copy_lock(nap);
 622         if (num_bytes_ptr != NULL) {
 623           *num_bytes_ptr = num_bytes_value;
 624         }
 625         if (num_handles_ptr != NULL) {
 626           *num_handles_ptr = num_handles_value;
 627         }
 628         *result_ptr = result_value;
 629       }
 630
 631       return 0;
 632     }
 633     case 18: {
 634       if (num_params != 3) {
 635         return -1;
 636       }
 637       MojoHandle volatile* handle_ptr;
 638       MojoHandle handle_value;
 639       MojoResult volatile* result_ptr;
 640       MojoResult result_value;
 641       {
 642         ScopedCopyLock copy_lock(nap);
 643         if (!ConvertScalarInOut(nap, params[1], false, &handle_value,
 644                                 &handle_ptr)) {
 645           return -1;
 646         }
 647         if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) {
 648           return -1;
 649         }
 650       }
 651
 652       result_value = _MojoGetInitialHandle(&handle_value);
 653
 654       {
 655         ScopedCopyLock copy_lock(nap);
 656         *handle_ptr = handle_value;
 657         *result_ptr = result_value;
 658       }
 659
 660       return 0;
 661     }
 662   }
 663
 664   return -1;
 665 }
 666
 667 ssize_t MojoDescRecvMsg(void* handle,
 668                         struct NaClImcTypedMsgHdr* msg,
 669                         int flags) {
 670   return -1;
 671 }
 672
 673 struct NaClDesc* MakeMojoDesc(struct NaClApp* nap) {
 674   struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER;
 675   funcs.Destroy = MojoDescDestroy;
 676   funcs.SendMsg = MojoDescSendMsg;
 677   funcs.RecvMsg = MojoDescRecvMsg;
 678   return NaClDescMakeCustomDesc(nap, &funcs);
 679 }
 680
 681 void MojoDisabledDescDestroy(void* handle) {
 682 }
 683
 684 ssize_t MojoDisabledDescSendMsg(void* handle,
 685                                 const struct NaClImcTypedMsgHdr* msg,
 686                                 int flags) {
 687   fprintf(stderr, "Mojo is not currently supported.");
 688   abort();
 689 }
 690
 691 ssize_t MojoDisabledDescRecvMsg(void* handle,
 692                                 struct NaClImcTypedMsgHdr* msg,
 693                                 int flags) {
 694   fprintf(stderr, "Mojo is not currently supported.");
 695   abort();
 696 }
 697
 698 struct NaClDesc* MakeDisabledMojoDesc(struct NaClApp* nap) {
 699   struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER;
 700   funcs.Destroy = MojoDisabledDescDestroy;
 701   funcs.SendMsg = MojoDisabledDescSendMsg;
 702   funcs.RecvMsg = MojoDisabledDescRecvMsg;
 703   return NaClDescMakeCustomDesc(nap, &funcs);
 704 }
 705
 706 }  // namespace
 707
 708 // The value for this FD must not conflict with uses inside Chromium. However,
 709 // mojo/nacl doesn't depend on any Chromium headers, so we can't use a #define
 710 // from there.
 711 #define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3)
 712
 713 void InjectMojo(struct NaClApp* nap) {
 714   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap));
 715   g_mojo_handle = MOJO_HANDLE_INVALID;
 716 }
 717
 718 void InjectMojo(struct NaClApp* nap, MojoHandle handle) {
 719   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap));
 720   g_mojo_handle = handle;
 721 }
 722
 723 void InjectDisabledMojo(struct NaClApp* nap) {
 724   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeDisabledMojoDesc(nap));
 725 }