1 // Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. 2 // 3 // Redistribution and use in source and binary forms, with or without 4 // modification, are permitted provided that the following conditions are 5 // met: 6 // 7 // * Redistributions of source code must retain the above copyright 8 // notice, this list of conditions and the following disclaimer. 9 // * Redistributions in binary form must reproduce the above 10 // copyright notice, this list of conditions and the following disclaimer 11 // in the documentation and/or other materials provided with the 12 // distribution. 13 // * Neither the name of Google Inc. nor the name Chromium Embedded 14 // Framework nor the names of its contributors may be used to endorse 15 // or promote products derived from this software without specific prior 16 // written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 // 30 // --------------------------------------------------------------------------- 31 // 32 // The contents of this file must follow a specific format in order to 33 // support the CEF translator tool. See the translator.README.txt file in the 34 // tools directory for more information. 35 // 36 37 #ifndef CEF_INCLUDE_CEF_VALUES_H_ 38 #define CEF_INCLUDE_CEF_VALUES_H_ 39 #pragma once 40 41 #include <vector> 42 #include "include/cef_base.h" 43 44 class CefBinaryValue; 45 class CefDictionaryValue; 46 class CefListValue; 47 48 typedef cef_value_type_t CefValueType; 49 50 /// 51 // Class that wraps other data value types. Complex types (binary, dictionary 52 // and list) will be referenced but not owned by this object. Can be used on any 53 // process and thread. 54 /// 55 /*--cef(source=library)--*/ 56 class CefValue : public virtual CefBaseRefCounted { 57 public: 58 /// 59 // Creates a new object. 60 /// 61 /*--cef()--*/ 62 static CefRefPtr<CefValue> Create(); 63 64 /// 65 // Returns true if the underlying data is valid. This will always be true for 66 // simple types. For complex types (binary, dictionary and list) the 67 // underlying data may become invalid if owned by another object (e.g. list or 68 // dictionary) and that other object is then modified or destroyed. This value 69 // object can be re-used by calling Set*() even if the underlying data is 70 // invalid. 71 /// 72 /*--cef()--*/ 73 virtual bool IsValid() = 0; 74 75 /// 76 // Returns true if the underlying data is owned by another object. 77 /// 78 /*--cef()--*/ 79 virtual bool IsOwned() = 0; 80 81 /// 82 // Returns true if the underlying data is read-only. Some APIs may expose 83 // read-only objects. 84 /// 85 /*--cef()--*/ 86 virtual bool IsReadOnly() = 0; 87 88 /// 89 // Returns true if this object and |that| object have the same underlying 90 // data. If true modifications to this object will also affect |that| object 91 // and vice-versa. 92 /// 93 /*--cef()--*/ 94 virtual bool IsSame(CefRefPtr<CefValue> that) = 0; 95 96 /// 97 // Returns true if this object and |that| object have an equivalent underlying 98 // value but are not necessarily the same object. 99 /// 100 /*--cef()--*/ 101 virtual bool IsEqual(CefRefPtr<CefValue> that) = 0; 102 103 /// 104 // Returns a copy of this object. The underlying data will also be copied. 105 /// 106 /*--cef()--*/ 107 virtual CefRefPtr<CefValue> Copy() = 0; 108 109 /// 110 // Returns the underlying value type. 111 /// 112 /*--cef(default_retval=VTYPE_INVALID)--*/ 113 virtual CefValueType GetType() = 0; 114 115 /// 116 // Returns the underlying value as type bool. 117 /// 118 /*--cef()--*/ 119 virtual bool GetBool() = 0; 120 121 /// 122 // Returns the underlying value as type int. 123 /// 124 /*--cef()--*/ 125 virtual int GetInt() = 0; 126 127 /// 128 // Returns the underlying value as type double. 129 /// 130 /*--cef()--*/ 131 virtual double GetDouble() = 0; 132 133 /// 134 // Returns the underlying value as type string. 135 /// 136 /*--cef()--*/ 137 virtual CefString GetString() = 0; 138 139 /// 140 // Returns the underlying value as type binary. The returned reference may 141 // become invalid if the value is owned by another object or if ownership is 142 // transferred to another object in the future. To maintain a reference to 143 // the value after assigning ownership to a dictionary or list pass this 144 // object to the SetValue() method instead of passing the returned reference 145 // to SetBinary(). 146 /// 147 /*--cef()--*/ 148 virtual CefRefPtr<CefBinaryValue> GetBinary() = 0; 149 150 /// 151 // Returns the underlying value as type dictionary. The returned reference may 152 // become invalid if the value is owned by another object or if ownership is 153 // transferred to another object in the future. To maintain a reference to 154 // the value after assigning ownership to a dictionary or list pass this 155 // object to the SetValue() method instead of passing the returned reference 156 // to SetDictionary(). 157 /// 158 /*--cef()--*/ 159 virtual CefRefPtr<CefDictionaryValue> GetDictionary() = 0; 160 161 /// 162 // Returns the underlying value as type list. The returned reference may 163 // become invalid if the value is owned by another object or if ownership is 164 // transferred to another object in the future. To maintain a reference to 165 // the value after assigning ownership to a dictionary or list pass this 166 // object to the SetValue() method instead of passing the returned reference 167 // to SetList(). 168 /// 169 /*--cef()--*/ 170 virtual CefRefPtr<CefListValue> GetList() = 0; 171 172 /// 173 // Sets the underlying value as type null. Returns true if the value was set 174 // successfully. 175 /// 176 /*--cef()--*/ 177 virtual bool SetNull() = 0; 178 179 /// 180 // Sets the underlying value as type bool. Returns true if the value was set 181 // successfully. 182 /// 183 /*--cef()--*/ 184 virtual bool SetBool(bool value) = 0; 185 186 /// 187 // Sets the underlying value as type int. Returns true if the value was set 188 // successfully. 189 /// 190 /*--cef()--*/ 191 virtual bool SetInt(int value) = 0; 192 193 /// 194 // Sets the underlying value as type double. Returns true if the value was set 195 // successfully. 196 /// 197 /*--cef()--*/ 198 virtual bool SetDouble(double value) = 0; 199 200 /// 201 // Sets the underlying value as type string. Returns true if the value was set 202 // successfully. 203 /// 204 /*--cef(optional_param=value)--*/ 205 virtual bool SetString(const CefString& value) = 0; 206 207 /// 208 // Sets the underlying value as type binary. Returns true if the value was set 209 // successfully. This object keeps a reference to |value| and ownership of the 210 // underlying data remains unchanged. 211 /// 212 /*--cef()--*/ 213 virtual bool SetBinary(CefRefPtr<CefBinaryValue> value) = 0; 214 215 /// 216 // Sets the underlying value as type dict. Returns true if the value was set 217 // successfully. This object keeps a reference to |value| and ownership of the 218 // underlying data remains unchanged. 219 /// 220 /*--cef()--*/ 221 virtual bool SetDictionary(CefRefPtr<CefDictionaryValue> value) = 0; 222 223 /// 224 // Sets the underlying value as type list. Returns true if the value was set 225 // successfully. This object keeps a reference to |value| and ownership of the 226 // underlying data remains unchanged. 227 /// 228 /*--cef()--*/ 229 virtual bool SetList(CefRefPtr<CefListValue> value) = 0; 230 }; 231 232 /// 233 // Class representing a binary value. Can be used on any process and thread. 234 /// 235 /*--cef(source=library)--*/ 236 class CefBinaryValue : public virtual CefBaseRefCounted { 237 public: 238 /// 239 // Creates a new object that is not owned by any other object. The specified 240 // |data| will be copied. 241 /// 242 /*--cef()--*/ 243 static CefRefPtr<CefBinaryValue> Create(const void* data, size_t data_size); 244 245 /// 246 // Returns true if this object is valid. This object may become invalid if 247 // the underlying data is owned by another object (e.g. list or dictionary) 248 // and that other object is then modified or destroyed. Do not call any other 249 // methods if this method returns false. 250 /// 251 /*--cef()--*/ 252 virtual bool IsValid() = 0; 253 254 /// 255 // Returns true if this object is currently owned by another object. 256 /// 257 /*--cef()--*/ 258 virtual bool IsOwned() = 0; 259 260 /// 261 // Returns true if this object and |that| object have the same underlying 262 // data. 263 /// 264 /*--cef()--*/ 265 virtual bool IsSame(CefRefPtr<CefBinaryValue> that) = 0; 266 267 /// 268 // Returns true if this object and |that| object have an equivalent underlying 269 // value but are not necessarily the same object. 270 /// 271 /*--cef()--*/ 272 virtual bool IsEqual(CefRefPtr<CefBinaryValue> that) = 0; 273 274 /// 275 // Returns a copy of this object. The data in this object will also be copied. 276 /// 277 /*--cef()--*/ 278 virtual CefRefPtr<CefBinaryValue> Copy() = 0; 279 280 /// 281 // Returns the data size. 282 /// 283 /*--cef()--*/ 284 virtual size_t GetSize() = 0; 285 286 /// 287 // Read up to |buffer_size| number of bytes into |buffer|. Reading begins at 288 // the specified byte |data_offset|. Returns the number of bytes read. 289 /// 290 /*--cef()--*/ 291 virtual size_t GetData(void* buffer, 292 size_t buffer_size, 293 size_t data_offset) = 0; 294 }; 295 296 /// 297 // Class representing a dictionary value. Can be used on any process and thread. 298 /// 299 /*--cef(source=library)--*/ 300 class CefDictionaryValue : public virtual CefBaseRefCounted { 301 public: 302 typedef std::vector<CefString> KeyList; 303 304 /// 305 // Creates a new object that is not owned by any other object. 306 /// 307 /*--cef()--*/ 308 static CefRefPtr<CefDictionaryValue> Create(); 309 310 /// 311 // Returns true if this object is valid. This object may become invalid if 312 // the underlying data is owned by another object (e.g. list or dictionary) 313 // and that other object is then modified or destroyed. Do not call any other 314 // methods if this method returns false. 315 /// 316 /*--cef()--*/ 317 virtual bool IsValid() = 0; 318 319 /// 320 // Returns true if this object is currently owned by another object. 321 /// 322 /*--cef()--*/ 323 virtual bool IsOwned() = 0; 324 325 /// 326 // Returns true if the values of this object are read-only. Some APIs may 327 // expose read-only objects. 328 /// 329 /*--cef()--*/ 330 virtual bool IsReadOnly() = 0; 331 332 /// 333 // Returns true if this object and |that| object have the same underlying 334 // data. If true modifications to this object will also affect |that| object 335 // and vice-versa. 336 /// 337 /*--cef()--*/ 338 virtual bool IsSame(CefRefPtr<CefDictionaryValue> that) = 0; 339 340 /// 341 // Returns true if this object and |that| object have an equivalent underlying 342 // value but are not necessarily the same object. 343 /// 344 /*--cef()--*/ 345 virtual bool IsEqual(CefRefPtr<CefDictionaryValue> that) = 0; 346 347 /// 348 // Returns a writable copy of this object. If |exclude_empty_children| is true 349 // any empty dictionaries or lists will be excluded from the copy. 350 /// 351 /*--cef()--*/ 352 virtual CefRefPtr<CefDictionaryValue> Copy(bool exclude_empty_children) = 0; 353 354 /// 355 // Returns the number of values. 356 /// 357 /*--cef()--*/ 358 virtual size_t GetSize() = 0; 359 360 /// 361 // Removes all values. Returns true on success. 362 /// 363 /*--cef()--*/ 364 virtual bool Clear() = 0; 365 366 /// 367 // Returns true if the current dictionary has a value for the given key. 368 /// 369 /*--cef()--*/ 370 virtual bool HasKey(const CefString& key) = 0; 371 372 /// 373 // Reads all keys for this dictionary into the specified vector. 374 /// 375 /*--cef()--*/ 376 virtual bool GetKeys(KeyList& keys) = 0; 377 378 /// 379 // Removes the value at the specified key. Returns true is the value was 380 // removed successfully. 381 /// 382 /*--cef()--*/ 383 virtual bool Remove(const CefString& key) = 0; 384 385 /// 386 // Returns the value type for the specified key. 387 /// 388 /*--cef(default_retval=VTYPE_INVALID)--*/ 389 virtual CefValueType GetType(const CefString& key) = 0; 390 391 /// 392 // Returns the value at the specified key. For simple types the returned 393 // value will copy existing data and modifications to the value will not 394 // modify this object. For complex types (binary, dictionary and list) the 395 // returned value will reference existing data and modifications to the value 396 // will modify this object. 397 /// 398 /*--cef()--*/ 399 virtual CefRefPtr<CefValue> GetValue(const CefString& key) = 0; 400 401 /// 402 // Returns the value at the specified key as type bool. 403 /// 404 /*--cef()--*/ 405 virtual bool GetBool(const CefString& key) = 0; 406 407 /// 408 // Returns the value at the specified key as type int. 409 /// 410 /*--cef()--*/ 411 virtual int GetInt(const CefString& key) = 0; 412 413 /// 414 // Returns the value at the specified key as type double. 415 /// 416 /*--cef()--*/ 417 virtual double GetDouble(const CefString& key) = 0; 418 419 /// 420 // Returns the value at the specified key as type string. 421 /// 422 /*--cef()--*/ 423 virtual CefString GetString(const CefString& key) = 0; 424 425 /// 426 // Returns the value at the specified key as type binary. The returned 427 // value will reference existing data. 428 /// 429 /*--cef()--*/ 430 virtual CefRefPtr<CefBinaryValue> GetBinary(const CefString& key) = 0; 431 432 /// 433 // Returns the value at the specified key as type dictionary. The returned 434 // value will reference existing data and modifications to the value will 435 // modify this object. 436 /// 437 /*--cef()--*/ 438 virtual CefRefPtr<CefDictionaryValue> GetDictionary(const CefString& key) = 0; 439 440 /// 441 // Returns the value at the specified key as type list. The returned value 442 // will reference existing data and modifications to the value will modify 443 // this object. 444 /// 445 /*--cef()--*/ 446 virtual CefRefPtr<CefListValue> GetList(const CefString& key) = 0; 447 448 /// 449 // Sets the value at the specified key. Returns true if the value was set 450 // successfully. If |value| represents simple data then the underlying data 451 // will be copied and modifications to |value| will not modify this object. If 452 // |value| represents complex data (binary, dictionary or list) then the 453 // underlying data will be referenced and modifications to |value| will modify 454 // this object. 455 /// 456 /*--cef()--*/ 457 virtual bool SetValue(const CefString& key, CefRefPtr<CefValue> value) = 0; 458 459 /// 460 // Sets the value at the specified key as type null. Returns true if the 461 // value was set successfully. 462 /// 463 /*--cef()--*/ 464 virtual bool SetNull(const CefString& key) = 0; 465 466 /// 467 // Sets the value at the specified key as type bool. Returns true if the 468 // value was set successfully. 469 /// 470 /*--cef()--*/ 471 virtual bool SetBool(const CefString& key, bool value) = 0; 472 473 /// 474 // Sets the value at the specified key as type int. Returns true if the 475 // value was set successfully. 476 /// 477 /*--cef()--*/ 478 virtual bool SetInt(const CefString& key, int value) = 0; 479 480 /// 481 // Sets the value at the specified key as type double. Returns true if the 482 // value was set successfully. 483 /// 484 /*--cef()--*/ 485 virtual bool SetDouble(const CefString& key, double value) = 0; 486 487 /// 488 // Sets the value at the specified key as type string. Returns true if the 489 // value was set successfully. 490 /// 491 /*--cef(optional_param=value)--*/ 492 virtual bool SetString(const CefString& key, const CefString& value) = 0; 493 494 /// 495 // Sets the value at the specified key as type binary. Returns true if the 496 // value was set successfully. If |value| is currently owned by another object 497 // then the value will be copied and the |value| reference will not change. 498 // Otherwise, ownership will be transferred to this object and the |value| 499 // reference will be invalidated. 500 /// 501 /*--cef()--*/ 502 virtual bool SetBinary(const CefString& key, 503 CefRefPtr<CefBinaryValue> value) = 0; 504 505 /// 506 // Sets the value at the specified key as type dict. Returns true if the 507 // value was set successfully. If |value| is currently owned by another object 508 // then the value will be copied and the |value| reference will not change. 509 // Otherwise, ownership will be transferred to this object and the |value| 510 // reference will be invalidated. 511 /// 512 /*--cef()--*/ 513 virtual bool SetDictionary(const CefString& key, 514 CefRefPtr<CefDictionaryValue> value) = 0; 515 516 /// 517 // Sets the value at the specified key as type list. Returns true if the 518 // value was set successfully. If |value| is currently owned by another object 519 // then the value will be copied and the |value| reference will not change. 520 // Otherwise, ownership will be transferred to this object and the |value| 521 // reference will be invalidated. 522 /// 523 /*--cef()--*/ 524 virtual bool SetList(const CefString& key, CefRefPtr<CefListValue> value) = 0; 525 }; 526 527 /// 528 // Class representing a list value. Can be used on any process and thread. 529 /// 530 /*--cef(source=library)--*/ 531 class CefListValue : public virtual CefBaseRefCounted { 532 public: 533 /// 534 // Creates a new object that is not owned by any other object. 535 /// 536 /*--cef()--*/ 537 static CefRefPtr<CefListValue> Create(); 538 539 /// 540 // Returns true if this object is valid. This object may become invalid if 541 // the underlying data is owned by another object (e.g. list or dictionary) 542 // and that other object is then modified or destroyed. Do not call any other 543 // methods if this method returns false. 544 /// 545 /*--cef()--*/ 546 virtual bool IsValid() = 0; 547 548 /// 549 // Returns true if this object is currently owned by another object. 550 /// 551 /*--cef()--*/ 552 virtual bool IsOwned() = 0; 553 554 /// 555 // Returns true if the values of this object are read-only. Some APIs may 556 // expose read-only objects. 557 /// 558 /*--cef()--*/ 559 virtual bool IsReadOnly() = 0; 560 561 /// 562 // Returns true if this object and |that| object have the same underlying 563 // data. If true modifications to this object will also affect |that| object 564 // and vice-versa. 565 /// 566 /*--cef()--*/ 567 virtual bool IsSame(CefRefPtr<CefListValue> that) = 0; 568 569 /// 570 // Returns true if this object and |that| object have an equivalent underlying 571 // value but are not necessarily the same object. 572 /// 573 /*--cef()--*/ 574 virtual bool IsEqual(CefRefPtr<CefListValue> that) = 0; 575 576 /// 577 // Returns a writable copy of this object. 578 /// 579 /*--cef()--*/ 580 virtual CefRefPtr<CefListValue> Copy() = 0; 581 582 /// 583 // Sets the number of values. If the number of values is expanded all 584 // new value slots will default to type null. Returns true on success. 585 /// 586 /*--cef()--*/ 587 virtual bool SetSize(size_t size) = 0; 588 589 /// 590 // Returns the number of values. 591 /// 592 /*--cef()--*/ 593 virtual size_t GetSize() = 0; 594 595 /// 596 // Removes all values. Returns true on success. 597 /// 598 /*--cef()--*/ 599 virtual bool Clear() = 0; 600 601 /// 602 // Removes the value at the specified index. 603 /// 604 /*--cef()--*/ 605 virtual bool Remove(size_t index) = 0; 606 607 /// 608 // Returns the value type at the specified index. 609 /// 610 /*--cef(default_retval=VTYPE_INVALID)--*/ 611 virtual CefValueType GetType(size_t index) = 0; 612 613 /// 614 // Returns the value at the specified index. For simple types the returned 615 // value will copy existing data and modifications to the value will not 616 // modify this object. For complex types (binary, dictionary and list) the 617 // returned value will reference existing data and modifications to the value 618 // will modify this object. 619 /// 620 /*--cef()--*/ 621 virtual CefRefPtr<CefValue> GetValue(size_t index) = 0; 622 623 /// 624 // Returns the value at the specified index as type bool. 625 /// 626 /*--cef()--*/ 627 virtual bool GetBool(size_t index) = 0; 628 629 /// 630 // Returns the value at the specified index as type int. 631 /// 632 /*--cef()--*/ 633 virtual int GetInt(size_t index) = 0; 634 635 /// 636 // Returns the value at the specified index as type double. 637 /// 638 /*--cef()--*/ 639 virtual double GetDouble(size_t index) = 0; 640 641 /// 642 // Returns the value at the specified index as type string. 643 /// 644 /*--cef()--*/ 645 virtual CefString GetString(size_t index) = 0; 646 647 /// 648 // Returns the value at the specified index as type binary. The returned 649 // value will reference existing data. 650 /// 651 /*--cef()--*/ 652 virtual CefRefPtr<CefBinaryValue> GetBinary(size_t index) = 0; 653 654 /// 655 // Returns the value at the specified index as type dictionary. The returned 656 // value will reference existing data and modifications to the value will 657 // modify this object. 658 /// 659 /*--cef()--*/ 660 virtual CefRefPtr<CefDictionaryValue> GetDictionary(size_t index) = 0; 661 662 /// 663 // Returns the value at the specified index as type list. The returned 664 // value will reference existing data and modifications to the value will 665 // modify this object. 666 /// 667 /*--cef()--*/ 668 virtual CefRefPtr<CefListValue> GetList(size_t index) = 0; 669 670 /// 671 // Sets the value at the specified index. Returns true if the value was set 672 // successfully. If |value| represents simple data then the underlying data 673 // will be copied and modifications to |value| will not modify this object. If 674 // |value| represents complex data (binary, dictionary or list) then the 675 // underlying data will be referenced and modifications to |value| will modify 676 // this object. 677 /// 678 /*--cef()--*/ 679 virtual bool SetValue(size_t index, CefRefPtr<CefValue> value) = 0; 680 681 /// 682 // Sets the value at the specified index as type null. Returns true if the 683 // value was set successfully. 684 /// 685 /*--cef()--*/ 686 virtual bool SetNull(size_t index) = 0; 687 688 /// 689 // Sets the value at the specified index as type bool. Returns true if the 690 // value was set successfully. 691 /// 692 /*--cef()--*/ 693 virtual bool SetBool(size_t index, bool value) = 0; 694 695 /// 696 // Sets the value at the specified index as type int. Returns true if the 697 // value was set successfully. 698 /// 699 /*--cef()--*/ 700 virtual bool SetInt(size_t index, int value) = 0; 701 702 /// 703 // Sets the value at the specified index as type double. Returns true if the 704 // value was set successfully. 705 /// 706 /*--cef()--*/ 707 virtual bool SetDouble(size_t index, double value) = 0; 708 709 /// 710 // Sets the value at the specified index as type string. Returns true if the 711 // value was set successfully. 712 /// 713 /*--cef(optional_param=value)--*/ 714 virtual bool SetString(size_t index, const CefString& value) = 0; 715 716 /// 717 // Sets the value at the specified index as type binary. Returns true if the 718 // value was set successfully. If |value| is currently owned by another object 719 // then the value will be copied and the |value| reference will not change. 720 // Otherwise, ownership will be transferred to this object and the |value| 721 // reference will be invalidated. 722 /// 723 /*--cef()--*/ 724 virtual bool SetBinary(size_t index, CefRefPtr<CefBinaryValue> value) = 0; 725 726 /// 727 // Sets the value at the specified index as type dict. Returns true if the 728 // value was set successfully. If |value| is currently owned by another object 729 // then the value will be copied and the |value| reference will not change. 730 // Otherwise, ownership will be transferred to this object and the |value| 731 // reference will be invalidated. 732 /// 733 /*--cef()--*/ 734 virtual bool SetDictionary(size_t index, 735 CefRefPtr<CefDictionaryValue> value) = 0; 736 737 /// 738 // Sets the value at the specified index as type list. Returns true if the 739 // value was set successfully. If |value| is currently owned by another object 740 // then the value will be copied and the |value| reference will not change. 741 // Otherwise, ownership will be transferred to this object and the |value| 742 // reference will be invalidated. 743 /// 744 /*--cef()--*/ 745 virtual bool SetList(size_t index, CefRefPtr<CefListValue> value) = 0; 746 }; 747 748 #endif // CEF_INCLUDE_CEF_VALUES_H_ 749