| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2011 The Native Client 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 WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING |
| 6 // |
| 7 // Automatically generated code. See srpcgen.py |
| 8 // |
| 9 // NaCl Simple Remote Procedure Call interface abstractions. |
| 10 |
| 11 #include "untrusted/srpcgen/ppb_rpc.h" |
| 12 #ifdef __native_client__ |
| 13 #ifndef UNREFERENCED_PARAMETER |
| 14 #define UNREFERENCED_PARAMETER(P) do { (void) P; } while (0) |
| 15 #endif // UNREFERENCED_PARAMETER |
| 16 #else |
| 17 #include "native_client/src/include/portability.h" |
| 18 #endif // __native_client__ |
| 19 #include "native_client/src/shared/platform/nacl_check.h" |
| 20 #include "native_client/src/shared/ppapi_proxy/plugin_globals.h" |
| 21 #include "native_client/src/shared/srpc/nacl_srpc.h" |
| 22 #include "ppapi/c/pp_instance.h" |
| 23 #include "ppapi/c/pp_module.h" |
| 24 #include "ppapi/c/pp_resource.h" |
| 25 #include "ppapi/c/ppb_core.h" |
| 26 |
| 27 NaClSrpcError NaClFileRpcClient::StreamAsFile( |
| 28 NaClSrpcChannel* channel, |
| 29 PP_Instance instance, |
| 30 char* url, |
| 31 int32_t callback_id) { |
| 32 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 33 ("%s: PPAPI calls are not supported off the main thread\n", |
| 34 __FUNCTION__)); |
| 35 NaClSrpcError retval; |
| 36 retval = NaClSrpcInvokeBySignature( |
| 37 channel, |
| 38 "StreamAsFile:isi:", |
| 39 instance, |
| 40 url, |
| 41 callback_id |
| 42 ); |
| 43 return retval; |
| 44 } |
| 45 |
| 46 NaClSrpcError NaClFileRpcClient::GetFileDesc( |
| 47 NaClSrpcChannel* channel, |
| 48 PP_Instance instance, |
| 49 char* url, |
| 50 NaClSrpcImcDescType* file_desc) { |
| 51 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 52 ("%s: PPAPI calls are not supported off the main thread\n", |
| 53 __FUNCTION__)); |
| 54 NaClSrpcError retval; |
| 55 retval = NaClSrpcInvokeBySignature( |
| 56 channel, |
| 57 "GetFileDesc:is:h", |
| 58 instance, |
| 59 url, |
| 60 file_desc |
| 61 ); |
| 62 return retval; |
| 63 } |
| 64 |
| 65 NaClSrpcError PpbRpcClient::PPB_GetInterface( |
| 66 NaClSrpcChannel* channel, |
| 67 char* interface_name, |
| 68 int32_t* exports_interface_name) { |
| 69 NaClSrpcError retval; |
| 70 retval = NaClSrpcInvokeBySignature( |
| 71 channel, |
| 72 "PPB_GetInterface:s:i", |
| 73 interface_name, |
| 74 exports_interface_name |
| 75 ); |
| 76 return retval; |
| 77 } |
| 78 |
| 79 NaClSrpcError PpbAudioRpcClient::PPB_Audio_Create( |
| 80 NaClSrpcChannel* channel, |
| 81 PP_Instance instance, |
| 82 PP_Resource config, |
| 83 PP_Resource* out_resource) { |
| 84 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 85 ("%s: PPAPI calls are not supported off the main thread\n", |
| 86 __FUNCTION__)); |
| 87 NaClSrpcError retval; |
| 88 retval = NaClSrpcInvokeBySignature( |
| 89 channel, |
| 90 "PPB_Audio_Create:ii:i", |
| 91 instance, |
| 92 config, |
| 93 out_resource |
| 94 ); |
| 95 return retval; |
| 96 } |
| 97 |
| 98 NaClSrpcError PpbAudioRpcClient::PPB_Audio_IsAudio( |
| 99 NaClSrpcChannel* channel, |
| 100 PP_Resource resource, |
| 101 int32_t* out_bool) { |
| 102 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 103 ("%s: PPAPI calls are not supported off the main thread\n", |
| 104 __FUNCTION__)); |
| 105 NaClSrpcError retval; |
| 106 retval = NaClSrpcInvokeBySignature( |
| 107 channel, |
| 108 "PPB_Audio_IsAudio:i:i", |
| 109 resource, |
| 110 out_bool |
| 111 ); |
| 112 return retval; |
| 113 } |
| 114 |
| 115 NaClSrpcError PpbAudioRpcClient::PPB_Audio_GetCurrentConfig( |
| 116 NaClSrpcChannel* channel, |
| 117 PP_Resource resource, |
| 118 PP_Resource* out_resource) { |
| 119 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 120 ("%s: PPAPI calls are not supported off the main thread\n", |
| 121 __FUNCTION__)); |
| 122 NaClSrpcError retval; |
| 123 retval = NaClSrpcInvokeBySignature( |
| 124 channel, |
| 125 "PPB_Audio_GetCurrentConfig:i:i", |
| 126 resource, |
| 127 out_resource |
| 128 ); |
| 129 return retval; |
| 130 } |
| 131 |
| 132 NaClSrpcError PpbAudioRpcClient::PPB_Audio_StopPlayback( |
| 133 NaClSrpcChannel* channel, |
| 134 PP_Resource resource, |
| 135 int32_t* out_bool) { |
| 136 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 137 ("%s: PPAPI calls are not supported off the main thread\n", |
| 138 __FUNCTION__)); |
| 139 NaClSrpcError retval; |
| 140 retval = NaClSrpcInvokeBySignature( |
| 141 channel, |
| 142 "PPB_Audio_StopPlayback:i:i", |
| 143 resource, |
| 144 out_bool |
| 145 ); |
| 146 return retval; |
| 147 } |
| 148 |
| 149 NaClSrpcError PpbAudioRpcClient::PPB_Audio_StartPlayback( |
| 150 NaClSrpcChannel* channel, |
| 151 PP_Resource resource, |
| 152 int32_t* out_bool) { |
| 153 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 154 ("%s: PPAPI calls are not supported off the main thread\n", |
| 155 __FUNCTION__)); |
| 156 NaClSrpcError retval; |
| 157 retval = NaClSrpcInvokeBySignature( |
| 158 channel, |
| 159 "PPB_Audio_StartPlayback:i:i", |
| 160 resource, |
| 161 out_bool |
| 162 ); |
| 163 return retval; |
| 164 } |
| 165 |
| 166 NaClSrpcError PpbAudioConfigRpcClient::PPB_AudioConfig_CreateStereo16Bit( |
| 167 NaClSrpcChannel* channel, |
| 168 PP_Instance instance, |
| 169 int32_t sample_rate, |
| 170 int32_t sample_frame_count, |
| 171 PP_Resource* resource) { |
| 172 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 173 ("%s: PPAPI calls are not supported off the main thread\n", |
| 174 __FUNCTION__)); |
| 175 NaClSrpcError retval; |
| 176 retval = NaClSrpcInvokeBySignature( |
| 177 channel, |
| 178 "PPB_AudioConfig_CreateStereo16Bit:iii:i", |
| 179 instance, |
| 180 sample_rate, |
| 181 sample_frame_count, |
| 182 resource |
| 183 ); |
| 184 return retval; |
| 185 } |
| 186 |
| 187 NaClSrpcError PpbAudioConfigRpcClient::PPB_AudioConfig_IsAudioConfig( |
| 188 NaClSrpcChannel* channel, |
| 189 PP_Resource resource, |
| 190 int32_t* out_bool) { |
| 191 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 192 ("%s: PPAPI calls are not supported off the main thread\n", |
| 193 __FUNCTION__)); |
| 194 NaClSrpcError retval; |
| 195 retval = NaClSrpcInvokeBySignature( |
| 196 channel, |
| 197 "PPB_AudioConfig_IsAudioConfig:i:i", |
| 198 resource, |
| 199 out_bool |
| 200 ); |
| 201 return retval; |
| 202 } |
| 203 |
| 204 NaClSrpcError PpbAudioConfigRpcClient::PPB_AudioConfig_RecommendSampleFrameCount
( |
| 205 NaClSrpcChannel* channel, |
| 206 int32_t request_sample_rate, |
| 207 int32_t request_sample_frame_count, |
| 208 int32_t* out_sample_frame_count) { |
| 209 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 210 ("%s: PPAPI calls are not supported off the main thread\n", |
| 211 __FUNCTION__)); |
| 212 NaClSrpcError retval; |
| 213 retval = NaClSrpcInvokeBySignature( |
| 214 channel, |
| 215 "PPB_AudioConfig_RecommendSampleFrameCount:ii:i", |
| 216 request_sample_rate, |
| 217 request_sample_frame_count, |
| 218 out_sample_frame_count |
| 219 ); |
| 220 return retval; |
| 221 } |
| 222 |
| 223 NaClSrpcError PpbAudioConfigRpcClient::PPB_AudioConfig_GetSampleRate( |
| 224 NaClSrpcChannel* channel, |
| 225 PP_Resource resource, |
| 226 int32_t* sample_rate) { |
| 227 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 228 ("%s: PPAPI calls are not supported off the main thread\n", |
| 229 __FUNCTION__)); |
| 230 NaClSrpcError retval; |
| 231 retval = NaClSrpcInvokeBySignature( |
| 232 channel, |
| 233 "PPB_AudioConfig_GetSampleRate:i:i", |
| 234 resource, |
| 235 sample_rate |
| 236 ); |
| 237 return retval; |
| 238 } |
| 239 |
| 240 NaClSrpcError PpbAudioConfigRpcClient::PPB_AudioConfig_GetSampleFrameCount( |
| 241 NaClSrpcChannel* channel, |
| 242 PP_Resource resource, |
| 243 int32_t* sample_frame_count) { |
| 244 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 245 ("%s: PPAPI calls are not supported off the main thread\n", |
| 246 __FUNCTION__)); |
| 247 NaClSrpcError retval; |
| 248 retval = NaClSrpcInvokeBySignature( |
| 249 channel, |
| 250 "PPB_AudioConfig_GetSampleFrameCount:i:i", |
| 251 resource, |
| 252 sample_frame_count |
| 253 ); |
| 254 return retval; |
| 255 } |
| 256 |
| 257 NaClSrpcError PpbCoreRpcClient::PPB_Core_AddRefResource( |
| 258 NaClSrpcChannel* channel, |
| 259 PP_Resource resource) { |
| 260 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 261 ("%s: PPAPI calls are not supported off the main thread\n", |
| 262 __FUNCTION__)); |
| 263 NaClSrpcError retval; |
| 264 retval = NaClSrpcInvokeBySignature( |
| 265 channel, |
| 266 "PPB_Core_AddRefResource:i:", |
| 267 resource |
| 268 ); |
| 269 return retval; |
| 270 } |
| 271 |
| 272 NaClSrpcError PpbCoreRpcClient::PPB_Core_ReleaseResource( |
| 273 NaClSrpcChannel* channel, |
| 274 PP_Resource resource) { |
| 275 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 276 ("%s: PPAPI calls are not supported off the main thread\n", |
| 277 __FUNCTION__)); |
| 278 NaClSrpcError retval; |
| 279 retval = NaClSrpcInvokeBySignature( |
| 280 channel, |
| 281 "PPB_Core_ReleaseResource:i:", |
| 282 resource |
| 283 ); |
| 284 return retval; |
| 285 } |
| 286 |
| 287 NaClSrpcError PpbCoreRpcClient::ReleaseResourceMultipleTimes( |
| 288 NaClSrpcChannel* channel, |
| 289 PP_Resource resource, |
| 290 int32_t count) { |
| 291 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 292 ("%s: PPAPI calls are not supported off the main thread\n", |
| 293 __FUNCTION__)); |
| 294 NaClSrpcError retval; |
| 295 retval = NaClSrpcInvokeBySignature( |
| 296 channel, |
| 297 "ReleaseResourceMultipleTimes:ii:", |
| 298 resource, |
| 299 count |
| 300 ); |
| 301 return retval; |
| 302 } |
| 303 |
| 304 NaClSrpcError PpbCoreRpcClient::PPB_Core_GetTime( |
| 305 NaClSrpcChannel* channel, |
| 306 double* time) { |
| 307 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 308 ("%s: PPAPI calls are not supported off the main thread\n", |
| 309 __FUNCTION__)); |
| 310 NaClSrpcError retval; |
| 311 retval = NaClSrpcInvokeBySignature( |
| 312 channel, |
| 313 "PPB_Core_GetTime::d", |
| 314 time |
| 315 ); |
| 316 return retval; |
| 317 } |
| 318 |
| 319 NaClSrpcError PpbCoreRpcClient::PPB_Core_GetTimeTicks( |
| 320 NaClSrpcChannel* channel, |
| 321 double* time_ticks) { |
| 322 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 323 ("%s: PPAPI calls are not supported off the main thread\n", |
| 324 __FUNCTION__)); |
| 325 NaClSrpcError retval; |
| 326 retval = NaClSrpcInvokeBySignature( |
| 327 channel, |
| 328 "PPB_Core_GetTimeTicks::d", |
| 329 time_ticks |
| 330 ); |
| 331 return retval; |
| 332 } |
| 333 |
| 334 NaClSrpcError PpbCoreRpcClient::PPB_Core_CallOnMainThread( |
| 335 NaClSrpcChannel* channel, |
| 336 int32_t delay_in_milliseconds, |
| 337 int32_t callback_id, |
| 338 int32_t result) { |
| 339 NaClSrpcError retval; |
| 340 retval = NaClSrpcInvokeBySignature( |
| 341 channel, |
| 342 "PPB_Core_CallOnMainThread:iii:", |
| 343 delay_in_milliseconds, |
| 344 callback_id, |
| 345 result |
| 346 ); |
| 347 return retval; |
| 348 } |
| 349 |
| 350 NaClSrpcError PpbCursorControlRpcClient::PPB_CursorControl_SetCursor( |
| 351 NaClSrpcChannel* channel, |
| 352 PP_Instance instance, |
| 353 int32_t type, |
| 354 PP_Resource custom_image, |
| 355 nacl_abi_size_t hot_spot_bytes, char* hot_spot, |
| 356 int32_t* success) { |
| 357 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 358 ("%s: PPAPI calls are not supported off the main thread\n", |
| 359 __FUNCTION__)); |
| 360 NaClSrpcError retval; |
| 361 retval = NaClSrpcInvokeBySignature( |
| 362 channel, |
| 363 "PPB_CursorControl_SetCursor:iiiC:i", |
| 364 instance, |
| 365 type, |
| 366 custom_image, |
| 367 hot_spot_bytes, hot_spot, |
| 368 success |
| 369 ); |
| 370 return retval; |
| 371 } |
| 372 |
| 373 NaClSrpcError PpbCursorControlRpcClient::PPB_CursorControl_LockCursor( |
| 374 NaClSrpcChannel* channel, |
| 375 PP_Instance instance, |
| 376 int32_t* success) { |
| 377 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 378 ("%s: PPAPI calls are not supported off the main thread\n", |
| 379 __FUNCTION__)); |
| 380 NaClSrpcError retval; |
| 381 retval = NaClSrpcInvokeBySignature( |
| 382 channel, |
| 383 "PPB_CursorControl_LockCursor:i:i", |
| 384 instance, |
| 385 success |
| 386 ); |
| 387 return retval; |
| 388 } |
| 389 |
| 390 NaClSrpcError PpbCursorControlRpcClient::PPB_CursorControl_UnlockCursor( |
| 391 NaClSrpcChannel* channel, |
| 392 PP_Instance instance, |
| 393 int32_t* success) { |
| 394 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 395 ("%s: PPAPI calls are not supported off the main thread\n", |
| 396 __FUNCTION__)); |
| 397 NaClSrpcError retval; |
| 398 retval = NaClSrpcInvokeBySignature( |
| 399 channel, |
| 400 "PPB_CursorControl_UnlockCursor:i:i", |
| 401 instance, |
| 402 success |
| 403 ); |
| 404 return retval; |
| 405 } |
| 406 |
| 407 NaClSrpcError PpbCursorControlRpcClient::PPB_CursorControl_HasCursorLock( |
| 408 NaClSrpcChannel* channel, |
| 409 PP_Instance instance, |
| 410 int32_t* success) { |
| 411 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 412 ("%s: PPAPI calls are not supported off the main thread\n", |
| 413 __FUNCTION__)); |
| 414 NaClSrpcError retval; |
| 415 retval = NaClSrpcInvokeBySignature( |
| 416 channel, |
| 417 "PPB_CursorControl_HasCursorLock:i:i", |
| 418 instance, |
| 419 success |
| 420 ); |
| 421 return retval; |
| 422 } |
| 423 |
| 424 NaClSrpcError PpbCursorControlRpcClient::PPB_CursorControl_CanLockCursor( |
| 425 NaClSrpcChannel* channel, |
| 426 PP_Instance instance, |
| 427 int32_t* success) { |
| 428 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 429 ("%s: PPAPI calls are not supported off the main thread\n", |
| 430 __FUNCTION__)); |
| 431 NaClSrpcError retval; |
| 432 retval = NaClSrpcInvokeBySignature( |
| 433 channel, |
| 434 "PPB_CursorControl_CanLockCursor:i:i", |
| 435 instance, |
| 436 success |
| 437 ); |
| 438 return retval; |
| 439 } |
| 440 |
| 441 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Create( |
| 442 NaClSrpcChannel* channel, |
| 443 PP_Instance instance, |
| 444 PP_Resource* resource) { |
| 445 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 446 ("%s: PPAPI calls are not supported off the main thread\n", |
| 447 __FUNCTION__)); |
| 448 NaClSrpcError retval; |
| 449 retval = NaClSrpcInvokeBySignature( |
| 450 channel, |
| 451 "PPB_FileIO_Create:i:i", |
| 452 instance, |
| 453 resource |
| 454 ); |
| 455 return retval; |
| 456 } |
| 457 |
| 458 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_IsFileIO( |
| 459 NaClSrpcChannel* channel, |
| 460 PP_Resource resource, |
| 461 int32_t* success) { |
| 462 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 463 ("%s: PPAPI calls are not supported off the main thread\n", |
| 464 __FUNCTION__)); |
| 465 NaClSrpcError retval; |
| 466 retval = NaClSrpcInvokeBySignature( |
| 467 channel, |
| 468 "PPB_FileIO_IsFileIO:i:i", |
| 469 resource, |
| 470 success |
| 471 ); |
| 472 return retval; |
| 473 } |
| 474 |
| 475 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Open( |
| 476 NaClSrpcChannel* channel, |
| 477 PP_Resource file_io, |
| 478 PP_Resource file_ref, |
| 479 int32_t open_flags, |
| 480 int32_t callback_id, |
| 481 int32_t* pp_error) { |
| 482 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 483 ("%s: PPAPI calls are not supported off the main thread\n", |
| 484 __FUNCTION__)); |
| 485 NaClSrpcError retval; |
| 486 retval = NaClSrpcInvokeBySignature( |
| 487 channel, |
| 488 "PPB_FileIO_Open:iiii:i", |
| 489 file_io, |
| 490 file_ref, |
| 491 open_flags, |
| 492 callback_id, |
| 493 pp_error |
| 494 ); |
| 495 return retval; |
| 496 } |
| 497 |
| 498 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Query( |
| 499 NaClSrpcChannel* channel, |
| 500 PP_Resource file_io, |
| 501 int32_t bytes_to_read, |
| 502 int32_t callback_id, |
| 503 nacl_abi_size_t* info_bytes, char* info, |
| 504 int32_t* pp_error) { |
| 505 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 506 ("%s: PPAPI calls are not supported off the main thread\n", |
| 507 __FUNCTION__)); |
| 508 NaClSrpcError retval; |
| 509 retval = NaClSrpcInvokeBySignature( |
| 510 channel, |
| 511 "PPB_FileIO_Query:iii:Ci", |
| 512 file_io, |
| 513 bytes_to_read, |
| 514 callback_id, |
| 515 info_bytes, info, |
| 516 pp_error |
| 517 ); |
| 518 return retval; |
| 519 } |
| 520 |
| 521 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Touch( |
| 522 NaClSrpcChannel* channel, |
| 523 PP_Resource file_io, |
| 524 double last_access_time, |
| 525 double last_modified_time, |
| 526 int32_t callback_id, |
| 527 int32_t* pp_error) { |
| 528 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 529 ("%s: PPAPI calls are not supported off the main thread\n", |
| 530 __FUNCTION__)); |
| 531 NaClSrpcError retval; |
| 532 retval = NaClSrpcInvokeBySignature( |
| 533 channel, |
| 534 "PPB_FileIO_Touch:iddi:i", |
| 535 file_io, |
| 536 last_access_time, |
| 537 last_modified_time, |
| 538 callback_id, |
| 539 pp_error |
| 540 ); |
| 541 return retval; |
| 542 } |
| 543 |
| 544 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Read( |
| 545 NaClSrpcChannel* channel, |
| 546 PP_Resource file_io, |
| 547 int64_t offset, |
| 548 int32_t bytes_to_read, |
| 549 int32_t callback_id, |
| 550 nacl_abi_size_t* buffer_bytes, char* buffer, |
| 551 int32_t* pp_error_or_bytes) { |
| 552 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 553 ("%s: PPAPI calls are not supported off the main thread\n", |
| 554 __FUNCTION__)); |
| 555 NaClSrpcError retval; |
| 556 retval = NaClSrpcInvokeBySignature( |
| 557 channel, |
| 558 "PPB_FileIO_Read:ilii:Ci", |
| 559 file_io, |
| 560 offset, |
| 561 bytes_to_read, |
| 562 callback_id, |
| 563 buffer_bytes, buffer, |
| 564 pp_error_or_bytes |
| 565 ); |
| 566 return retval; |
| 567 } |
| 568 |
| 569 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Write( |
| 570 NaClSrpcChannel* channel, |
| 571 PP_Resource file_io, |
| 572 int64_t offset, |
| 573 nacl_abi_size_t buffer_bytes, char* buffer, |
| 574 int32_t bytes_to_write, |
| 575 int32_t callback_id, |
| 576 int32_t* pp_error_or_bytes) { |
| 577 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 578 ("%s: PPAPI calls are not supported off the main thread\n", |
| 579 __FUNCTION__)); |
| 580 NaClSrpcError retval; |
| 581 retval = NaClSrpcInvokeBySignature( |
| 582 channel, |
| 583 "PPB_FileIO_Write:ilCii:i", |
| 584 file_io, |
| 585 offset, |
| 586 buffer_bytes, buffer, |
| 587 bytes_to_write, |
| 588 callback_id, |
| 589 pp_error_or_bytes |
| 590 ); |
| 591 return retval; |
| 592 } |
| 593 |
| 594 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_SetLength( |
| 595 NaClSrpcChannel* channel, |
| 596 PP_Resource file_io, |
| 597 int64_t length, |
| 598 int32_t callback_id, |
| 599 int32_t* pp_error) { |
| 600 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 601 ("%s: PPAPI calls are not supported off the main thread\n", |
| 602 __FUNCTION__)); |
| 603 NaClSrpcError retval; |
| 604 retval = NaClSrpcInvokeBySignature( |
| 605 channel, |
| 606 "PPB_FileIO_SetLength:ili:i", |
| 607 file_io, |
| 608 length, |
| 609 callback_id, |
| 610 pp_error |
| 611 ); |
| 612 return retval; |
| 613 } |
| 614 |
| 615 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Flush( |
| 616 NaClSrpcChannel* channel, |
| 617 PP_Resource file_io, |
| 618 int32_t callback_id, |
| 619 int32_t* pp_error) { |
| 620 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 621 ("%s: PPAPI calls are not supported off the main thread\n", |
| 622 __FUNCTION__)); |
| 623 NaClSrpcError retval; |
| 624 retval = NaClSrpcInvokeBySignature( |
| 625 channel, |
| 626 "PPB_FileIO_Flush:ii:i", |
| 627 file_io, |
| 628 callback_id, |
| 629 pp_error |
| 630 ); |
| 631 return retval; |
| 632 } |
| 633 |
| 634 NaClSrpcError PpbFileIORpcClient::PPB_FileIO_Close( |
| 635 NaClSrpcChannel* channel, |
| 636 PP_Resource file_io) { |
| 637 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 638 ("%s: PPAPI calls are not supported off the main thread\n", |
| 639 __FUNCTION__)); |
| 640 NaClSrpcError retval; |
| 641 retval = NaClSrpcInvokeBySignature( |
| 642 channel, |
| 643 "PPB_FileIO_Close:i:", |
| 644 file_io |
| 645 ); |
| 646 return retval; |
| 647 } |
| 648 |
| 649 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_Create( |
| 650 NaClSrpcChannel* channel, |
| 651 PP_Resource file_system, |
| 652 nacl_abi_size_t path_bytes, char* path, |
| 653 PP_Resource* resource) { |
| 654 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 655 ("%s: PPAPI calls are not supported off the main thread\n", |
| 656 __FUNCTION__)); |
| 657 NaClSrpcError retval; |
| 658 retval = NaClSrpcInvokeBySignature( |
| 659 channel, |
| 660 "PPB_FileRef_Create:iC:i", |
| 661 file_system, |
| 662 path_bytes, path, |
| 663 resource |
| 664 ); |
| 665 return retval; |
| 666 } |
| 667 |
| 668 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_IsFileRef( |
| 669 NaClSrpcChannel* channel, |
| 670 PP_Resource resource, |
| 671 int32_t* success) { |
| 672 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 673 ("%s: PPAPI calls are not supported off the main thread\n", |
| 674 __FUNCTION__)); |
| 675 NaClSrpcError retval; |
| 676 retval = NaClSrpcInvokeBySignature( |
| 677 channel, |
| 678 "PPB_FileRef_IsFileRef:i:i", |
| 679 resource, |
| 680 success |
| 681 ); |
| 682 return retval; |
| 683 } |
| 684 |
| 685 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_GetFileSystemType( |
| 686 NaClSrpcChannel* channel, |
| 687 PP_Resource file_ref, |
| 688 int32_t* file_system_type) { |
| 689 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 690 ("%s: PPAPI calls are not supported off the main thread\n", |
| 691 __FUNCTION__)); |
| 692 NaClSrpcError retval; |
| 693 retval = NaClSrpcInvokeBySignature( |
| 694 channel, |
| 695 "PPB_FileRef_GetFileSystemType:i:i", |
| 696 file_ref, |
| 697 file_system_type |
| 698 ); |
| 699 return retval; |
| 700 } |
| 701 |
| 702 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_GetName( |
| 703 NaClSrpcChannel* channel, |
| 704 PP_Resource file_ref, |
| 705 nacl_abi_size_t* name_bytes, char* name) { |
| 706 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 707 ("%s: PPAPI calls are not supported off the main thread\n", |
| 708 __FUNCTION__)); |
| 709 NaClSrpcError retval; |
| 710 retval = NaClSrpcInvokeBySignature( |
| 711 channel, |
| 712 "PPB_FileRef_GetName:i:C", |
| 713 file_ref, |
| 714 name_bytes, name |
| 715 ); |
| 716 return retval; |
| 717 } |
| 718 |
| 719 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_GetPath( |
| 720 NaClSrpcChannel* channel, |
| 721 PP_Resource file_ref, |
| 722 nacl_abi_size_t* path_bytes, char* path) { |
| 723 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 724 ("%s: PPAPI calls are not supported off the main thread\n", |
| 725 __FUNCTION__)); |
| 726 NaClSrpcError retval; |
| 727 retval = NaClSrpcInvokeBySignature( |
| 728 channel, |
| 729 "PPB_FileRef_GetPath:i:C", |
| 730 file_ref, |
| 731 path_bytes, path |
| 732 ); |
| 733 return retval; |
| 734 } |
| 735 |
| 736 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_GetParent( |
| 737 NaClSrpcChannel* channel, |
| 738 PP_Resource file_ref, |
| 739 PP_Resource* parent) { |
| 740 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 741 ("%s: PPAPI calls are not supported off the main thread\n", |
| 742 __FUNCTION__)); |
| 743 NaClSrpcError retval; |
| 744 retval = NaClSrpcInvokeBySignature( |
| 745 channel, |
| 746 "PPB_FileRef_GetParent:i:i", |
| 747 file_ref, |
| 748 parent |
| 749 ); |
| 750 return retval; |
| 751 } |
| 752 |
| 753 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_MakeDirectory( |
| 754 NaClSrpcChannel* channel, |
| 755 PP_Resource directory_ref, |
| 756 int32_t make_ancestors, |
| 757 int32_t callback_id, |
| 758 int32_t* pp_error) { |
| 759 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 760 ("%s: PPAPI calls are not supported off the main thread\n", |
| 761 __FUNCTION__)); |
| 762 NaClSrpcError retval; |
| 763 retval = NaClSrpcInvokeBySignature( |
| 764 channel, |
| 765 "PPB_FileRef_MakeDirectory:iii:i", |
| 766 directory_ref, |
| 767 make_ancestors, |
| 768 callback_id, |
| 769 pp_error |
| 770 ); |
| 771 return retval; |
| 772 } |
| 773 |
| 774 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_Touch( |
| 775 NaClSrpcChannel* channel, |
| 776 PP_Resource file_ref, |
| 777 double last_access_time, |
| 778 double last_modified_time, |
| 779 int32_t callback_id, |
| 780 int32_t* pp_error) { |
| 781 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 782 ("%s: PPAPI calls are not supported off the main thread\n", |
| 783 __FUNCTION__)); |
| 784 NaClSrpcError retval; |
| 785 retval = NaClSrpcInvokeBySignature( |
| 786 channel, |
| 787 "PPB_FileRef_Touch:iddi:i", |
| 788 file_ref, |
| 789 last_access_time, |
| 790 last_modified_time, |
| 791 callback_id, |
| 792 pp_error |
| 793 ); |
| 794 return retval; |
| 795 } |
| 796 |
| 797 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_Delete( |
| 798 NaClSrpcChannel* channel, |
| 799 PP_Resource file_ref, |
| 800 int32_t callback_id, |
| 801 int32_t* pp_error) { |
| 802 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 803 ("%s: PPAPI calls are not supported off the main thread\n", |
| 804 __FUNCTION__)); |
| 805 NaClSrpcError retval; |
| 806 retval = NaClSrpcInvokeBySignature( |
| 807 channel, |
| 808 "PPB_FileRef_Delete:ii:i", |
| 809 file_ref, |
| 810 callback_id, |
| 811 pp_error |
| 812 ); |
| 813 return retval; |
| 814 } |
| 815 |
| 816 NaClSrpcError PpbFileRefRpcClient::PPB_FileRef_Rename( |
| 817 NaClSrpcChannel* channel, |
| 818 PP_Resource file_ref, |
| 819 PP_Resource new_file_ref, |
| 820 int32_t callback_id, |
| 821 int32_t* pp_error) { |
| 822 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 823 ("%s: PPAPI calls are not supported off the main thread\n", |
| 824 __FUNCTION__)); |
| 825 NaClSrpcError retval; |
| 826 retval = NaClSrpcInvokeBySignature( |
| 827 channel, |
| 828 "PPB_FileRef_Rename:iii:i", |
| 829 file_ref, |
| 830 new_file_ref, |
| 831 callback_id, |
| 832 pp_error |
| 833 ); |
| 834 return retval; |
| 835 } |
| 836 |
| 837 NaClSrpcError PpbFileSystemRpcClient::PPB_FileSystem_Create( |
| 838 NaClSrpcChannel* channel, |
| 839 PP_Instance instance, |
| 840 int32_t file_system_type, |
| 841 PP_Resource* resource) { |
| 842 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 843 ("%s: PPAPI calls are not supported off the main thread\n", |
| 844 __FUNCTION__)); |
| 845 NaClSrpcError retval; |
| 846 retval = NaClSrpcInvokeBySignature( |
| 847 channel, |
| 848 "PPB_FileSystem_Create:ii:i", |
| 849 instance, |
| 850 file_system_type, |
| 851 resource |
| 852 ); |
| 853 return retval; |
| 854 } |
| 855 |
| 856 NaClSrpcError PpbFileSystemRpcClient::PPB_FileSystem_IsFileSystem( |
| 857 NaClSrpcChannel* channel, |
| 858 PP_Resource resource, |
| 859 int32_t* success) { |
| 860 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 861 ("%s: PPAPI calls are not supported off the main thread\n", |
| 862 __FUNCTION__)); |
| 863 NaClSrpcError retval; |
| 864 retval = NaClSrpcInvokeBySignature( |
| 865 channel, |
| 866 "PPB_FileSystem_IsFileSystem:i:i", |
| 867 resource, |
| 868 success |
| 869 ); |
| 870 return retval; |
| 871 } |
| 872 |
| 873 NaClSrpcError PpbFileSystemRpcClient::PPB_FileSystem_Open( |
| 874 NaClSrpcChannel* channel, |
| 875 PP_Resource file_system, |
| 876 int64_t expected_size, |
| 877 int32_t callback_id, |
| 878 int32_t* pp_error) { |
| 879 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 880 ("%s: PPAPI calls are not supported off the main thread\n", |
| 881 __FUNCTION__)); |
| 882 NaClSrpcError retval; |
| 883 retval = NaClSrpcInvokeBySignature( |
| 884 channel, |
| 885 "PPB_FileSystem_Open:ili:i", |
| 886 file_system, |
| 887 expected_size, |
| 888 callback_id, |
| 889 pp_error |
| 890 ); |
| 891 return retval; |
| 892 } |
| 893 |
| 894 NaClSrpcError PpbFileSystemRpcClient::PPB_FileSystem_GetType( |
| 895 NaClSrpcChannel* channel, |
| 896 PP_Resource file_system, |
| 897 int32_t* type) { |
| 898 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 899 ("%s: PPAPI calls are not supported off the main thread\n", |
| 900 __FUNCTION__)); |
| 901 NaClSrpcError retval; |
| 902 retval = NaClSrpcInvokeBySignature( |
| 903 channel, |
| 904 "PPB_FileSystem_GetType:i:i", |
| 905 file_system, |
| 906 type |
| 907 ); |
| 908 return retval; |
| 909 } |
| 910 |
| 911 NaClSrpcError PpbFindRpcClient::PPB_Find_NumberOfFindResultsChanged( |
| 912 NaClSrpcChannel* channel, |
| 913 PP_Instance instance, |
| 914 int32_t total, |
| 915 int32_t final_result) { |
| 916 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 917 ("%s: PPAPI calls are not supported off the main thread\n", |
| 918 __FUNCTION__)); |
| 919 NaClSrpcError retval; |
| 920 retval = NaClSrpcInvokeBySignature( |
| 921 channel, |
| 922 "PPB_Find_NumberOfFindResultsChanged:iii:", |
| 923 instance, |
| 924 total, |
| 925 final_result |
| 926 ); |
| 927 return retval; |
| 928 } |
| 929 |
| 930 NaClSrpcError PpbFindRpcClient::PPB_Find_SelectedFindResultChanged( |
| 931 NaClSrpcChannel* channel, |
| 932 PP_Instance instance, |
| 933 int32_t index) { |
| 934 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 935 ("%s: PPAPI calls are not supported off the main thread\n", |
| 936 __FUNCTION__)); |
| 937 NaClSrpcError retval; |
| 938 retval = NaClSrpcInvokeBySignature( |
| 939 channel, |
| 940 "PPB_Find_SelectedFindResultChanged:ii:", |
| 941 instance, |
| 942 index |
| 943 ); |
| 944 return retval; |
| 945 } |
| 946 |
| 947 NaClSrpcError PpbFontRpcClient::PPB_Font_GetFontFamilies( |
| 948 NaClSrpcChannel* channel, |
| 949 PP_Instance instance, |
| 950 nacl_abi_size_t* font_families_bytes, char* font_families) { |
| 951 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 952 ("%s: PPAPI calls are not supported off the main thread\n", |
| 953 __FUNCTION__)); |
| 954 NaClSrpcError retval; |
| 955 retval = NaClSrpcInvokeBySignature( |
| 956 channel, |
| 957 "PPB_Font_GetFontFamilies:i:C", |
| 958 instance, |
| 959 font_families_bytes, font_families |
| 960 ); |
| 961 return retval; |
| 962 } |
| 963 |
| 964 NaClSrpcError PpbFontRpcClient::PPB_Font_Create( |
| 965 NaClSrpcChannel* channel, |
| 966 PP_Instance instance, |
| 967 nacl_abi_size_t description_bytes, char* description, |
| 968 nacl_abi_size_t face_bytes, char* face, |
| 969 PP_Resource* font) { |
| 970 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 971 ("%s: PPAPI calls are not supported off the main thread\n", |
| 972 __FUNCTION__)); |
| 973 NaClSrpcError retval; |
| 974 retval = NaClSrpcInvokeBySignature( |
| 975 channel, |
| 976 "PPB_Font_Create:iCC:i", |
| 977 instance, |
| 978 description_bytes, description, |
| 979 face_bytes, face, |
| 980 font |
| 981 ); |
| 982 return retval; |
| 983 } |
| 984 |
| 985 NaClSrpcError PpbFontRpcClient::PPB_Font_IsFont( |
| 986 NaClSrpcChannel* channel, |
| 987 PP_Resource resource, |
| 988 int32_t* is_font) { |
| 989 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 990 ("%s: PPAPI calls are not supported off the main thread\n", |
| 991 __FUNCTION__)); |
| 992 NaClSrpcError retval; |
| 993 retval = NaClSrpcInvokeBySignature( |
| 994 channel, |
| 995 "PPB_Font_IsFont:i:i", |
| 996 resource, |
| 997 is_font |
| 998 ); |
| 999 return retval; |
| 1000 } |
| 1001 |
| 1002 NaClSrpcError PpbFontRpcClient::PPB_Font_Describe( |
| 1003 NaClSrpcChannel* channel, |
| 1004 PP_Resource font, |
| 1005 nacl_abi_size_t* description_bytes, char* description, |
| 1006 nacl_abi_size_t* face_bytes, char* face, |
| 1007 nacl_abi_size_t* metrics_bytes, char* metrics, |
| 1008 int32_t* success) { |
| 1009 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1010 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1011 __FUNCTION__)); |
| 1012 NaClSrpcError retval; |
| 1013 retval = NaClSrpcInvokeBySignature( |
| 1014 channel, |
| 1015 "PPB_Font_Describe:i:CCCi", |
| 1016 font, |
| 1017 description_bytes, description, |
| 1018 face_bytes, face, |
| 1019 metrics_bytes, metrics, |
| 1020 success |
| 1021 ); |
| 1022 return retval; |
| 1023 } |
| 1024 |
| 1025 NaClSrpcError PpbFontRpcClient::PPB_Font_DrawTextAt( |
| 1026 NaClSrpcChannel* channel, |
| 1027 PP_Resource font, |
| 1028 PP_Resource image_data, |
| 1029 nacl_abi_size_t text_run_bytes, char* text_run, |
| 1030 nacl_abi_size_t text_bytes, char* text, |
| 1031 nacl_abi_size_t position_bytes, char* position, |
| 1032 int32_t color, |
| 1033 nacl_abi_size_t clip_bytes, char* clip, |
| 1034 int32_t image_data_is_opaque, |
| 1035 int32_t* success) { |
| 1036 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1037 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1038 __FUNCTION__)); |
| 1039 NaClSrpcError retval; |
| 1040 retval = NaClSrpcInvokeBySignature( |
| 1041 channel, |
| 1042 "PPB_Font_DrawTextAt:iiCCCiCi:i", |
| 1043 font, |
| 1044 image_data, |
| 1045 text_run_bytes, text_run, |
| 1046 text_bytes, text, |
| 1047 position_bytes, position, |
| 1048 color, |
| 1049 clip_bytes, clip, |
| 1050 image_data_is_opaque, |
| 1051 success |
| 1052 ); |
| 1053 return retval; |
| 1054 } |
| 1055 |
| 1056 NaClSrpcError PpbFontRpcClient::PPB_Font_MeasureText( |
| 1057 NaClSrpcChannel* channel, |
| 1058 PP_Resource font, |
| 1059 nacl_abi_size_t text_run_bytes, char* text_run, |
| 1060 nacl_abi_size_t text_bytes, char* text, |
| 1061 int32_t* width) { |
| 1062 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1063 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1064 __FUNCTION__)); |
| 1065 NaClSrpcError retval; |
| 1066 retval = NaClSrpcInvokeBySignature( |
| 1067 channel, |
| 1068 "PPB_Font_MeasureText:iCC:i", |
| 1069 font, |
| 1070 text_run_bytes, text_run, |
| 1071 text_bytes, text, |
| 1072 width |
| 1073 ); |
| 1074 return retval; |
| 1075 } |
| 1076 |
| 1077 NaClSrpcError PpbFontRpcClient::PPB_Font_CharacterOffsetForPixel( |
| 1078 NaClSrpcChannel* channel, |
| 1079 PP_Resource font, |
| 1080 nacl_abi_size_t text_run_bytes, char* text_run, |
| 1081 nacl_abi_size_t text_bytes, char* text, |
| 1082 int32_t pixel_position, |
| 1083 int32_t* offset) { |
| 1084 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1085 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1086 __FUNCTION__)); |
| 1087 NaClSrpcError retval; |
| 1088 retval = NaClSrpcInvokeBySignature( |
| 1089 channel, |
| 1090 "PPB_Font_CharacterOffsetForPixel:iCCi:i", |
| 1091 font, |
| 1092 text_run_bytes, text_run, |
| 1093 text_bytes, text, |
| 1094 pixel_position, |
| 1095 offset |
| 1096 ); |
| 1097 return retval; |
| 1098 } |
| 1099 |
| 1100 NaClSrpcError PpbFontRpcClient::PPB_Font_PixelOffsetForCharacter( |
| 1101 NaClSrpcChannel* channel, |
| 1102 PP_Resource font, |
| 1103 nacl_abi_size_t text_run_bytes, char* text_run, |
| 1104 nacl_abi_size_t text_bytes, char* text, |
| 1105 int32_t char_offset, |
| 1106 int32_t* offset) { |
| 1107 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1108 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1109 __FUNCTION__)); |
| 1110 NaClSrpcError retval; |
| 1111 retval = NaClSrpcInvokeBySignature( |
| 1112 channel, |
| 1113 "PPB_Font_PixelOffsetForCharacter:iCCi:i", |
| 1114 font, |
| 1115 text_run_bytes, text_run, |
| 1116 text_bytes, text, |
| 1117 char_offset, |
| 1118 offset |
| 1119 ); |
| 1120 return retval; |
| 1121 } |
| 1122 |
| 1123 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_Create( |
| 1124 NaClSrpcChannel* channel, |
| 1125 PP_Instance instance, |
| 1126 nacl_abi_size_t size_bytes, char* size, |
| 1127 int32_t is_always_opaque, |
| 1128 PP_Resource* resource) { |
| 1129 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1130 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1131 __FUNCTION__)); |
| 1132 NaClSrpcError retval; |
| 1133 retval = NaClSrpcInvokeBySignature( |
| 1134 channel, |
| 1135 "PPB_Graphics2D_Create:iCi:i", |
| 1136 instance, |
| 1137 size_bytes, size, |
| 1138 is_always_opaque, |
| 1139 resource |
| 1140 ); |
| 1141 return retval; |
| 1142 } |
| 1143 |
| 1144 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_IsGraphics2D( |
| 1145 NaClSrpcChannel* channel, |
| 1146 PP_Resource resource, |
| 1147 int32_t* success) { |
| 1148 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1149 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1150 __FUNCTION__)); |
| 1151 NaClSrpcError retval; |
| 1152 retval = NaClSrpcInvokeBySignature( |
| 1153 channel, |
| 1154 "PPB_Graphics2D_IsGraphics2D:i:i", |
| 1155 resource, |
| 1156 success |
| 1157 ); |
| 1158 return retval; |
| 1159 } |
| 1160 |
| 1161 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_Describe( |
| 1162 NaClSrpcChannel* channel, |
| 1163 PP_Resource graphics_2d, |
| 1164 nacl_abi_size_t* size_bytes, char* size, |
| 1165 int32_t* is_always_opaque, |
| 1166 int32_t* success) { |
| 1167 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1168 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1169 __FUNCTION__)); |
| 1170 NaClSrpcError retval; |
| 1171 retval = NaClSrpcInvokeBySignature( |
| 1172 channel, |
| 1173 "PPB_Graphics2D_Describe:i:Cii", |
| 1174 graphics_2d, |
| 1175 size_bytes, size, |
| 1176 is_always_opaque, |
| 1177 success |
| 1178 ); |
| 1179 return retval; |
| 1180 } |
| 1181 |
| 1182 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_PaintImageData( |
| 1183 NaClSrpcChannel* channel, |
| 1184 PP_Resource graphics_2d, |
| 1185 PP_Resource image, |
| 1186 nacl_abi_size_t top_left_bytes, char* top_left, |
| 1187 nacl_abi_size_t src_rect_bytes, char* src_rect) { |
| 1188 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1189 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1190 __FUNCTION__)); |
| 1191 NaClSrpcError retval; |
| 1192 retval = NaClSrpcInvokeBySignature( |
| 1193 channel, |
| 1194 "PPB_Graphics2D_PaintImageData:iiCC:", |
| 1195 graphics_2d, |
| 1196 image, |
| 1197 top_left_bytes, top_left, |
| 1198 src_rect_bytes, src_rect |
| 1199 ); |
| 1200 return retval; |
| 1201 } |
| 1202 |
| 1203 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_Scroll( |
| 1204 NaClSrpcChannel* channel, |
| 1205 PP_Resource graphics_2d, |
| 1206 nacl_abi_size_t clip_rect_bytes, char* clip_rect, |
| 1207 nacl_abi_size_t amount_bytes, char* amount) { |
| 1208 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1209 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1210 __FUNCTION__)); |
| 1211 NaClSrpcError retval; |
| 1212 retval = NaClSrpcInvokeBySignature( |
| 1213 channel, |
| 1214 "PPB_Graphics2D_Scroll:iCC:", |
| 1215 graphics_2d, |
| 1216 clip_rect_bytes, clip_rect, |
| 1217 amount_bytes, amount |
| 1218 ); |
| 1219 return retval; |
| 1220 } |
| 1221 |
| 1222 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_ReplaceContents( |
| 1223 NaClSrpcChannel* channel, |
| 1224 PP_Resource graphics_2d, |
| 1225 PP_Resource image) { |
| 1226 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1227 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1228 __FUNCTION__)); |
| 1229 NaClSrpcError retval; |
| 1230 retval = NaClSrpcInvokeBySignature( |
| 1231 channel, |
| 1232 "PPB_Graphics2D_ReplaceContents:ii:", |
| 1233 graphics_2d, |
| 1234 image |
| 1235 ); |
| 1236 return retval; |
| 1237 } |
| 1238 |
| 1239 NaClSrpcError PpbGraphics2DRpcClient::PPB_Graphics2D_Flush( |
| 1240 NaClSrpcChannel* channel, |
| 1241 PP_Resource graphics_2d, |
| 1242 int32_t callback_id, |
| 1243 int32_t* pp_error) { |
| 1244 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1245 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1246 __FUNCTION__)); |
| 1247 NaClSrpcError retval; |
| 1248 retval = NaClSrpcInvokeBySignature( |
| 1249 channel, |
| 1250 "PPB_Graphics2D_Flush:ii:i", |
| 1251 graphics_2d, |
| 1252 callback_id, |
| 1253 pp_error |
| 1254 ); |
| 1255 return retval; |
| 1256 } |
| 1257 |
| 1258 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3D_Create( |
| 1259 NaClSrpcChannel* channel, |
| 1260 PP_Instance instance, |
| 1261 PP_Resource share_context, |
| 1262 nacl_abi_size_t attrib_list_bytes, int32_t* attrib_list, |
| 1263 PP_Resource* resource_id) { |
| 1264 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1265 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1266 __FUNCTION__)); |
| 1267 NaClSrpcError retval; |
| 1268 retval = NaClSrpcInvokeBySignature( |
| 1269 channel, |
| 1270 "PPB_Graphics3D_Create:iiI:i", |
| 1271 instance, |
| 1272 share_context, |
| 1273 attrib_list_bytes, attrib_list, |
| 1274 resource_id |
| 1275 ); |
| 1276 return retval; |
| 1277 } |
| 1278 |
| 1279 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3D_GetAttribs( |
| 1280 NaClSrpcChannel* channel, |
| 1281 PP_Resource context, |
| 1282 nacl_abi_size_t input_attrib_list_bytes, int32_t* input_attrib_list, |
| 1283 nacl_abi_size_t* output_attrib_list_bytes, int32_t* output_attrib_list, |
| 1284 int32_t* pp_error) { |
| 1285 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1286 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1287 __FUNCTION__)); |
| 1288 NaClSrpcError retval; |
| 1289 retval = NaClSrpcInvokeBySignature( |
| 1290 channel, |
| 1291 "PPB_Graphics3D_GetAttribs:iI:Ii", |
| 1292 context, |
| 1293 input_attrib_list_bytes, input_attrib_list, |
| 1294 output_attrib_list_bytes, output_attrib_list, |
| 1295 pp_error |
| 1296 ); |
| 1297 return retval; |
| 1298 } |
| 1299 |
| 1300 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3D_SetAttribs( |
| 1301 NaClSrpcChannel* channel, |
| 1302 PP_Resource context, |
| 1303 nacl_abi_size_t attrib_list_bytes, int32_t* attrib_list, |
| 1304 int32_t* pp_error) { |
| 1305 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1306 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1307 __FUNCTION__)); |
| 1308 NaClSrpcError retval; |
| 1309 retval = NaClSrpcInvokeBySignature( |
| 1310 channel, |
| 1311 "PPB_Graphics3D_SetAttribs:iI:i", |
| 1312 context, |
| 1313 attrib_list_bytes, attrib_list, |
| 1314 pp_error |
| 1315 ); |
| 1316 return retval; |
| 1317 } |
| 1318 |
| 1319 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3D_ResizeBuffers( |
| 1320 NaClSrpcChannel* channel, |
| 1321 PP_Resource context, |
| 1322 int32_t width, |
| 1323 int32_t height, |
| 1324 int32_t* pp_error) { |
| 1325 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1326 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1327 __FUNCTION__)); |
| 1328 NaClSrpcError retval; |
| 1329 retval = NaClSrpcInvokeBySignature( |
| 1330 channel, |
| 1331 "PPB_Graphics3D_ResizeBuffers:iii:i", |
| 1332 context, |
| 1333 width, |
| 1334 height, |
| 1335 pp_error |
| 1336 ); |
| 1337 return retval; |
| 1338 } |
| 1339 |
| 1340 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3D_SwapBuffers( |
| 1341 NaClSrpcChannel* channel, |
| 1342 PP_Resource context, |
| 1343 int32_t callback_id, |
| 1344 int32_t* pp_error) { |
| 1345 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1346 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1347 __FUNCTION__)); |
| 1348 NaClSrpcError retval; |
| 1349 retval = NaClSrpcInvokeBySignature( |
| 1350 channel, |
| 1351 "PPB_Graphics3D_SwapBuffers:ii:i", |
| 1352 context, |
| 1353 callback_id, |
| 1354 pp_error |
| 1355 ); |
| 1356 return retval; |
| 1357 } |
| 1358 |
| 1359 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_CreateRaw( |
| 1360 NaClSrpcChannel* channel, |
| 1361 PP_Instance instance, |
| 1362 PP_Resource share_context, |
| 1363 nacl_abi_size_t attrib_list_bytes, int32_t* attrib_list, |
| 1364 PP_Resource* resource_id) { |
| 1365 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1366 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1367 __FUNCTION__)); |
| 1368 NaClSrpcError retval; |
| 1369 retval = NaClSrpcInvokeBySignature( |
| 1370 channel, |
| 1371 "PPB_Graphics3DTrusted_CreateRaw:iiI:i", |
| 1372 instance, |
| 1373 share_context, |
| 1374 attrib_list_bytes, attrib_list, |
| 1375 resource_id |
| 1376 ); |
| 1377 return retval; |
| 1378 } |
| 1379 |
| 1380 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_InitCommandBuffer( |
| 1381 NaClSrpcChannel* channel, |
| 1382 PP_Resource resource_id, |
| 1383 int32_t size, |
| 1384 int32_t* success) { |
| 1385 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1386 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1387 __FUNCTION__)); |
| 1388 NaClSrpcError retval; |
| 1389 retval = NaClSrpcInvokeBySignature( |
| 1390 channel, |
| 1391 "PPB_Graphics3DTrusted_InitCommandBuffer:ii:i", |
| 1392 resource_id, |
| 1393 size, |
| 1394 success |
| 1395 ); |
| 1396 return retval; |
| 1397 } |
| 1398 |
| 1399 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_GetRingBuffer( |
| 1400 NaClSrpcChannel* channel, |
| 1401 PP_Resource resource_id, |
| 1402 NaClSrpcImcDescType* shm_desc, |
| 1403 int32_t* shm_size) { |
| 1404 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1405 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1406 __FUNCTION__)); |
| 1407 NaClSrpcError retval; |
| 1408 retval = NaClSrpcInvokeBySignature( |
| 1409 channel, |
| 1410 "PPB_Graphics3DTrusted_GetRingBuffer:i:hi", |
| 1411 resource_id, |
| 1412 shm_desc, |
| 1413 shm_size |
| 1414 ); |
| 1415 return retval; |
| 1416 } |
| 1417 |
| 1418 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_GetState( |
| 1419 NaClSrpcChannel* channel, |
| 1420 PP_Resource resource_id, |
| 1421 nacl_abi_size_t* state_bytes, char* state) { |
| 1422 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1423 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1424 __FUNCTION__)); |
| 1425 NaClSrpcError retval; |
| 1426 retval = NaClSrpcInvokeBySignature( |
| 1427 channel, |
| 1428 "PPB_Graphics3DTrusted_GetState:i:C", |
| 1429 resource_id, |
| 1430 state_bytes, state |
| 1431 ); |
| 1432 return retval; |
| 1433 } |
| 1434 |
| 1435 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_Flush( |
| 1436 NaClSrpcChannel* channel, |
| 1437 PP_Resource resource_id, |
| 1438 int32_t put_offset) { |
| 1439 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1440 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1441 __FUNCTION__)); |
| 1442 NaClSrpcError retval; |
| 1443 retval = NaClSrpcInvokeBySignature( |
| 1444 channel, |
| 1445 "PPB_Graphics3DTrusted_Flush:ii:", |
| 1446 resource_id, |
| 1447 put_offset |
| 1448 ); |
| 1449 return retval; |
| 1450 } |
| 1451 |
| 1452 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_FlushSync( |
| 1453 NaClSrpcChannel* channel, |
| 1454 PP_Resource resource_id, |
| 1455 int32_t put_offset, |
| 1456 nacl_abi_size_t* state_bytes, char* state) { |
| 1457 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1458 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1459 __FUNCTION__)); |
| 1460 NaClSrpcError retval; |
| 1461 retval = NaClSrpcInvokeBySignature( |
| 1462 channel, |
| 1463 "PPB_Graphics3DTrusted_FlushSync:ii:C", |
| 1464 resource_id, |
| 1465 put_offset, |
| 1466 state_bytes, state |
| 1467 ); |
| 1468 return retval; |
| 1469 } |
| 1470 |
| 1471 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_CreateTransferBuffer
( |
| 1472 NaClSrpcChannel* channel, |
| 1473 PP_Resource resource_id, |
| 1474 int32_t size, |
| 1475 int32_t request_id, |
| 1476 int32_t* id) { |
| 1477 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1478 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1479 __FUNCTION__)); |
| 1480 NaClSrpcError retval; |
| 1481 retval = NaClSrpcInvokeBySignature( |
| 1482 channel, |
| 1483 "PPB_Graphics3DTrusted_CreateTransferBuffer:iii:i", |
| 1484 resource_id, |
| 1485 size, |
| 1486 request_id, |
| 1487 id |
| 1488 ); |
| 1489 return retval; |
| 1490 } |
| 1491 |
| 1492 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_DestroyTransferBuffe
r( |
| 1493 NaClSrpcChannel* channel, |
| 1494 PP_Resource resource_id, |
| 1495 int32_t id) { |
| 1496 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1497 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1498 __FUNCTION__)); |
| 1499 NaClSrpcError retval; |
| 1500 retval = NaClSrpcInvokeBySignature( |
| 1501 channel, |
| 1502 "PPB_Graphics3DTrusted_DestroyTransferBuffer:ii:", |
| 1503 resource_id, |
| 1504 id |
| 1505 ); |
| 1506 return retval; |
| 1507 } |
| 1508 |
| 1509 NaClSrpcError PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_GetTransferBuffer( |
| 1510 NaClSrpcChannel* channel, |
| 1511 PP_Resource resource_id, |
| 1512 int32_t id, |
| 1513 NaClSrpcImcDescType* shm_desc, |
| 1514 int32_t* shm_size) { |
| 1515 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1516 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1517 __FUNCTION__)); |
| 1518 NaClSrpcError retval; |
| 1519 retval = NaClSrpcInvokeBySignature( |
| 1520 channel, |
| 1521 "PPB_Graphics3DTrusted_GetTransferBuffer:ii:hi", |
| 1522 resource_id, |
| 1523 id, |
| 1524 shm_desc, |
| 1525 shm_size |
| 1526 ); |
| 1527 return retval; |
| 1528 } |
| 1529 |
| 1530 NaClSrpcError PpbImageDataRpcClient::PPB_ImageData_GetNativeImageDataFormat( |
| 1531 NaClSrpcChannel* channel, |
| 1532 int32_t* format) { |
| 1533 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1534 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1535 __FUNCTION__)); |
| 1536 NaClSrpcError retval; |
| 1537 retval = NaClSrpcInvokeBySignature( |
| 1538 channel, |
| 1539 "PPB_ImageData_GetNativeImageDataFormat::i", |
| 1540 format |
| 1541 ); |
| 1542 return retval; |
| 1543 } |
| 1544 |
| 1545 NaClSrpcError PpbImageDataRpcClient::PPB_ImageData_IsImageDataFormatSupported( |
| 1546 NaClSrpcChannel* channel, |
| 1547 int32_t format, |
| 1548 int32_t* success) { |
| 1549 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1550 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1551 __FUNCTION__)); |
| 1552 NaClSrpcError retval; |
| 1553 retval = NaClSrpcInvokeBySignature( |
| 1554 channel, |
| 1555 "PPB_ImageData_IsImageDataFormatSupported:i:i", |
| 1556 format, |
| 1557 success |
| 1558 ); |
| 1559 return retval; |
| 1560 } |
| 1561 |
| 1562 NaClSrpcError PpbImageDataRpcClient::PPB_ImageData_Create( |
| 1563 NaClSrpcChannel* channel, |
| 1564 PP_Instance instance, |
| 1565 int32_t format, |
| 1566 nacl_abi_size_t size_bytes, char* size, |
| 1567 int32_t init_to_zero, |
| 1568 PP_Resource* resource) { |
| 1569 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1570 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1571 __FUNCTION__)); |
| 1572 NaClSrpcError retval; |
| 1573 retval = NaClSrpcInvokeBySignature( |
| 1574 channel, |
| 1575 "PPB_ImageData_Create:iiCi:i", |
| 1576 instance, |
| 1577 format, |
| 1578 size_bytes, size, |
| 1579 init_to_zero, |
| 1580 resource |
| 1581 ); |
| 1582 return retval; |
| 1583 } |
| 1584 |
| 1585 NaClSrpcError PpbImageDataRpcClient::PPB_ImageData_IsImageData( |
| 1586 NaClSrpcChannel* channel, |
| 1587 PP_Resource resource, |
| 1588 int32_t* success) { |
| 1589 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1590 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1591 __FUNCTION__)); |
| 1592 NaClSrpcError retval; |
| 1593 retval = NaClSrpcInvokeBySignature( |
| 1594 channel, |
| 1595 "PPB_ImageData_IsImageData:i:i", |
| 1596 resource, |
| 1597 success |
| 1598 ); |
| 1599 return retval; |
| 1600 } |
| 1601 |
| 1602 NaClSrpcError PpbImageDataRpcClient::PPB_ImageData_Describe( |
| 1603 NaClSrpcChannel* channel, |
| 1604 PP_Resource resource, |
| 1605 nacl_abi_size_t* desc_bytes, char* desc, |
| 1606 NaClSrpcImcDescType* shm, |
| 1607 int32_t* shm_size, |
| 1608 int32_t* success) { |
| 1609 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1610 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1611 __FUNCTION__)); |
| 1612 NaClSrpcError retval; |
| 1613 retval = NaClSrpcInvokeBySignature( |
| 1614 channel, |
| 1615 "PPB_ImageData_Describe:i:Chii", |
| 1616 resource, |
| 1617 desc_bytes, desc, |
| 1618 shm, |
| 1619 shm_size, |
| 1620 success |
| 1621 ); |
| 1622 return retval; |
| 1623 } |
| 1624 |
| 1625 NaClSrpcError PpbInputEventRpcClient::PPB_InputEvent_RequestInputEvents( |
| 1626 NaClSrpcChannel* channel, |
| 1627 PP_Instance instance, |
| 1628 int32_t event_classes, |
| 1629 int32_t filtered, |
| 1630 int32_t* success) { |
| 1631 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1632 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1633 __FUNCTION__)); |
| 1634 NaClSrpcError retval; |
| 1635 retval = NaClSrpcInvokeBySignature( |
| 1636 channel, |
| 1637 "PPB_InputEvent_RequestInputEvents:iii:i", |
| 1638 instance, |
| 1639 event_classes, |
| 1640 filtered, |
| 1641 success |
| 1642 ); |
| 1643 return retval; |
| 1644 } |
| 1645 |
| 1646 NaClSrpcError PpbInputEventRpcClient::PPB_InputEvent_ClearInputEventRequest( |
| 1647 NaClSrpcChannel* channel, |
| 1648 PP_Instance instance, |
| 1649 int32_t event_classes) { |
| 1650 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1651 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1652 __FUNCTION__)); |
| 1653 NaClSrpcError retval; |
| 1654 retval = NaClSrpcInvokeBySignature( |
| 1655 channel, |
| 1656 "PPB_InputEvent_ClearInputEventRequest:ii:", |
| 1657 instance, |
| 1658 event_classes |
| 1659 ); |
| 1660 return retval; |
| 1661 } |
| 1662 |
| 1663 NaClSrpcError PpbInputEventRpcClient::PPB_InputEvent_CreateMouseInputEvent( |
| 1664 NaClSrpcChannel* channel, |
| 1665 PP_Instance instance, |
| 1666 int32_t type, |
| 1667 double time_stamp, |
| 1668 int32_t modifiers, |
| 1669 int32_t mouse_button, |
| 1670 int32_t mouse_position_x, |
| 1671 int32_t mouse_position_y, |
| 1672 int32_t click_count, |
| 1673 PP_Resource* resource_id) { |
| 1674 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1675 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1676 __FUNCTION__)); |
| 1677 NaClSrpcError retval; |
| 1678 retval = NaClSrpcInvokeBySignature( |
| 1679 channel, |
| 1680 "PPB_InputEvent_CreateMouseInputEvent:iidiiiii:i", |
| 1681 instance, |
| 1682 type, |
| 1683 time_stamp, |
| 1684 modifiers, |
| 1685 mouse_button, |
| 1686 mouse_position_x, |
| 1687 mouse_position_y, |
| 1688 click_count, |
| 1689 resource_id |
| 1690 ); |
| 1691 return retval; |
| 1692 } |
| 1693 |
| 1694 NaClSrpcError PpbInputEventRpcClient::PPB_InputEvent_CreateWheelInputEvent( |
| 1695 NaClSrpcChannel* channel, |
| 1696 PP_Instance instance, |
| 1697 double time_stamp, |
| 1698 int32_t modifiers, |
| 1699 double wheel_delta_x, |
| 1700 double wheel_delta_y, |
| 1701 double wheel_ticks_x, |
| 1702 double wheel_ticks_y, |
| 1703 int32_t scroll_by_page, |
| 1704 PP_Resource* resource_id) { |
| 1705 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1706 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1707 __FUNCTION__)); |
| 1708 NaClSrpcError retval; |
| 1709 retval = NaClSrpcInvokeBySignature( |
| 1710 channel, |
| 1711 "PPB_InputEvent_CreateWheelInputEvent:ididdddi:i", |
| 1712 instance, |
| 1713 time_stamp, |
| 1714 modifiers, |
| 1715 wheel_delta_x, |
| 1716 wheel_delta_y, |
| 1717 wheel_ticks_x, |
| 1718 wheel_ticks_y, |
| 1719 scroll_by_page, |
| 1720 resource_id |
| 1721 ); |
| 1722 return retval; |
| 1723 } |
| 1724 |
| 1725 NaClSrpcError PpbInputEventRpcClient::PPB_InputEvent_CreateKeyboardInputEvent( |
| 1726 NaClSrpcChannel* channel, |
| 1727 PP_Instance instance, |
| 1728 int32_t type, |
| 1729 double time_stamp, |
| 1730 int32_t modifiers, |
| 1731 int32_t key_code, |
| 1732 nacl_abi_size_t character_text_bytes, char* character_text, |
| 1733 PP_Resource* resource_id) { |
| 1734 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1735 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1736 __FUNCTION__)); |
| 1737 NaClSrpcError retval; |
| 1738 retval = NaClSrpcInvokeBySignature( |
| 1739 channel, |
| 1740 "PPB_InputEvent_CreateKeyboardInputEvent:iidiiC:i", |
| 1741 instance, |
| 1742 type, |
| 1743 time_stamp, |
| 1744 modifiers, |
| 1745 key_code, |
| 1746 character_text_bytes, character_text, |
| 1747 resource_id |
| 1748 ); |
| 1749 return retval; |
| 1750 } |
| 1751 |
| 1752 NaClSrpcError PpbInstanceRpcClient::PPB_Instance_BindGraphics( |
| 1753 NaClSrpcChannel* channel, |
| 1754 PP_Instance instance, |
| 1755 PP_Resource graphics_device, |
| 1756 int32_t* success) { |
| 1757 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1758 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1759 __FUNCTION__)); |
| 1760 NaClSrpcError retval; |
| 1761 retval = NaClSrpcInvokeBySignature( |
| 1762 channel, |
| 1763 "PPB_Instance_BindGraphics:ii:i", |
| 1764 instance, |
| 1765 graphics_device, |
| 1766 success |
| 1767 ); |
| 1768 return retval; |
| 1769 } |
| 1770 |
| 1771 NaClSrpcError PpbInstanceRpcClient::PPB_Instance_IsFullFrame( |
| 1772 NaClSrpcChannel* channel, |
| 1773 PP_Instance instance, |
| 1774 int32_t* is_full_frame) { |
| 1775 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1776 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1777 __FUNCTION__)); |
| 1778 NaClSrpcError retval; |
| 1779 retval = NaClSrpcInvokeBySignature( |
| 1780 channel, |
| 1781 "PPB_Instance_IsFullFrame:i:i", |
| 1782 instance, |
| 1783 is_full_frame |
| 1784 ); |
| 1785 return retval; |
| 1786 } |
| 1787 |
| 1788 NaClSrpcError PpbMessagingRpcClient::PPB_Messaging_PostMessage( |
| 1789 NaClSrpcChannel* channel, |
| 1790 PP_Instance instance, |
| 1791 nacl_abi_size_t message_bytes, char* message) { |
| 1792 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1793 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1794 __FUNCTION__)); |
| 1795 NaClSrpcError retval; |
| 1796 retval = NaClSrpcInvokeBySignature( |
| 1797 channel, |
| 1798 "PPB_Messaging_PostMessage:iC:", |
| 1799 instance, |
| 1800 message_bytes, message |
| 1801 ); |
| 1802 return retval; |
| 1803 } |
| 1804 |
| 1805 NaClSrpcError PpbPdfRpcClient::PPB_PDF_GetLocalizedString( |
| 1806 NaClSrpcChannel* channel, |
| 1807 PP_Instance instance, |
| 1808 int32_t string_id, |
| 1809 nacl_abi_size_t* string_bytes, char* string) { |
| 1810 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1811 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1812 __FUNCTION__)); |
| 1813 NaClSrpcError retval; |
| 1814 retval = NaClSrpcInvokeBySignature( |
| 1815 channel, |
| 1816 "PPB_PDF_GetLocalizedString:ii:C", |
| 1817 instance, |
| 1818 string_id, |
| 1819 string_bytes, string |
| 1820 ); |
| 1821 return retval; |
| 1822 } |
| 1823 |
| 1824 NaClSrpcError PpbPdfRpcClient::PPB_PDF_GetResourceImage( |
| 1825 NaClSrpcChannel* channel, |
| 1826 PP_Instance instance, |
| 1827 int32_t image_id, |
| 1828 PP_Resource* image) { |
| 1829 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1830 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1831 __FUNCTION__)); |
| 1832 NaClSrpcError retval; |
| 1833 retval = NaClSrpcInvokeBySignature( |
| 1834 channel, |
| 1835 "PPB_PDF_GetResourceImage:ii:i", |
| 1836 instance, |
| 1837 image_id, |
| 1838 image |
| 1839 ); |
| 1840 return retval; |
| 1841 } |
| 1842 |
| 1843 NaClSrpcError PpbPdfRpcClient::PPB_PDF_GetFontFileWithFallback( |
| 1844 NaClSrpcChannel* channel, |
| 1845 PP_Instance instance, |
| 1846 nacl_abi_size_t description_bytes, char* description, |
| 1847 nacl_abi_size_t face_bytes, char* face, |
| 1848 int32_t charset, |
| 1849 PP_Resource* font) { |
| 1850 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1851 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1852 __FUNCTION__)); |
| 1853 NaClSrpcError retval; |
| 1854 retval = NaClSrpcInvokeBySignature( |
| 1855 channel, |
| 1856 "PPB_PDF_GetFontFileWithFallback:iCCi:i", |
| 1857 instance, |
| 1858 description_bytes, description, |
| 1859 face_bytes, face, |
| 1860 charset, |
| 1861 font |
| 1862 ); |
| 1863 return retval; |
| 1864 } |
| 1865 |
| 1866 NaClSrpcError PpbPdfRpcClient::PPB_PDF_GetFontTableForPrivateFontFile( |
| 1867 NaClSrpcChannel* channel, |
| 1868 PP_Resource font_file, |
| 1869 int32_t table, |
| 1870 nacl_abi_size_t* output_bytes, char* output, |
| 1871 int32_t* success) { |
| 1872 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1873 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1874 __FUNCTION__)); |
| 1875 NaClSrpcError retval; |
| 1876 retval = NaClSrpcInvokeBySignature( |
| 1877 channel, |
| 1878 "PPB_PDF_GetFontTableForPrivateFontFile:ii:Ci", |
| 1879 font_file, |
| 1880 table, |
| 1881 output_bytes, output, |
| 1882 success |
| 1883 ); |
| 1884 return retval; |
| 1885 } |
| 1886 |
| 1887 NaClSrpcError PpbPdfRpcClient::PPB_PDF_SearchString( |
| 1888 NaClSrpcChannel* channel, |
| 1889 PP_Instance instance, |
| 1890 nacl_abi_size_t string_bytes, char* string, |
| 1891 nacl_abi_size_t term_bytes, char* term, |
| 1892 int32_t case_sensitive, |
| 1893 nacl_abi_size_t* results_bytes, char* results, |
| 1894 int32_t* count) { |
| 1895 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1896 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1897 __FUNCTION__)); |
| 1898 NaClSrpcError retval; |
| 1899 retval = NaClSrpcInvokeBySignature( |
| 1900 channel, |
| 1901 "PPB_PDF_SearchString:iCCi:Ci", |
| 1902 instance, |
| 1903 string_bytes, string, |
| 1904 term_bytes, term, |
| 1905 case_sensitive, |
| 1906 results_bytes, results, |
| 1907 count |
| 1908 ); |
| 1909 return retval; |
| 1910 } |
| 1911 |
| 1912 NaClSrpcError PpbPdfRpcClient::PPB_PDF_DidStartLoading( |
| 1913 NaClSrpcChannel* channel, |
| 1914 PP_Instance instance) { |
| 1915 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1916 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1917 __FUNCTION__)); |
| 1918 NaClSrpcError retval; |
| 1919 retval = NaClSrpcInvokeBySignature( |
| 1920 channel, |
| 1921 "PPB_PDF_DidStartLoading:i:", |
| 1922 instance |
| 1923 ); |
| 1924 return retval; |
| 1925 } |
| 1926 |
| 1927 NaClSrpcError PpbPdfRpcClient::PPB_PDF_DidStopLoading( |
| 1928 NaClSrpcChannel* channel, |
| 1929 PP_Instance instance) { |
| 1930 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1931 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1932 __FUNCTION__)); |
| 1933 NaClSrpcError retval; |
| 1934 retval = NaClSrpcInvokeBySignature( |
| 1935 channel, |
| 1936 "PPB_PDF_DidStopLoading:i:", |
| 1937 instance |
| 1938 ); |
| 1939 return retval; |
| 1940 } |
| 1941 |
| 1942 NaClSrpcError PpbPdfRpcClient::PPB_PDF_SetContentRestriction( |
| 1943 NaClSrpcChannel* channel, |
| 1944 PP_Instance instance, |
| 1945 int32_t restrictions) { |
| 1946 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1947 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1948 __FUNCTION__)); |
| 1949 NaClSrpcError retval; |
| 1950 retval = NaClSrpcInvokeBySignature( |
| 1951 channel, |
| 1952 "PPB_PDF_SetContentRestriction:ii:", |
| 1953 instance, |
| 1954 restrictions |
| 1955 ); |
| 1956 return retval; |
| 1957 } |
| 1958 |
| 1959 NaClSrpcError PpbPdfRpcClient::PPB_PDF_HistogramPDFPageCount( |
| 1960 NaClSrpcChannel* channel, |
| 1961 int32_t count) { |
| 1962 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1963 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1964 __FUNCTION__)); |
| 1965 NaClSrpcError retval; |
| 1966 retval = NaClSrpcInvokeBySignature( |
| 1967 channel, |
| 1968 "PPB_PDF_HistogramPDFPageCount:i:", |
| 1969 count |
| 1970 ); |
| 1971 return retval; |
| 1972 } |
| 1973 |
| 1974 NaClSrpcError PpbPdfRpcClient::PPB_PDF_UserMetricsRecordAction( |
| 1975 NaClSrpcChannel* channel, |
| 1976 nacl_abi_size_t action_bytes, char* action) { |
| 1977 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1978 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1979 __FUNCTION__)); |
| 1980 NaClSrpcError retval; |
| 1981 retval = NaClSrpcInvokeBySignature( |
| 1982 channel, |
| 1983 "PPB_PDF_UserMetricsRecordAction:C:", |
| 1984 action_bytes, action |
| 1985 ); |
| 1986 return retval; |
| 1987 } |
| 1988 |
| 1989 NaClSrpcError PpbPdfRpcClient::PPB_PDF_HasUnsupportedFeature( |
| 1990 NaClSrpcChannel* channel, |
| 1991 PP_Instance instance) { |
| 1992 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 1993 ("%s: PPAPI calls are not supported off the main thread\n", |
| 1994 __FUNCTION__)); |
| 1995 NaClSrpcError retval; |
| 1996 retval = NaClSrpcInvokeBySignature( |
| 1997 channel, |
| 1998 "PPB_PDF_HasUnsupportedFeature:i:", |
| 1999 instance |
| 2000 ); |
| 2001 return retval; |
| 2002 } |
| 2003 |
| 2004 NaClSrpcError PpbPdfRpcClient::PPB_PDF_SaveAs( |
| 2005 NaClSrpcChannel* channel, |
| 2006 PP_Instance instance) { |
| 2007 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2008 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2009 __FUNCTION__)); |
| 2010 NaClSrpcError retval; |
| 2011 retval = NaClSrpcInvokeBySignature( |
| 2012 channel, |
| 2013 "PPB_PDF_SaveAs:i:", |
| 2014 instance |
| 2015 ); |
| 2016 return retval; |
| 2017 } |
| 2018 |
| 2019 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_Create( |
| 2020 NaClSrpcChannel* channel, |
| 2021 PP_Instance instance, |
| 2022 int32_t vertical, |
| 2023 PP_Resource* scrollbar) { |
| 2024 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2025 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2026 __FUNCTION__)); |
| 2027 NaClSrpcError retval; |
| 2028 retval = NaClSrpcInvokeBySignature( |
| 2029 channel, |
| 2030 "PPB_Scrollbar_Create:ii:i", |
| 2031 instance, |
| 2032 vertical, |
| 2033 scrollbar |
| 2034 ); |
| 2035 return retval; |
| 2036 } |
| 2037 |
| 2038 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_IsScrollbar( |
| 2039 NaClSrpcChannel* channel, |
| 2040 PP_Resource resource, |
| 2041 int32_t* is_scrollbar) { |
| 2042 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2043 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2044 __FUNCTION__)); |
| 2045 NaClSrpcError retval; |
| 2046 retval = NaClSrpcInvokeBySignature( |
| 2047 channel, |
| 2048 "PPB_Scrollbar_IsScrollbar:i:i", |
| 2049 resource, |
| 2050 is_scrollbar |
| 2051 ); |
| 2052 return retval; |
| 2053 } |
| 2054 |
| 2055 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_IsOverlay( |
| 2056 NaClSrpcChannel* channel, |
| 2057 PP_Resource resource, |
| 2058 int32_t* is_overlay) { |
| 2059 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2060 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2061 __FUNCTION__)); |
| 2062 NaClSrpcError retval; |
| 2063 retval = NaClSrpcInvokeBySignature( |
| 2064 channel, |
| 2065 "PPB_Scrollbar_IsOverlay:i:i", |
| 2066 resource, |
| 2067 is_overlay |
| 2068 ); |
| 2069 return retval; |
| 2070 } |
| 2071 |
| 2072 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_GetThickness( |
| 2073 NaClSrpcChannel* channel, |
| 2074 PP_Resource resource, |
| 2075 int32_t* thickness) { |
| 2076 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2077 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2078 __FUNCTION__)); |
| 2079 NaClSrpcError retval; |
| 2080 retval = NaClSrpcInvokeBySignature( |
| 2081 channel, |
| 2082 "PPB_Scrollbar_GetThickness:i:i", |
| 2083 resource, |
| 2084 thickness |
| 2085 ); |
| 2086 return retval; |
| 2087 } |
| 2088 |
| 2089 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_GetValue( |
| 2090 NaClSrpcChannel* channel, |
| 2091 PP_Resource scrollbar, |
| 2092 int32_t* value) { |
| 2093 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2094 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2095 __FUNCTION__)); |
| 2096 NaClSrpcError retval; |
| 2097 retval = NaClSrpcInvokeBySignature( |
| 2098 channel, |
| 2099 "PPB_Scrollbar_GetValue:i:i", |
| 2100 scrollbar, |
| 2101 value |
| 2102 ); |
| 2103 return retval; |
| 2104 } |
| 2105 |
| 2106 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_SetValue( |
| 2107 NaClSrpcChannel* channel, |
| 2108 PP_Resource scrollbar, |
| 2109 int32_t value) { |
| 2110 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2111 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2112 __FUNCTION__)); |
| 2113 NaClSrpcError retval; |
| 2114 retval = NaClSrpcInvokeBySignature( |
| 2115 channel, |
| 2116 "PPB_Scrollbar_SetValue:ii:", |
| 2117 scrollbar, |
| 2118 value |
| 2119 ); |
| 2120 return retval; |
| 2121 } |
| 2122 |
| 2123 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_SetDocumentSize( |
| 2124 NaClSrpcChannel* channel, |
| 2125 PP_Resource scrollbar, |
| 2126 int32_t size) { |
| 2127 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2128 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2129 __FUNCTION__)); |
| 2130 NaClSrpcError retval; |
| 2131 retval = NaClSrpcInvokeBySignature( |
| 2132 channel, |
| 2133 "PPB_Scrollbar_SetDocumentSize:ii:", |
| 2134 scrollbar, |
| 2135 size |
| 2136 ); |
| 2137 return retval; |
| 2138 } |
| 2139 |
| 2140 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_SetTickMarks( |
| 2141 NaClSrpcChannel* channel, |
| 2142 PP_Resource scrollbar, |
| 2143 nacl_abi_size_t tick_marks_bytes, char* tick_marks, |
| 2144 int32_t count) { |
| 2145 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2146 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2147 __FUNCTION__)); |
| 2148 NaClSrpcError retval; |
| 2149 retval = NaClSrpcInvokeBySignature( |
| 2150 channel, |
| 2151 "PPB_Scrollbar_SetTickMarks:iCi:", |
| 2152 scrollbar, |
| 2153 tick_marks_bytes, tick_marks, |
| 2154 count |
| 2155 ); |
| 2156 return retval; |
| 2157 } |
| 2158 |
| 2159 NaClSrpcError PpbScrollbarRpcClient::PPB_Scrollbar_ScrollBy( |
| 2160 NaClSrpcChannel* channel, |
| 2161 PP_Resource scrollbar, |
| 2162 int32_t unit, |
| 2163 int32_t multiplier) { |
| 2164 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2165 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2166 __FUNCTION__)); |
| 2167 NaClSrpcError retval; |
| 2168 retval = NaClSrpcInvokeBySignature( |
| 2169 channel, |
| 2170 "PPB_Scrollbar_ScrollBy:iii:", |
| 2171 scrollbar, |
| 2172 unit, |
| 2173 multiplier |
| 2174 ); |
| 2175 return retval; |
| 2176 } |
| 2177 |
| 2178 NaClSrpcError PpbTestingRpcClient::PPB_Testing_ReadImageData( |
| 2179 NaClSrpcChannel* channel, |
| 2180 PP_Resource device_context_2d, |
| 2181 PP_Resource image, |
| 2182 nacl_abi_size_t top_left_bytes, char* top_left, |
| 2183 int32_t* success) { |
| 2184 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2185 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2186 __FUNCTION__)); |
| 2187 NaClSrpcError retval; |
| 2188 retval = NaClSrpcInvokeBySignature( |
| 2189 channel, |
| 2190 "PPB_Testing_ReadImageData:iiC:i", |
| 2191 device_context_2d, |
| 2192 image, |
| 2193 top_left_bytes, top_left, |
| 2194 success |
| 2195 ); |
| 2196 return retval; |
| 2197 } |
| 2198 |
| 2199 NaClSrpcError PpbTestingRpcClient::PPB_Testing_RunMessageLoop( |
| 2200 NaClSrpcChannel* channel, |
| 2201 PP_Instance instance) { |
| 2202 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2203 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2204 __FUNCTION__)); |
| 2205 NaClSrpcError retval; |
| 2206 retval = NaClSrpcInvokeBySignature( |
| 2207 channel, |
| 2208 "PPB_Testing_RunMessageLoop:i:", |
| 2209 instance |
| 2210 ); |
| 2211 return retval; |
| 2212 } |
| 2213 |
| 2214 NaClSrpcError PpbTestingRpcClient::PPB_Testing_QuitMessageLoop( |
| 2215 NaClSrpcChannel* channel, |
| 2216 PP_Instance instance) { |
| 2217 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2218 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2219 __FUNCTION__)); |
| 2220 NaClSrpcError retval; |
| 2221 retval = NaClSrpcInvokeBySignature( |
| 2222 channel, |
| 2223 "PPB_Testing_QuitMessageLoop:i:", |
| 2224 instance |
| 2225 ); |
| 2226 return retval; |
| 2227 } |
| 2228 |
| 2229 NaClSrpcError PpbTestingRpcClient::PPB_Testing_GetLiveObjectsForInstance( |
| 2230 NaClSrpcChannel* channel, |
| 2231 PP_Instance instance, |
| 2232 int32_t* live_object_count) { |
| 2233 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2234 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2235 __FUNCTION__)); |
| 2236 NaClSrpcError retval; |
| 2237 retval = NaClSrpcInvokeBySignature( |
| 2238 channel, |
| 2239 "PPB_Testing_GetLiveObjectsForInstance:i:i", |
| 2240 instance, |
| 2241 live_object_count |
| 2242 ); |
| 2243 return retval; |
| 2244 } |
| 2245 |
| 2246 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_Create( |
| 2247 NaClSrpcChannel* channel, |
| 2248 PP_Instance instance, |
| 2249 PP_Resource* resource) { |
| 2250 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2251 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2252 __FUNCTION__)); |
| 2253 NaClSrpcError retval; |
| 2254 retval = NaClSrpcInvokeBySignature( |
| 2255 channel, |
| 2256 "PPB_URLLoader_Create:i:i", |
| 2257 instance, |
| 2258 resource |
| 2259 ); |
| 2260 return retval; |
| 2261 } |
| 2262 |
| 2263 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_IsURLLoader( |
| 2264 NaClSrpcChannel* channel, |
| 2265 PP_Resource resource, |
| 2266 int32_t* is_url_loader) { |
| 2267 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2268 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2269 __FUNCTION__)); |
| 2270 NaClSrpcError retval; |
| 2271 retval = NaClSrpcInvokeBySignature( |
| 2272 channel, |
| 2273 "PPB_URLLoader_IsURLLoader:i:i", |
| 2274 resource, |
| 2275 is_url_loader |
| 2276 ); |
| 2277 return retval; |
| 2278 } |
| 2279 |
| 2280 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_Open( |
| 2281 NaClSrpcChannel* channel, |
| 2282 PP_Resource loader, |
| 2283 PP_Resource request, |
| 2284 int32_t callback_id, |
| 2285 int32_t* pp_error) { |
| 2286 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2287 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2288 __FUNCTION__)); |
| 2289 NaClSrpcError retval; |
| 2290 retval = NaClSrpcInvokeBySignature( |
| 2291 channel, |
| 2292 "PPB_URLLoader_Open:iii:i", |
| 2293 loader, |
| 2294 request, |
| 2295 callback_id, |
| 2296 pp_error |
| 2297 ); |
| 2298 return retval; |
| 2299 } |
| 2300 |
| 2301 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_FollowRedirect( |
| 2302 NaClSrpcChannel* channel, |
| 2303 PP_Resource loader, |
| 2304 int32_t callback_id, |
| 2305 int32_t* pp_error) { |
| 2306 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2307 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2308 __FUNCTION__)); |
| 2309 NaClSrpcError retval; |
| 2310 retval = NaClSrpcInvokeBySignature( |
| 2311 channel, |
| 2312 "PPB_URLLoader_FollowRedirect:ii:i", |
| 2313 loader, |
| 2314 callback_id, |
| 2315 pp_error |
| 2316 ); |
| 2317 return retval; |
| 2318 } |
| 2319 |
| 2320 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_GetUploadProgress( |
| 2321 NaClSrpcChannel* channel, |
| 2322 PP_Resource loader, |
| 2323 int64_t* bytes_sent, |
| 2324 int64_t* total_bytes_to_be_sent, |
| 2325 int32_t* success) { |
| 2326 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2327 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2328 __FUNCTION__)); |
| 2329 NaClSrpcError retval; |
| 2330 retval = NaClSrpcInvokeBySignature( |
| 2331 channel, |
| 2332 "PPB_URLLoader_GetUploadProgress:i:lli", |
| 2333 loader, |
| 2334 bytes_sent, |
| 2335 total_bytes_to_be_sent, |
| 2336 success |
| 2337 ); |
| 2338 return retval; |
| 2339 } |
| 2340 |
| 2341 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_GetDownloadProgress( |
| 2342 NaClSrpcChannel* channel, |
| 2343 PP_Resource loader, |
| 2344 int64_t* bytes_received, |
| 2345 int64_t* total_bytes_to_be_received, |
| 2346 int32_t* success) { |
| 2347 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2348 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2349 __FUNCTION__)); |
| 2350 NaClSrpcError retval; |
| 2351 retval = NaClSrpcInvokeBySignature( |
| 2352 channel, |
| 2353 "PPB_URLLoader_GetDownloadProgress:i:lli", |
| 2354 loader, |
| 2355 bytes_received, |
| 2356 total_bytes_to_be_received, |
| 2357 success |
| 2358 ); |
| 2359 return retval; |
| 2360 } |
| 2361 |
| 2362 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_GetResponseInfo( |
| 2363 NaClSrpcChannel* channel, |
| 2364 PP_Resource loader, |
| 2365 PP_Resource* response) { |
| 2366 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2367 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2368 __FUNCTION__)); |
| 2369 NaClSrpcError retval; |
| 2370 retval = NaClSrpcInvokeBySignature( |
| 2371 channel, |
| 2372 "PPB_URLLoader_GetResponseInfo:i:i", |
| 2373 loader, |
| 2374 response |
| 2375 ); |
| 2376 return retval; |
| 2377 } |
| 2378 |
| 2379 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_ReadResponseBody( |
| 2380 NaClSrpcChannel* channel, |
| 2381 PP_Resource loader, |
| 2382 int32_t bytes_to_read, |
| 2383 int32_t callback_id, |
| 2384 nacl_abi_size_t* buffer_bytes, char* buffer, |
| 2385 int32_t* pp_error_or_bytes) { |
| 2386 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2387 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2388 __FUNCTION__)); |
| 2389 NaClSrpcError retval; |
| 2390 retval = NaClSrpcInvokeBySignature( |
| 2391 channel, |
| 2392 "PPB_URLLoader_ReadResponseBody:iii:Ci", |
| 2393 loader, |
| 2394 bytes_to_read, |
| 2395 callback_id, |
| 2396 buffer_bytes, buffer, |
| 2397 pp_error_or_bytes |
| 2398 ); |
| 2399 return retval; |
| 2400 } |
| 2401 |
| 2402 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_FinishStreamingToFile( |
| 2403 NaClSrpcChannel* channel, |
| 2404 PP_Resource loader, |
| 2405 int32_t callback_id, |
| 2406 int32_t* pp_error) { |
| 2407 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2408 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2409 __FUNCTION__)); |
| 2410 NaClSrpcError retval; |
| 2411 retval = NaClSrpcInvokeBySignature( |
| 2412 channel, |
| 2413 "PPB_URLLoader_FinishStreamingToFile:ii:i", |
| 2414 loader, |
| 2415 callback_id, |
| 2416 pp_error |
| 2417 ); |
| 2418 return retval; |
| 2419 } |
| 2420 |
| 2421 NaClSrpcError PpbURLLoaderRpcClient::PPB_URLLoader_Close( |
| 2422 NaClSrpcChannel* channel, |
| 2423 PP_Resource loader) { |
| 2424 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2425 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2426 __FUNCTION__)); |
| 2427 NaClSrpcError retval; |
| 2428 retval = NaClSrpcInvokeBySignature( |
| 2429 channel, |
| 2430 "PPB_URLLoader_Close:i:", |
| 2431 loader |
| 2432 ); |
| 2433 return retval; |
| 2434 } |
| 2435 |
| 2436 NaClSrpcError PpbURLRequestInfoRpcClient::PPB_URLRequestInfo_Create( |
| 2437 NaClSrpcChannel* channel, |
| 2438 PP_Instance instance, |
| 2439 PP_Resource* resource) { |
| 2440 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2441 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2442 __FUNCTION__)); |
| 2443 NaClSrpcError retval; |
| 2444 retval = NaClSrpcInvokeBySignature( |
| 2445 channel, |
| 2446 "PPB_URLRequestInfo_Create:i:i", |
| 2447 instance, |
| 2448 resource |
| 2449 ); |
| 2450 return retval; |
| 2451 } |
| 2452 |
| 2453 NaClSrpcError PpbURLRequestInfoRpcClient::PPB_URLRequestInfo_IsURLRequestInfo( |
| 2454 NaClSrpcChannel* channel, |
| 2455 PP_Resource resource, |
| 2456 int32_t* success) { |
| 2457 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2458 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2459 __FUNCTION__)); |
| 2460 NaClSrpcError retval; |
| 2461 retval = NaClSrpcInvokeBySignature( |
| 2462 channel, |
| 2463 "PPB_URLRequestInfo_IsURLRequestInfo:i:i", |
| 2464 resource, |
| 2465 success |
| 2466 ); |
| 2467 return retval; |
| 2468 } |
| 2469 |
| 2470 NaClSrpcError PpbURLRequestInfoRpcClient::PPB_URLRequestInfo_SetProperty( |
| 2471 NaClSrpcChannel* channel, |
| 2472 PP_Resource request, |
| 2473 int32_t property, |
| 2474 nacl_abi_size_t value_bytes, char* value, |
| 2475 int32_t* success) { |
| 2476 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2477 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2478 __FUNCTION__)); |
| 2479 NaClSrpcError retval; |
| 2480 retval = NaClSrpcInvokeBySignature( |
| 2481 channel, |
| 2482 "PPB_URLRequestInfo_SetProperty:iiC:i", |
| 2483 request, |
| 2484 property, |
| 2485 value_bytes, value, |
| 2486 success |
| 2487 ); |
| 2488 return retval; |
| 2489 } |
| 2490 |
| 2491 NaClSrpcError PpbURLRequestInfoRpcClient::PPB_URLRequestInfo_AppendDataToBody( |
| 2492 NaClSrpcChannel* channel, |
| 2493 PP_Resource request, |
| 2494 nacl_abi_size_t data_bytes, char* data, |
| 2495 int32_t* success) { |
| 2496 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2497 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2498 __FUNCTION__)); |
| 2499 NaClSrpcError retval; |
| 2500 retval = NaClSrpcInvokeBySignature( |
| 2501 channel, |
| 2502 "PPB_URLRequestInfo_AppendDataToBody:iC:i", |
| 2503 request, |
| 2504 data_bytes, data, |
| 2505 success |
| 2506 ); |
| 2507 return retval; |
| 2508 } |
| 2509 |
| 2510 NaClSrpcError PpbURLRequestInfoRpcClient::PPB_URLRequestInfo_AppendFileToBody( |
| 2511 NaClSrpcChannel* channel, |
| 2512 PP_Resource request, |
| 2513 PP_Resource file_ref, |
| 2514 int64_t start_offset, |
| 2515 int64_t number_of_bytes, |
| 2516 double expected_last_modified_time, |
| 2517 int32_t* success) { |
| 2518 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2519 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2520 __FUNCTION__)); |
| 2521 NaClSrpcError retval; |
| 2522 retval = NaClSrpcInvokeBySignature( |
| 2523 channel, |
| 2524 "PPB_URLRequestInfo_AppendFileToBody:iilld:i", |
| 2525 request, |
| 2526 file_ref, |
| 2527 start_offset, |
| 2528 number_of_bytes, |
| 2529 expected_last_modified_time, |
| 2530 success |
| 2531 ); |
| 2532 return retval; |
| 2533 } |
| 2534 |
| 2535 NaClSrpcError PpbURLResponseInfoRpcClient::PPB_URLResponseInfo_IsURLResponseInfo
( |
| 2536 NaClSrpcChannel* channel, |
| 2537 PP_Resource resource, |
| 2538 int32_t* success) { |
| 2539 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2540 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2541 __FUNCTION__)); |
| 2542 NaClSrpcError retval; |
| 2543 retval = NaClSrpcInvokeBySignature( |
| 2544 channel, |
| 2545 "PPB_URLResponseInfo_IsURLResponseInfo:i:i", |
| 2546 resource, |
| 2547 success |
| 2548 ); |
| 2549 return retval; |
| 2550 } |
| 2551 |
| 2552 NaClSrpcError PpbURLResponseInfoRpcClient::PPB_URLResponseInfo_GetProperty( |
| 2553 NaClSrpcChannel* channel, |
| 2554 PP_Resource response, |
| 2555 int32_t property, |
| 2556 nacl_abi_size_t* value_bytes, char* value) { |
| 2557 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2558 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2559 __FUNCTION__)); |
| 2560 NaClSrpcError retval; |
| 2561 retval = NaClSrpcInvokeBySignature( |
| 2562 channel, |
| 2563 "PPB_URLResponseInfo_GetProperty:ii:C", |
| 2564 response, |
| 2565 property, |
| 2566 value_bytes, value |
| 2567 ); |
| 2568 return retval; |
| 2569 } |
| 2570 |
| 2571 NaClSrpcError PpbURLResponseInfoRpcClient::PPB_URLResponseInfo_GetBodyAsFileRef( |
| 2572 NaClSrpcChannel* channel, |
| 2573 PP_Resource response, |
| 2574 PP_Resource* file_ref) { |
| 2575 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2576 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2577 __FUNCTION__)); |
| 2578 NaClSrpcError retval; |
| 2579 retval = NaClSrpcInvokeBySignature( |
| 2580 channel, |
| 2581 "PPB_URLResponseInfo_GetBodyAsFileRef:i:i", |
| 2582 response, |
| 2583 file_ref |
| 2584 ); |
| 2585 return retval; |
| 2586 } |
| 2587 |
| 2588 NaClSrpcError PpbWidgetRpcClient::PPB_Widget_IsWidget( |
| 2589 NaClSrpcChannel* channel, |
| 2590 PP_Resource resource, |
| 2591 int32_t* is_widget) { |
| 2592 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2593 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2594 __FUNCTION__)); |
| 2595 NaClSrpcError retval; |
| 2596 retval = NaClSrpcInvokeBySignature( |
| 2597 channel, |
| 2598 "PPB_Widget_IsWidget:i:i", |
| 2599 resource, |
| 2600 is_widget |
| 2601 ); |
| 2602 return retval; |
| 2603 } |
| 2604 |
| 2605 NaClSrpcError PpbWidgetRpcClient::PPB_Widget_Paint( |
| 2606 NaClSrpcChannel* channel, |
| 2607 PP_Resource widget, |
| 2608 nacl_abi_size_t rect_bytes, char* rect, |
| 2609 PP_Resource image, |
| 2610 int32_t* success) { |
| 2611 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2612 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2613 __FUNCTION__)); |
| 2614 NaClSrpcError retval; |
| 2615 retval = NaClSrpcInvokeBySignature( |
| 2616 channel, |
| 2617 "PPB_Widget_Paint:iCi:i", |
| 2618 widget, |
| 2619 rect_bytes, rect, |
| 2620 image, |
| 2621 success |
| 2622 ); |
| 2623 return retval; |
| 2624 } |
| 2625 |
| 2626 NaClSrpcError PpbWidgetRpcClient::PPB_Widget_HandleEvent( |
| 2627 NaClSrpcChannel* channel, |
| 2628 PP_Resource widget, |
| 2629 PP_Resource event, |
| 2630 int32_t* handled) { |
| 2631 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2632 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2633 __FUNCTION__)); |
| 2634 NaClSrpcError retval; |
| 2635 retval = NaClSrpcInvokeBySignature( |
| 2636 channel, |
| 2637 "PPB_Widget_HandleEvent:ii:i", |
| 2638 widget, |
| 2639 event, |
| 2640 handled |
| 2641 ); |
| 2642 return retval; |
| 2643 } |
| 2644 |
| 2645 NaClSrpcError PpbWidgetRpcClient::PPB_Widget_GetLocation( |
| 2646 NaClSrpcChannel* channel, |
| 2647 PP_Resource widget, |
| 2648 nacl_abi_size_t* location_bytes, char* location, |
| 2649 int32_t* visible) { |
| 2650 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2651 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2652 __FUNCTION__)); |
| 2653 NaClSrpcError retval; |
| 2654 retval = NaClSrpcInvokeBySignature( |
| 2655 channel, |
| 2656 "PPB_Widget_GetLocation:i:Ci", |
| 2657 widget, |
| 2658 location_bytes, location, |
| 2659 visible |
| 2660 ); |
| 2661 return retval; |
| 2662 } |
| 2663 |
| 2664 NaClSrpcError PpbWidgetRpcClient::PPB_Widget_SetLocation( |
| 2665 NaClSrpcChannel* channel, |
| 2666 PP_Resource widget, |
| 2667 nacl_abi_size_t location_bytes, char* location) { |
| 2668 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2669 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2670 __FUNCTION__)); |
| 2671 NaClSrpcError retval; |
| 2672 retval = NaClSrpcInvokeBySignature( |
| 2673 channel, |
| 2674 "PPB_Widget_SetLocation:iC:", |
| 2675 widget, |
| 2676 location_bytes, location |
| 2677 ); |
| 2678 return retval; |
| 2679 } |
| 2680 |
| 2681 NaClSrpcError PpbZoomRpcClient::PPB_Zoom_ZoomChanged( |
| 2682 NaClSrpcChannel* channel, |
| 2683 PP_Instance instance, |
| 2684 double factor) { |
| 2685 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2686 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2687 __FUNCTION__)); |
| 2688 NaClSrpcError retval; |
| 2689 retval = NaClSrpcInvokeBySignature( |
| 2690 channel, |
| 2691 "PPB_Zoom_ZoomChanged:id:", |
| 2692 instance, |
| 2693 factor |
| 2694 ); |
| 2695 return retval; |
| 2696 } |
| 2697 |
| 2698 NaClSrpcError PpbZoomRpcClient::PPB_Zoom_ZoomLimitsChanged( |
| 2699 NaClSrpcChannel* channel, |
| 2700 PP_Instance instance, |
| 2701 double minimum_factor, |
| 2702 double maximum_factor) { |
| 2703 VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(), |
| 2704 ("%s: PPAPI calls are not supported off the main thread\n", |
| 2705 __FUNCTION__)); |
| 2706 NaClSrpcError retval; |
| 2707 retval = NaClSrpcInvokeBySignature( |
| 2708 channel, |
| 2709 "PPB_Zoom_ZoomLimitsChanged:idd:", |
| 2710 instance, |
| 2711 minimum_factor, |
| 2712 maximum_factor |
| 2713 ); |
| 2714 return retval; |
| 2715 } |
| 2716 |
| 2717 |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 7740013:
Cloning a bunch of stuff from the native_client repository at r6528 (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/