| 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 #ifndef GEN_PPAPI_PROXY_PPB_RPC_H_ |
| 12 #define GEN_PPAPI_PROXY_PPB_RPC_H_ |
| 13 |
| 14 #ifndef __native_client__ |
| 15 #include "native_client/src/include/portability.h" |
| 16 #endif // __native_client__ |
| 17 #include "native_client/src/shared/srpc/nacl_srpc.h" |
| 18 #include "ppapi/c/pp_instance.h" |
| 19 #include "ppapi/c/pp_module.h" |
| 20 #include "ppapi/c/pp_resource.h" |
| 21 |
| 22 class NaClFileRpcServer { |
| 23 public: |
| 24 static void StreamAsFile( |
| 25 NaClSrpcRpc* rpc, |
| 26 NaClSrpcClosure* done, |
| 27 PP_Instance instance, |
| 28 char* url, |
| 29 int32_t callback_id); |
| 30 static void GetFileDesc( |
| 31 NaClSrpcRpc* rpc, |
| 32 NaClSrpcClosure* done, |
| 33 PP_Instance instance, |
| 34 char* url, |
| 35 NaClSrpcImcDescType* file_desc); |
| 36 |
| 37 private: |
| 38 NaClFileRpcServer(); |
| 39 NaClFileRpcServer(const NaClFileRpcServer&); |
| 40 void operator=(const NaClFileRpcServer); |
| 41 }; // class NaClFileRpcServer |
| 42 |
| 43 class PpbRpcServer { |
| 44 public: |
| 45 static void PPB_GetInterface( |
| 46 NaClSrpcRpc* rpc, |
| 47 NaClSrpcClosure* done, |
| 48 char* interface_name, |
| 49 int32_t* exports_interface_name); |
| 50 |
| 51 private: |
| 52 PpbRpcServer(); |
| 53 PpbRpcServer(const PpbRpcServer&); |
| 54 void operator=(const PpbRpcServer); |
| 55 }; // class PpbRpcServer |
| 56 |
| 57 class PpbAudioRpcServer { |
| 58 public: |
| 59 static void PPB_Audio_Create( |
| 60 NaClSrpcRpc* rpc, |
| 61 NaClSrpcClosure* done, |
| 62 PP_Instance instance, |
| 63 PP_Resource config, |
| 64 PP_Resource* out_resource); |
| 65 static void PPB_Audio_IsAudio( |
| 66 NaClSrpcRpc* rpc, |
| 67 NaClSrpcClosure* done, |
| 68 PP_Resource resource, |
| 69 int32_t* out_bool); |
| 70 static void PPB_Audio_GetCurrentConfig( |
| 71 NaClSrpcRpc* rpc, |
| 72 NaClSrpcClosure* done, |
| 73 PP_Resource resource, |
| 74 PP_Resource* out_resource); |
| 75 static void PPB_Audio_StopPlayback( |
| 76 NaClSrpcRpc* rpc, |
| 77 NaClSrpcClosure* done, |
| 78 PP_Resource resource, |
| 79 int32_t* out_bool); |
| 80 static void PPB_Audio_StartPlayback( |
| 81 NaClSrpcRpc* rpc, |
| 82 NaClSrpcClosure* done, |
| 83 PP_Resource resource, |
| 84 int32_t* out_bool); |
| 85 |
| 86 private: |
| 87 PpbAudioRpcServer(); |
| 88 PpbAudioRpcServer(const PpbAudioRpcServer&); |
| 89 void operator=(const PpbAudioRpcServer); |
| 90 }; // class PpbAudioRpcServer |
| 91 |
| 92 class PpbAudioConfigRpcServer { |
| 93 public: |
| 94 static void PPB_AudioConfig_CreateStereo16Bit( |
| 95 NaClSrpcRpc* rpc, |
| 96 NaClSrpcClosure* done, |
| 97 PP_Instance instance, |
| 98 int32_t sample_rate, |
| 99 int32_t sample_frame_count, |
| 100 PP_Resource* resource); |
| 101 static void PPB_AudioConfig_IsAudioConfig( |
| 102 NaClSrpcRpc* rpc, |
| 103 NaClSrpcClosure* done, |
| 104 PP_Resource resource, |
| 105 int32_t* out_bool); |
| 106 static void PPB_AudioConfig_RecommendSampleFrameCount( |
| 107 NaClSrpcRpc* rpc, |
| 108 NaClSrpcClosure* done, |
| 109 int32_t request_sample_rate, |
| 110 int32_t request_sample_frame_count, |
| 111 int32_t* out_sample_frame_count); |
| 112 static void PPB_AudioConfig_GetSampleRate( |
| 113 NaClSrpcRpc* rpc, |
| 114 NaClSrpcClosure* done, |
| 115 PP_Resource resource, |
| 116 int32_t* sample_rate); |
| 117 static void PPB_AudioConfig_GetSampleFrameCount( |
| 118 NaClSrpcRpc* rpc, |
| 119 NaClSrpcClosure* done, |
| 120 PP_Resource resource, |
| 121 int32_t* sample_frame_count); |
| 122 |
| 123 private: |
| 124 PpbAudioConfigRpcServer(); |
| 125 PpbAudioConfigRpcServer(const PpbAudioConfigRpcServer&); |
| 126 void operator=(const PpbAudioConfigRpcServer); |
| 127 }; // class PpbAudioConfigRpcServer |
| 128 |
| 129 class PpbCoreRpcServer { |
| 130 public: |
| 131 static void PPB_Core_AddRefResource( |
| 132 NaClSrpcRpc* rpc, |
| 133 NaClSrpcClosure* done, |
| 134 PP_Resource resource); |
| 135 static void PPB_Core_ReleaseResource( |
| 136 NaClSrpcRpc* rpc, |
| 137 NaClSrpcClosure* done, |
| 138 PP_Resource resource); |
| 139 static void ReleaseResourceMultipleTimes( |
| 140 NaClSrpcRpc* rpc, |
| 141 NaClSrpcClosure* done, |
| 142 PP_Resource resource, |
| 143 int32_t count); |
| 144 static void PPB_Core_GetTime( |
| 145 NaClSrpcRpc* rpc, |
| 146 NaClSrpcClosure* done, |
| 147 double* time); |
| 148 static void PPB_Core_GetTimeTicks( |
| 149 NaClSrpcRpc* rpc, |
| 150 NaClSrpcClosure* done, |
| 151 double* time_ticks); |
| 152 static void PPB_Core_CallOnMainThread( |
| 153 NaClSrpcRpc* rpc, |
| 154 NaClSrpcClosure* done, |
| 155 int32_t delay_in_milliseconds, |
| 156 int32_t callback_id, |
| 157 int32_t result); |
| 158 |
| 159 private: |
| 160 PpbCoreRpcServer(); |
| 161 PpbCoreRpcServer(const PpbCoreRpcServer&); |
| 162 void operator=(const PpbCoreRpcServer); |
| 163 }; // class PpbCoreRpcServer |
| 164 |
| 165 class PpbCursorControlRpcServer { |
| 166 public: |
| 167 static void PPB_CursorControl_SetCursor( |
| 168 NaClSrpcRpc* rpc, |
| 169 NaClSrpcClosure* done, |
| 170 PP_Instance instance, |
| 171 int32_t type, |
| 172 PP_Resource custom_image, |
| 173 nacl_abi_size_t hot_spot_bytes, char* hot_spot, |
| 174 int32_t* success); |
| 175 static void PPB_CursorControl_LockCursor( |
| 176 NaClSrpcRpc* rpc, |
| 177 NaClSrpcClosure* done, |
| 178 PP_Instance instance, |
| 179 int32_t* success); |
| 180 static void PPB_CursorControl_UnlockCursor( |
| 181 NaClSrpcRpc* rpc, |
| 182 NaClSrpcClosure* done, |
| 183 PP_Instance instance, |
| 184 int32_t* success); |
| 185 static void PPB_CursorControl_HasCursorLock( |
| 186 NaClSrpcRpc* rpc, |
| 187 NaClSrpcClosure* done, |
| 188 PP_Instance instance, |
| 189 int32_t* success); |
| 190 static void PPB_CursorControl_CanLockCursor( |
| 191 NaClSrpcRpc* rpc, |
| 192 NaClSrpcClosure* done, |
| 193 PP_Instance instance, |
| 194 int32_t* success); |
| 195 |
| 196 private: |
| 197 PpbCursorControlRpcServer(); |
| 198 PpbCursorControlRpcServer(const PpbCursorControlRpcServer&); |
| 199 void operator=(const PpbCursorControlRpcServer); |
| 200 }; // class PpbCursorControlRpcServer |
| 201 |
| 202 class PpbFileIORpcServer { |
| 203 public: |
| 204 static void PPB_FileIO_Create( |
| 205 NaClSrpcRpc* rpc, |
| 206 NaClSrpcClosure* done, |
| 207 PP_Instance instance, |
| 208 PP_Resource* resource); |
| 209 static void PPB_FileIO_IsFileIO( |
| 210 NaClSrpcRpc* rpc, |
| 211 NaClSrpcClosure* done, |
| 212 PP_Resource resource, |
| 213 int32_t* success); |
| 214 static void PPB_FileIO_Open( |
| 215 NaClSrpcRpc* rpc, |
| 216 NaClSrpcClosure* done, |
| 217 PP_Resource file_io, |
| 218 PP_Resource file_ref, |
| 219 int32_t open_flags, |
| 220 int32_t callback_id, |
| 221 int32_t* pp_error); |
| 222 static void PPB_FileIO_Query( |
| 223 NaClSrpcRpc* rpc, |
| 224 NaClSrpcClosure* done, |
| 225 PP_Resource file_io, |
| 226 int32_t bytes_to_read, |
| 227 int32_t callback_id, |
| 228 nacl_abi_size_t* info_bytes, char* info, |
| 229 int32_t* pp_error); |
| 230 static void PPB_FileIO_Touch( |
| 231 NaClSrpcRpc* rpc, |
| 232 NaClSrpcClosure* done, |
| 233 PP_Resource file_io, |
| 234 double last_access_time, |
| 235 double last_modified_time, |
| 236 int32_t callback_id, |
| 237 int32_t* pp_error); |
| 238 static void PPB_FileIO_Read( |
| 239 NaClSrpcRpc* rpc, |
| 240 NaClSrpcClosure* done, |
| 241 PP_Resource file_io, |
| 242 int64_t offset, |
| 243 int32_t bytes_to_read, |
| 244 int32_t callback_id, |
| 245 nacl_abi_size_t* buffer_bytes, char* buffer, |
| 246 int32_t* pp_error_or_bytes); |
| 247 static void PPB_FileIO_Write( |
| 248 NaClSrpcRpc* rpc, |
| 249 NaClSrpcClosure* done, |
| 250 PP_Resource file_io, |
| 251 int64_t offset, |
| 252 nacl_abi_size_t buffer_bytes, char* buffer, |
| 253 int32_t bytes_to_write, |
| 254 int32_t callback_id, |
| 255 int32_t* pp_error_or_bytes); |
| 256 static void PPB_FileIO_SetLength( |
| 257 NaClSrpcRpc* rpc, |
| 258 NaClSrpcClosure* done, |
| 259 PP_Resource file_io, |
| 260 int64_t length, |
| 261 int32_t callback_id, |
| 262 int32_t* pp_error); |
| 263 static void PPB_FileIO_Flush( |
| 264 NaClSrpcRpc* rpc, |
| 265 NaClSrpcClosure* done, |
| 266 PP_Resource file_io, |
| 267 int32_t callback_id, |
| 268 int32_t* pp_error); |
| 269 static void PPB_FileIO_Close( |
| 270 NaClSrpcRpc* rpc, |
| 271 NaClSrpcClosure* done, |
| 272 PP_Resource file_io); |
| 273 |
| 274 private: |
| 275 PpbFileIORpcServer(); |
| 276 PpbFileIORpcServer(const PpbFileIORpcServer&); |
| 277 void operator=(const PpbFileIORpcServer); |
| 278 }; // class PpbFileIORpcServer |
| 279 |
| 280 class PpbFileRefRpcServer { |
| 281 public: |
| 282 static void PPB_FileRef_Create( |
| 283 NaClSrpcRpc* rpc, |
| 284 NaClSrpcClosure* done, |
| 285 PP_Resource file_system, |
| 286 nacl_abi_size_t path_bytes, char* path, |
| 287 PP_Resource* resource); |
| 288 static void PPB_FileRef_IsFileRef( |
| 289 NaClSrpcRpc* rpc, |
| 290 NaClSrpcClosure* done, |
| 291 PP_Resource resource, |
| 292 int32_t* success); |
| 293 static void PPB_FileRef_GetFileSystemType( |
| 294 NaClSrpcRpc* rpc, |
| 295 NaClSrpcClosure* done, |
| 296 PP_Resource file_ref, |
| 297 int32_t* file_system_type); |
| 298 static void PPB_FileRef_GetName( |
| 299 NaClSrpcRpc* rpc, |
| 300 NaClSrpcClosure* done, |
| 301 PP_Resource file_ref, |
| 302 nacl_abi_size_t* name_bytes, char* name); |
| 303 static void PPB_FileRef_GetPath( |
| 304 NaClSrpcRpc* rpc, |
| 305 NaClSrpcClosure* done, |
| 306 PP_Resource file_ref, |
| 307 nacl_abi_size_t* path_bytes, char* path); |
| 308 static void PPB_FileRef_GetParent( |
| 309 NaClSrpcRpc* rpc, |
| 310 NaClSrpcClosure* done, |
| 311 PP_Resource file_ref, |
| 312 PP_Resource* parent); |
| 313 static void PPB_FileRef_MakeDirectory( |
| 314 NaClSrpcRpc* rpc, |
| 315 NaClSrpcClosure* done, |
| 316 PP_Resource directory_ref, |
| 317 int32_t make_ancestors, |
| 318 int32_t callback_id, |
| 319 int32_t* pp_error); |
| 320 static void PPB_FileRef_Touch( |
| 321 NaClSrpcRpc* rpc, |
| 322 NaClSrpcClosure* done, |
| 323 PP_Resource file_ref, |
| 324 double last_access_time, |
| 325 double last_modified_time, |
| 326 int32_t callback_id, |
| 327 int32_t* pp_error); |
| 328 static void PPB_FileRef_Delete( |
| 329 NaClSrpcRpc* rpc, |
| 330 NaClSrpcClosure* done, |
| 331 PP_Resource file_ref, |
| 332 int32_t callback_id, |
| 333 int32_t* pp_error); |
| 334 static void PPB_FileRef_Rename( |
| 335 NaClSrpcRpc* rpc, |
| 336 NaClSrpcClosure* done, |
| 337 PP_Resource file_ref, |
| 338 PP_Resource new_file_ref, |
| 339 int32_t callback_id, |
| 340 int32_t* pp_error); |
| 341 |
| 342 private: |
| 343 PpbFileRefRpcServer(); |
| 344 PpbFileRefRpcServer(const PpbFileRefRpcServer&); |
| 345 void operator=(const PpbFileRefRpcServer); |
| 346 }; // class PpbFileRefRpcServer |
| 347 |
| 348 class PpbFileSystemRpcServer { |
| 349 public: |
| 350 static void PPB_FileSystem_Create( |
| 351 NaClSrpcRpc* rpc, |
| 352 NaClSrpcClosure* done, |
| 353 PP_Instance instance, |
| 354 int32_t file_system_type, |
| 355 PP_Resource* resource); |
| 356 static void PPB_FileSystem_IsFileSystem( |
| 357 NaClSrpcRpc* rpc, |
| 358 NaClSrpcClosure* done, |
| 359 PP_Resource resource, |
| 360 int32_t* success); |
| 361 static void PPB_FileSystem_Open( |
| 362 NaClSrpcRpc* rpc, |
| 363 NaClSrpcClosure* done, |
| 364 PP_Resource file_system, |
| 365 int64_t expected_size, |
| 366 int32_t callback_id, |
| 367 int32_t* pp_error); |
| 368 static void PPB_FileSystem_GetType( |
| 369 NaClSrpcRpc* rpc, |
| 370 NaClSrpcClosure* done, |
| 371 PP_Resource file_system, |
| 372 int32_t* type); |
| 373 |
| 374 private: |
| 375 PpbFileSystemRpcServer(); |
| 376 PpbFileSystemRpcServer(const PpbFileSystemRpcServer&); |
| 377 void operator=(const PpbFileSystemRpcServer); |
| 378 }; // class PpbFileSystemRpcServer |
| 379 |
| 380 class PpbFindRpcServer { |
| 381 public: |
| 382 static void PPB_Find_NumberOfFindResultsChanged( |
| 383 NaClSrpcRpc* rpc, |
| 384 NaClSrpcClosure* done, |
| 385 PP_Instance instance, |
| 386 int32_t total, |
| 387 int32_t final_result); |
| 388 static void PPB_Find_SelectedFindResultChanged( |
| 389 NaClSrpcRpc* rpc, |
| 390 NaClSrpcClosure* done, |
| 391 PP_Instance instance, |
| 392 int32_t index); |
| 393 |
| 394 private: |
| 395 PpbFindRpcServer(); |
| 396 PpbFindRpcServer(const PpbFindRpcServer&); |
| 397 void operator=(const PpbFindRpcServer); |
| 398 }; // class PpbFindRpcServer |
| 399 |
| 400 class PpbFontRpcServer { |
| 401 public: |
| 402 static void PPB_Font_GetFontFamilies( |
| 403 NaClSrpcRpc* rpc, |
| 404 NaClSrpcClosure* done, |
| 405 PP_Instance instance, |
| 406 nacl_abi_size_t* font_families_bytes, char* font_families); |
| 407 static void PPB_Font_Create( |
| 408 NaClSrpcRpc* rpc, |
| 409 NaClSrpcClosure* done, |
| 410 PP_Instance instance, |
| 411 nacl_abi_size_t description_bytes, char* description, |
| 412 nacl_abi_size_t face_bytes, char* face, |
| 413 PP_Resource* font); |
| 414 static void PPB_Font_IsFont( |
| 415 NaClSrpcRpc* rpc, |
| 416 NaClSrpcClosure* done, |
| 417 PP_Resource resource, |
| 418 int32_t* is_font); |
| 419 static void PPB_Font_Describe( |
| 420 NaClSrpcRpc* rpc, |
| 421 NaClSrpcClosure* done, |
| 422 PP_Resource font, |
| 423 nacl_abi_size_t* description_bytes, char* description, |
| 424 nacl_abi_size_t* face_bytes, char* face, |
| 425 nacl_abi_size_t* metrics_bytes, char* metrics, |
| 426 int32_t* success); |
| 427 static void PPB_Font_DrawTextAt( |
| 428 NaClSrpcRpc* rpc, |
| 429 NaClSrpcClosure* done, |
| 430 PP_Resource font, |
| 431 PP_Resource image_data, |
| 432 nacl_abi_size_t text_run_bytes, char* text_run, |
| 433 nacl_abi_size_t text_bytes, char* text, |
| 434 nacl_abi_size_t position_bytes, char* position, |
| 435 int32_t color, |
| 436 nacl_abi_size_t clip_bytes, char* clip, |
| 437 int32_t image_data_is_opaque, |
| 438 int32_t* success); |
| 439 static void PPB_Font_MeasureText( |
| 440 NaClSrpcRpc* rpc, |
| 441 NaClSrpcClosure* done, |
| 442 PP_Resource font, |
| 443 nacl_abi_size_t text_run_bytes, char* text_run, |
| 444 nacl_abi_size_t text_bytes, char* text, |
| 445 int32_t* width); |
| 446 static void PPB_Font_CharacterOffsetForPixel( |
| 447 NaClSrpcRpc* rpc, |
| 448 NaClSrpcClosure* done, |
| 449 PP_Resource font, |
| 450 nacl_abi_size_t text_run_bytes, char* text_run, |
| 451 nacl_abi_size_t text_bytes, char* text, |
| 452 int32_t pixel_position, |
| 453 int32_t* offset); |
| 454 static void PPB_Font_PixelOffsetForCharacter( |
| 455 NaClSrpcRpc* rpc, |
| 456 NaClSrpcClosure* done, |
| 457 PP_Resource font, |
| 458 nacl_abi_size_t text_run_bytes, char* text_run, |
| 459 nacl_abi_size_t text_bytes, char* text, |
| 460 int32_t char_offset, |
| 461 int32_t* offset); |
| 462 |
| 463 private: |
| 464 PpbFontRpcServer(); |
| 465 PpbFontRpcServer(const PpbFontRpcServer&); |
| 466 void operator=(const PpbFontRpcServer); |
| 467 }; // class PpbFontRpcServer |
| 468 |
| 469 class PpbGraphics2DRpcServer { |
| 470 public: |
| 471 static void PPB_Graphics2D_Create( |
| 472 NaClSrpcRpc* rpc, |
| 473 NaClSrpcClosure* done, |
| 474 PP_Instance instance, |
| 475 nacl_abi_size_t size_bytes, char* size, |
| 476 int32_t is_always_opaque, |
| 477 PP_Resource* resource); |
| 478 static void PPB_Graphics2D_IsGraphics2D( |
| 479 NaClSrpcRpc* rpc, |
| 480 NaClSrpcClosure* done, |
| 481 PP_Resource resource, |
| 482 int32_t* success); |
| 483 static void PPB_Graphics2D_Describe( |
| 484 NaClSrpcRpc* rpc, |
| 485 NaClSrpcClosure* done, |
| 486 PP_Resource graphics_2d, |
| 487 nacl_abi_size_t* size_bytes, char* size, |
| 488 int32_t* is_always_opaque, |
| 489 int32_t* success); |
| 490 static void PPB_Graphics2D_PaintImageData( |
| 491 NaClSrpcRpc* rpc, |
| 492 NaClSrpcClosure* done, |
| 493 PP_Resource graphics_2d, |
| 494 PP_Resource image, |
| 495 nacl_abi_size_t top_left_bytes, char* top_left, |
| 496 nacl_abi_size_t src_rect_bytes, char* src_rect); |
| 497 static void PPB_Graphics2D_Scroll( |
| 498 NaClSrpcRpc* rpc, |
| 499 NaClSrpcClosure* done, |
| 500 PP_Resource graphics_2d, |
| 501 nacl_abi_size_t clip_rect_bytes, char* clip_rect, |
| 502 nacl_abi_size_t amount_bytes, char* amount); |
| 503 static void PPB_Graphics2D_ReplaceContents( |
| 504 NaClSrpcRpc* rpc, |
| 505 NaClSrpcClosure* done, |
| 506 PP_Resource graphics_2d, |
| 507 PP_Resource image); |
| 508 static void PPB_Graphics2D_Flush( |
| 509 NaClSrpcRpc* rpc, |
| 510 NaClSrpcClosure* done, |
| 511 PP_Resource graphics_2d, |
| 512 int32_t callback_id, |
| 513 int32_t* pp_error); |
| 514 |
| 515 private: |
| 516 PpbGraphics2DRpcServer(); |
| 517 PpbGraphics2DRpcServer(const PpbGraphics2DRpcServer&); |
| 518 void operator=(const PpbGraphics2DRpcServer); |
| 519 }; // class PpbGraphics2DRpcServer |
| 520 |
| 521 class PpbGraphics3DRpcServer { |
| 522 public: |
| 523 static void PPB_Graphics3D_Create( |
| 524 NaClSrpcRpc* rpc, |
| 525 NaClSrpcClosure* done, |
| 526 PP_Instance instance, |
| 527 PP_Resource share_context, |
| 528 nacl_abi_size_t attrib_list_bytes, int32_t* attrib_list, |
| 529 PP_Resource* resource_id); |
| 530 static void PPB_Graphics3D_GetAttribs( |
| 531 NaClSrpcRpc* rpc, |
| 532 NaClSrpcClosure* done, |
| 533 PP_Resource context, |
| 534 nacl_abi_size_t input_attrib_list_bytes, int32_t* input_attrib_list, |
| 535 nacl_abi_size_t* output_attrib_list_bytes, int32_t* output_attrib_list, |
| 536 int32_t* pp_error); |
| 537 static void PPB_Graphics3D_SetAttribs( |
| 538 NaClSrpcRpc* rpc, |
| 539 NaClSrpcClosure* done, |
| 540 PP_Resource context, |
| 541 nacl_abi_size_t attrib_list_bytes, int32_t* attrib_list, |
| 542 int32_t* pp_error); |
| 543 static void PPB_Graphics3D_ResizeBuffers( |
| 544 NaClSrpcRpc* rpc, |
| 545 NaClSrpcClosure* done, |
| 546 PP_Resource context, |
| 547 int32_t width, |
| 548 int32_t height, |
| 549 int32_t* pp_error); |
| 550 static void PPB_Graphics3D_SwapBuffers( |
| 551 NaClSrpcRpc* rpc, |
| 552 NaClSrpcClosure* done, |
| 553 PP_Resource context, |
| 554 int32_t callback_id, |
| 555 int32_t* pp_error); |
| 556 static void PPB_Graphics3DTrusted_CreateRaw( |
| 557 NaClSrpcRpc* rpc, |
| 558 NaClSrpcClosure* done, |
| 559 PP_Instance instance, |
| 560 PP_Resource share_context, |
| 561 nacl_abi_size_t attrib_list_bytes, int32_t* attrib_list, |
| 562 PP_Resource* resource_id); |
| 563 static void PPB_Graphics3DTrusted_InitCommandBuffer( |
| 564 NaClSrpcRpc* rpc, |
| 565 NaClSrpcClosure* done, |
| 566 PP_Resource resource_id, |
| 567 int32_t size, |
| 568 int32_t* success); |
| 569 static void PPB_Graphics3DTrusted_GetRingBuffer( |
| 570 NaClSrpcRpc* rpc, |
| 571 NaClSrpcClosure* done, |
| 572 PP_Resource resource_id, |
| 573 NaClSrpcImcDescType* shm_desc, |
| 574 int32_t* shm_size); |
| 575 static void PPB_Graphics3DTrusted_GetState( |
| 576 NaClSrpcRpc* rpc, |
| 577 NaClSrpcClosure* done, |
| 578 PP_Resource resource_id, |
| 579 nacl_abi_size_t* state_bytes, char* state); |
| 580 static void PPB_Graphics3DTrusted_Flush( |
| 581 NaClSrpcRpc* rpc, |
| 582 NaClSrpcClosure* done, |
| 583 PP_Resource resource_id, |
| 584 int32_t put_offset); |
| 585 static void PPB_Graphics3DTrusted_FlushSync( |
| 586 NaClSrpcRpc* rpc, |
| 587 NaClSrpcClosure* done, |
| 588 PP_Resource resource_id, |
| 589 int32_t put_offset, |
| 590 nacl_abi_size_t* state_bytes, char* state); |
| 591 static void PPB_Graphics3DTrusted_CreateTransferBuffer( |
| 592 NaClSrpcRpc* rpc, |
| 593 NaClSrpcClosure* done, |
| 594 PP_Resource resource_id, |
| 595 int32_t size, |
| 596 int32_t request_id, |
| 597 int32_t* id); |
| 598 static void PPB_Graphics3DTrusted_DestroyTransferBuffer( |
| 599 NaClSrpcRpc* rpc, |
| 600 NaClSrpcClosure* done, |
| 601 PP_Resource resource_id, |
| 602 int32_t id); |
| 603 static void PPB_Graphics3DTrusted_GetTransferBuffer( |
| 604 NaClSrpcRpc* rpc, |
| 605 NaClSrpcClosure* done, |
| 606 PP_Resource resource_id, |
| 607 int32_t id, |
| 608 NaClSrpcImcDescType* shm_desc, |
| 609 int32_t* shm_size); |
| 610 |
| 611 private: |
| 612 PpbGraphics3DRpcServer(); |
| 613 PpbGraphics3DRpcServer(const PpbGraphics3DRpcServer&); |
| 614 void operator=(const PpbGraphics3DRpcServer); |
| 615 }; // class PpbGraphics3DRpcServer |
| 616 |
| 617 class PpbImageDataRpcServer { |
| 618 public: |
| 619 static void PPB_ImageData_GetNativeImageDataFormat( |
| 620 NaClSrpcRpc* rpc, |
| 621 NaClSrpcClosure* done, |
| 622 int32_t* format); |
| 623 static void PPB_ImageData_IsImageDataFormatSupported( |
| 624 NaClSrpcRpc* rpc, |
| 625 NaClSrpcClosure* done, |
| 626 int32_t format, |
| 627 int32_t* success); |
| 628 static void PPB_ImageData_Create( |
| 629 NaClSrpcRpc* rpc, |
| 630 NaClSrpcClosure* done, |
| 631 PP_Instance instance, |
| 632 int32_t format, |
| 633 nacl_abi_size_t size_bytes, char* size, |
| 634 int32_t init_to_zero, |
| 635 PP_Resource* resource); |
| 636 static void PPB_ImageData_IsImageData( |
| 637 NaClSrpcRpc* rpc, |
| 638 NaClSrpcClosure* done, |
| 639 PP_Resource resource, |
| 640 int32_t* success); |
| 641 static void PPB_ImageData_Describe( |
| 642 NaClSrpcRpc* rpc, |
| 643 NaClSrpcClosure* done, |
| 644 PP_Resource resource, |
| 645 nacl_abi_size_t* desc_bytes, char* desc, |
| 646 NaClSrpcImcDescType* shm, |
| 647 int32_t* shm_size, |
| 648 int32_t* success); |
| 649 |
| 650 private: |
| 651 PpbImageDataRpcServer(); |
| 652 PpbImageDataRpcServer(const PpbImageDataRpcServer&); |
| 653 void operator=(const PpbImageDataRpcServer); |
| 654 }; // class PpbImageDataRpcServer |
| 655 |
| 656 class PpbInputEventRpcServer { |
| 657 public: |
| 658 static void PPB_InputEvent_RequestInputEvents( |
| 659 NaClSrpcRpc* rpc, |
| 660 NaClSrpcClosure* done, |
| 661 PP_Instance instance, |
| 662 int32_t event_classes, |
| 663 int32_t filtered, |
| 664 int32_t* success); |
| 665 static void PPB_InputEvent_ClearInputEventRequest( |
| 666 NaClSrpcRpc* rpc, |
| 667 NaClSrpcClosure* done, |
| 668 PP_Instance instance, |
| 669 int32_t event_classes); |
| 670 static void PPB_InputEvent_CreateMouseInputEvent( |
| 671 NaClSrpcRpc* rpc, |
| 672 NaClSrpcClosure* done, |
| 673 PP_Instance instance, |
| 674 int32_t type, |
| 675 double time_stamp, |
| 676 int32_t modifiers, |
| 677 int32_t mouse_button, |
| 678 int32_t mouse_position_x, |
| 679 int32_t mouse_position_y, |
| 680 int32_t click_count, |
| 681 PP_Resource* resource_id); |
| 682 static void PPB_InputEvent_CreateWheelInputEvent( |
| 683 NaClSrpcRpc* rpc, |
| 684 NaClSrpcClosure* done, |
| 685 PP_Instance instance, |
| 686 double time_stamp, |
| 687 int32_t modifiers, |
| 688 double wheel_delta_x, |
| 689 double wheel_delta_y, |
| 690 double wheel_ticks_x, |
| 691 double wheel_ticks_y, |
| 692 int32_t scroll_by_page, |
| 693 PP_Resource* resource_id); |
| 694 static void PPB_InputEvent_CreateKeyboardInputEvent( |
| 695 NaClSrpcRpc* rpc, |
| 696 NaClSrpcClosure* done, |
| 697 PP_Instance instance, |
| 698 int32_t type, |
| 699 double time_stamp, |
| 700 int32_t modifiers, |
| 701 int32_t key_code, |
| 702 nacl_abi_size_t character_text_bytes, char* character_text, |
| 703 PP_Resource* resource_id); |
| 704 |
| 705 private: |
| 706 PpbInputEventRpcServer(); |
| 707 PpbInputEventRpcServer(const PpbInputEventRpcServer&); |
| 708 void operator=(const PpbInputEventRpcServer); |
| 709 }; // class PpbInputEventRpcServer |
| 710 |
| 711 class PpbInstanceRpcServer { |
| 712 public: |
| 713 static void PPB_Instance_BindGraphics( |
| 714 NaClSrpcRpc* rpc, |
| 715 NaClSrpcClosure* done, |
| 716 PP_Instance instance, |
| 717 PP_Resource graphics_device, |
| 718 int32_t* success); |
| 719 static void PPB_Instance_IsFullFrame( |
| 720 NaClSrpcRpc* rpc, |
| 721 NaClSrpcClosure* done, |
| 722 PP_Instance instance, |
| 723 int32_t* is_full_frame); |
| 724 |
| 725 private: |
| 726 PpbInstanceRpcServer(); |
| 727 PpbInstanceRpcServer(const PpbInstanceRpcServer&); |
| 728 void operator=(const PpbInstanceRpcServer); |
| 729 }; // class PpbInstanceRpcServer |
| 730 |
| 731 class PpbMessagingRpcServer { |
| 732 public: |
| 733 static void PPB_Messaging_PostMessage( |
| 734 NaClSrpcRpc* rpc, |
| 735 NaClSrpcClosure* done, |
| 736 PP_Instance instance, |
| 737 nacl_abi_size_t message_bytes, char* message); |
| 738 |
| 739 private: |
| 740 PpbMessagingRpcServer(); |
| 741 PpbMessagingRpcServer(const PpbMessagingRpcServer&); |
| 742 void operator=(const PpbMessagingRpcServer); |
| 743 }; // class PpbMessagingRpcServer |
| 744 |
| 745 class PpbPdfRpcServer { |
| 746 public: |
| 747 static void PPB_PDF_GetLocalizedString( |
| 748 NaClSrpcRpc* rpc, |
| 749 NaClSrpcClosure* done, |
| 750 PP_Instance instance, |
| 751 int32_t string_id, |
| 752 nacl_abi_size_t* string_bytes, char* string); |
| 753 static void PPB_PDF_GetResourceImage( |
| 754 NaClSrpcRpc* rpc, |
| 755 NaClSrpcClosure* done, |
| 756 PP_Instance instance, |
| 757 int32_t image_id, |
| 758 PP_Resource* image); |
| 759 static void PPB_PDF_GetFontFileWithFallback( |
| 760 NaClSrpcRpc* rpc, |
| 761 NaClSrpcClosure* done, |
| 762 PP_Instance instance, |
| 763 nacl_abi_size_t description_bytes, char* description, |
| 764 nacl_abi_size_t face_bytes, char* face, |
| 765 int32_t charset, |
| 766 PP_Resource* font); |
| 767 static void PPB_PDF_GetFontTableForPrivateFontFile( |
| 768 NaClSrpcRpc* rpc, |
| 769 NaClSrpcClosure* done, |
| 770 PP_Resource font_file, |
| 771 int32_t table, |
| 772 nacl_abi_size_t* output_bytes, char* output, |
| 773 int32_t* success); |
| 774 static void PPB_PDF_SearchString( |
| 775 NaClSrpcRpc* rpc, |
| 776 NaClSrpcClosure* done, |
| 777 PP_Instance instance, |
| 778 nacl_abi_size_t string_bytes, char* string, |
| 779 nacl_abi_size_t term_bytes, char* term, |
| 780 int32_t case_sensitive, |
| 781 nacl_abi_size_t* results_bytes, char* results, |
| 782 int32_t* count); |
| 783 static void PPB_PDF_DidStartLoading( |
| 784 NaClSrpcRpc* rpc, |
| 785 NaClSrpcClosure* done, |
| 786 PP_Instance instance); |
| 787 static void PPB_PDF_DidStopLoading( |
| 788 NaClSrpcRpc* rpc, |
| 789 NaClSrpcClosure* done, |
| 790 PP_Instance instance); |
| 791 static void PPB_PDF_SetContentRestriction( |
| 792 NaClSrpcRpc* rpc, |
| 793 NaClSrpcClosure* done, |
| 794 PP_Instance instance, |
| 795 int32_t restrictions); |
| 796 static void PPB_PDF_HistogramPDFPageCount( |
| 797 NaClSrpcRpc* rpc, |
| 798 NaClSrpcClosure* done, |
| 799 int32_t count); |
| 800 static void PPB_PDF_UserMetricsRecordAction( |
| 801 NaClSrpcRpc* rpc, |
| 802 NaClSrpcClosure* done, |
| 803 nacl_abi_size_t action_bytes, char* action); |
| 804 static void PPB_PDF_HasUnsupportedFeature( |
| 805 NaClSrpcRpc* rpc, |
| 806 NaClSrpcClosure* done, |
| 807 PP_Instance instance); |
| 808 static void PPB_PDF_SaveAs( |
| 809 NaClSrpcRpc* rpc, |
| 810 NaClSrpcClosure* done, |
| 811 PP_Instance instance); |
| 812 |
| 813 private: |
| 814 PpbPdfRpcServer(); |
| 815 PpbPdfRpcServer(const PpbPdfRpcServer&); |
| 816 void operator=(const PpbPdfRpcServer); |
| 817 }; // class PpbPdfRpcServer |
| 818 |
| 819 class PpbScrollbarRpcServer { |
| 820 public: |
| 821 static void PPB_Scrollbar_Create( |
| 822 NaClSrpcRpc* rpc, |
| 823 NaClSrpcClosure* done, |
| 824 PP_Instance instance, |
| 825 int32_t vertical, |
| 826 PP_Resource* scrollbar); |
| 827 static void PPB_Scrollbar_IsScrollbar( |
| 828 NaClSrpcRpc* rpc, |
| 829 NaClSrpcClosure* done, |
| 830 PP_Resource resource, |
| 831 int32_t* is_scrollbar); |
| 832 static void PPB_Scrollbar_IsOverlay( |
| 833 NaClSrpcRpc* rpc, |
| 834 NaClSrpcClosure* done, |
| 835 PP_Resource resource, |
| 836 int32_t* is_overlay); |
| 837 static void PPB_Scrollbar_GetThickness( |
| 838 NaClSrpcRpc* rpc, |
| 839 NaClSrpcClosure* done, |
| 840 PP_Resource resource, |
| 841 int32_t* thickness); |
| 842 static void PPB_Scrollbar_GetValue( |
| 843 NaClSrpcRpc* rpc, |
| 844 NaClSrpcClosure* done, |
| 845 PP_Resource scrollbar, |
| 846 int32_t* value); |
| 847 static void PPB_Scrollbar_SetValue( |
| 848 NaClSrpcRpc* rpc, |
| 849 NaClSrpcClosure* done, |
| 850 PP_Resource scrollbar, |
| 851 int32_t value); |
| 852 static void PPB_Scrollbar_SetDocumentSize( |
| 853 NaClSrpcRpc* rpc, |
| 854 NaClSrpcClosure* done, |
| 855 PP_Resource scrollbar, |
| 856 int32_t size); |
| 857 static void PPB_Scrollbar_SetTickMarks( |
| 858 NaClSrpcRpc* rpc, |
| 859 NaClSrpcClosure* done, |
| 860 PP_Resource scrollbar, |
| 861 nacl_abi_size_t tick_marks_bytes, char* tick_marks, |
| 862 int32_t count); |
| 863 static void PPB_Scrollbar_ScrollBy( |
| 864 NaClSrpcRpc* rpc, |
| 865 NaClSrpcClosure* done, |
| 866 PP_Resource scrollbar, |
| 867 int32_t unit, |
| 868 int32_t multiplier); |
| 869 |
| 870 private: |
| 871 PpbScrollbarRpcServer(); |
| 872 PpbScrollbarRpcServer(const PpbScrollbarRpcServer&); |
| 873 void operator=(const PpbScrollbarRpcServer); |
| 874 }; // class PpbScrollbarRpcServer |
| 875 |
| 876 class PpbTestingRpcServer { |
| 877 public: |
| 878 static void PPB_Testing_ReadImageData( |
| 879 NaClSrpcRpc* rpc, |
| 880 NaClSrpcClosure* done, |
| 881 PP_Resource device_context_2d, |
| 882 PP_Resource image, |
| 883 nacl_abi_size_t top_left_bytes, char* top_left, |
| 884 int32_t* success); |
| 885 static void PPB_Testing_RunMessageLoop( |
| 886 NaClSrpcRpc* rpc, |
| 887 NaClSrpcClosure* done, |
| 888 PP_Instance instance); |
| 889 static void PPB_Testing_QuitMessageLoop( |
| 890 NaClSrpcRpc* rpc, |
| 891 NaClSrpcClosure* done, |
| 892 PP_Instance instance); |
| 893 static void PPB_Testing_GetLiveObjectsForInstance( |
| 894 NaClSrpcRpc* rpc, |
| 895 NaClSrpcClosure* done, |
| 896 PP_Instance instance, |
| 897 int32_t* live_object_count); |
| 898 |
| 899 private: |
| 900 PpbTestingRpcServer(); |
| 901 PpbTestingRpcServer(const PpbTestingRpcServer&); |
| 902 void operator=(const PpbTestingRpcServer); |
| 903 }; // class PpbTestingRpcServer |
| 904 |
| 905 class PpbURLLoaderRpcServer { |
| 906 public: |
| 907 static void PPB_URLLoader_Create( |
| 908 NaClSrpcRpc* rpc, |
| 909 NaClSrpcClosure* done, |
| 910 PP_Instance instance, |
| 911 PP_Resource* resource); |
| 912 static void PPB_URLLoader_IsURLLoader( |
| 913 NaClSrpcRpc* rpc, |
| 914 NaClSrpcClosure* done, |
| 915 PP_Resource resource, |
| 916 int32_t* is_url_loader); |
| 917 static void PPB_URLLoader_Open( |
| 918 NaClSrpcRpc* rpc, |
| 919 NaClSrpcClosure* done, |
| 920 PP_Resource loader, |
| 921 PP_Resource request, |
| 922 int32_t callback_id, |
| 923 int32_t* pp_error); |
| 924 static void PPB_URLLoader_FollowRedirect( |
| 925 NaClSrpcRpc* rpc, |
| 926 NaClSrpcClosure* done, |
| 927 PP_Resource loader, |
| 928 int32_t callback_id, |
| 929 int32_t* pp_error); |
| 930 static void PPB_URLLoader_GetUploadProgress( |
| 931 NaClSrpcRpc* rpc, |
| 932 NaClSrpcClosure* done, |
| 933 PP_Resource loader, |
| 934 int64_t* bytes_sent, |
| 935 int64_t* total_bytes_to_be_sent, |
| 936 int32_t* success); |
| 937 static void PPB_URLLoader_GetDownloadProgress( |
| 938 NaClSrpcRpc* rpc, |
| 939 NaClSrpcClosure* done, |
| 940 PP_Resource loader, |
| 941 int64_t* bytes_received, |
| 942 int64_t* total_bytes_to_be_received, |
| 943 int32_t* success); |
| 944 static void PPB_URLLoader_GetResponseInfo( |
| 945 NaClSrpcRpc* rpc, |
| 946 NaClSrpcClosure* done, |
| 947 PP_Resource loader, |
| 948 PP_Resource* response); |
| 949 static void PPB_URLLoader_ReadResponseBody( |
| 950 NaClSrpcRpc* rpc, |
| 951 NaClSrpcClosure* done, |
| 952 PP_Resource loader, |
| 953 int32_t bytes_to_read, |
| 954 int32_t callback_id, |
| 955 nacl_abi_size_t* buffer_bytes, char* buffer, |
| 956 int32_t* pp_error_or_bytes); |
| 957 static void PPB_URLLoader_FinishStreamingToFile( |
| 958 NaClSrpcRpc* rpc, |
| 959 NaClSrpcClosure* done, |
| 960 PP_Resource loader, |
| 961 int32_t callback_id, |
| 962 int32_t* pp_error); |
| 963 static void PPB_URLLoader_Close( |
| 964 NaClSrpcRpc* rpc, |
| 965 NaClSrpcClosure* done, |
| 966 PP_Resource loader); |
| 967 |
| 968 private: |
| 969 PpbURLLoaderRpcServer(); |
| 970 PpbURLLoaderRpcServer(const PpbURLLoaderRpcServer&); |
| 971 void operator=(const PpbURLLoaderRpcServer); |
| 972 }; // class PpbURLLoaderRpcServer |
| 973 |
| 974 class PpbURLRequestInfoRpcServer { |
| 975 public: |
| 976 static void PPB_URLRequestInfo_Create( |
| 977 NaClSrpcRpc* rpc, |
| 978 NaClSrpcClosure* done, |
| 979 PP_Instance instance, |
| 980 PP_Resource* resource); |
| 981 static void PPB_URLRequestInfo_IsURLRequestInfo( |
| 982 NaClSrpcRpc* rpc, |
| 983 NaClSrpcClosure* done, |
| 984 PP_Resource resource, |
| 985 int32_t* success); |
| 986 static void PPB_URLRequestInfo_SetProperty( |
| 987 NaClSrpcRpc* rpc, |
| 988 NaClSrpcClosure* done, |
| 989 PP_Resource request, |
| 990 int32_t property, |
| 991 nacl_abi_size_t value_bytes, char* value, |
| 992 int32_t* success); |
| 993 static void PPB_URLRequestInfo_AppendDataToBody( |
| 994 NaClSrpcRpc* rpc, |
| 995 NaClSrpcClosure* done, |
| 996 PP_Resource request, |
| 997 nacl_abi_size_t data_bytes, char* data, |
| 998 int32_t* success); |
| 999 static void PPB_URLRequestInfo_AppendFileToBody( |
| 1000 NaClSrpcRpc* rpc, |
| 1001 NaClSrpcClosure* done, |
| 1002 PP_Resource request, |
| 1003 PP_Resource file_ref, |
| 1004 int64_t start_offset, |
| 1005 int64_t number_of_bytes, |
| 1006 double expected_last_modified_time, |
| 1007 int32_t* success); |
| 1008 |
| 1009 private: |
| 1010 PpbURLRequestInfoRpcServer(); |
| 1011 PpbURLRequestInfoRpcServer(const PpbURLRequestInfoRpcServer&); |
| 1012 void operator=(const PpbURLRequestInfoRpcServer); |
| 1013 }; // class PpbURLRequestInfoRpcServer |
| 1014 |
| 1015 class PpbURLResponseInfoRpcServer { |
| 1016 public: |
| 1017 static void PPB_URLResponseInfo_IsURLResponseInfo( |
| 1018 NaClSrpcRpc* rpc, |
| 1019 NaClSrpcClosure* done, |
| 1020 PP_Resource resource, |
| 1021 int32_t* success); |
| 1022 static void PPB_URLResponseInfo_GetProperty( |
| 1023 NaClSrpcRpc* rpc, |
| 1024 NaClSrpcClosure* done, |
| 1025 PP_Resource response, |
| 1026 int32_t property, |
| 1027 nacl_abi_size_t* value_bytes, char* value); |
| 1028 static void PPB_URLResponseInfo_GetBodyAsFileRef( |
| 1029 NaClSrpcRpc* rpc, |
| 1030 NaClSrpcClosure* done, |
| 1031 PP_Resource response, |
| 1032 PP_Resource* file_ref); |
| 1033 |
| 1034 private: |
| 1035 PpbURLResponseInfoRpcServer(); |
| 1036 PpbURLResponseInfoRpcServer(const PpbURLResponseInfoRpcServer&); |
| 1037 void operator=(const PpbURLResponseInfoRpcServer); |
| 1038 }; // class PpbURLResponseInfoRpcServer |
| 1039 |
| 1040 class PpbWidgetRpcServer { |
| 1041 public: |
| 1042 static void PPB_Widget_IsWidget( |
| 1043 NaClSrpcRpc* rpc, |
| 1044 NaClSrpcClosure* done, |
| 1045 PP_Resource resource, |
| 1046 int32_t* is_widget); |
| 1047 static void PPB_Widget_Paint( |
| 1048 NaClSrpcRpc* rpc, |
| 1049 NaClSrpcClosure* done, |
| 1050 PP_Resource widget, |
| 1051 nacl_abi_size_t rect_bytes, char* rect, |
| 1052 PP_Resource image, |
| 1053 int32_t* success); |
| 1054 static void PPB_Widget_HandleEvent( |
| 1055 NaClSrpcRpc* rpc, |
| 1056 NaClSrpcClosure* done, |
| 1057 PP_Resource widget, |
| 1058 PP_Resource event, |
| 1059 int32_t* handled); |
| 1060 static void PPB_Widget_GetLocation( |
| 1061 NaClSrpcRpc* rpc, |
| 1062 NaClSrpcClosure* done, |
| 1063 PP_Resource widget, |
| 1064 nacl_abi_size_t* location_bytes, char* location, |
| 1065 int32_t* visible); |
| 1066 static void PPB_Widget_SetLocation( |
| 1067 NaClSrpcRpc* rpc, |
| 1068 NaClSrpcClosure* done, |
| 1069 PP_Resource widget, |
| 1070 nacl_abi_size_t location_bytes, char* location); |
| 1071 |
| 1072 private: |
| 1073 PpbWidgetRpcServer(); |
| 1074 PpbWidgetRpcServer(const PpbWidgetRpcServer&); |
| 1075 void operator=(const PpbWidgetRpcServer); |
| 1076 }; // class PpbWidgetRpcServer |
| 1077 |
| 1078 class PpbZoomRpcServer { |
| 1079 public: |
| 1080 static void PPB_Zoom_ZoomChanged( |
| 1081 NaClSrpcRpc* rpc, |
| 1082 NaClSrpcClosure* done, |
| 1083 PP_Instance instance, |
| 1084 double factor); |
| 1085 static void PPB_Zoom_ZoomLimitsChanged( |
| 1086 NaClSrpcRpc* rpc, |
| 1087 NaClSrpcClosure* done, |
| 1088 PP_Instance instance, |
| 1089 double minimum_factor, |
| 1090 double maximum_factor); |
| 1091 |
| 1092 private: |
| 1093 PpbZoomRpcServer(); |
| 1094 PpbZoomRpcServer(const PpbZoomRpcServer&); |
| 1095 void operator=(const PpbZoomRpcServer); |
| 1096 }; // class PpbZoomRpcServer |
| 1097 |
| 1098 class PpbRpcs { |
| 1099 public: |
| 1100 static NaClSrpcHandlerDesc srpc_methods[]; |
| 1101 }; // class PpbRpcs |
| 1102 |
| 1103 |
| 1104 #endif // GEN_PPAPI_PROXY_PPB_RPC_H_ |
| 1105 |
| 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/