commit 84eeef4e2f1c39b6f47d16c02c3e94ccb2483e37 Author: abba23 Date: Thu Apr 29 20:05:41 2021 +0200 Initial commit diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..f2e16f8 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,19 @@ +name: build + +on: [push, pull_request] + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v2 + - name: Run make + run: make + - name: Strip binary + run: strip target/release/libspotifyadblock.so + - name: Create build artifact + uses: actions/upload-artifact@v1 + with: + name: spotify-adblock.so + path: target/release/libspotifyadblock.so diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..9036f96 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,24 @@ +name: release + +on: + release: + types: + - created + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v2 + - name: Run make + run: make + - name: Attach build artifact to release + uses: actions/upload-release-asset@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + upload_url: ${{ github.event.release.upload_url }} + asset_name: spotify-adblock.so + asset_path: target/release/libspotifyadblock.so + asset_content_type: application/octet-stream diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fcf34bb --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +Cargo.lock +target/ +include/ diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..44bc88f --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "spotify-adblock" +version = "1.0.0" +authors = ["abba23"] +description = "Adblocker for Spotify" +edition = "2018" + +[dependencies] +home = "*" +lazy_static = "*" +libc = "*" +serde = { version = "*", features = ["derive"] } +toml = "*" +redhook = "*" +regex = "*" + +[lib] +name = "spotifyadblock" +crate_type = ["dylib"] + +[profile.release] +lto = true +panic = "abort" diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..58293a6 --- /dev/null +++ b/Makefile @@ -0,0 +1,32 @@ +NAME = spotify-adblock +PREFIX = /usr/local +PROFILE ?= release +BINARY_PATH = target/$(PROFILE)/libspotifyadblock.so +CONFIG_PATH = config.toml +BINARY_TARGET = $(DESTDIR)$(PREFIX)/lib/$(NAME).so +CONFIG_TARGET = /etc/$(NAME)/config.toml + +.PHONY: all +all: $(BINARY_PATH) + +$(BINARY_PATH): src Cargo.toml + # cargo build --profile $(PROFILE) +ifeq ($(PROFILE), release) + cargo build --release +else + cargo build +endif + +.PHONY: clean +clean: + rm -rf target + +.PHONY: install +install: $(BINARY_PATH) $(CONFIG_PATH) + install -D --mode=644 --strip $(BINARY_PATH) $(BINARY_TARGET) + install -D --mode=644 $(CONFIG_PATH) $(CONFIG_TARGET) + +.PHONY: uninstall +uninstall: + rm -f $(BINARY_TARGET) + rm -f $(CONFIG_TARGET) diff --git a/README.md b/README.md new file mode 100644 index 0000000..1507e18 --- /dev/null +++ b/README.md @@ -0,0 +1,58 @@ +# spotify-adblock +Spotify adblocker for Linux (macOS untested) that works by wrapping `getaddrinfo` and `cef_urlrequest_create`. It blocks requests to domains in the allowlist and URLs in the denylist. + +### Notes +* This does not work with the snap and Flatpak Spotify packages. + +## Build +Prerequisites: +* Git +* Make +* Rust + + +--- + + $ git clone https://github.com/abba23/spotify-adblock.git + $ cd spotify-adblock + $ make + +## Install + $ sudo make install + +## Usage + +### Command-line + $ LD_PRELOAD=/usr/local/lib/spotify-adblock.so spotify + +### Desktop file +You can integrate it with your desktop environment by creating a `.desktop` file (e.g. `spotify-adblock.desktop`) in `~/.local/share/applications`. This lets you easily run it from an application launcher without opening a terminal. + +
+ Example +

+ +``` +[Desktop Entry] +Type=Application +Name=Spotify (adblock) +GenericName=Music Player +Icon=spotify-client +TryExec=spotify +Exec=env LD_PRELOAD=/usr/local/lib/spotify-adblock.so spotify %U +Terminal=false +MimeType=x-scheme-handler/spotify; +Categories=Audio;Music;Player;AudioVideo; +StartupWMClass=spotify +``` +

+
+ +## Uninstall + $ sudo make uninstall + + +## Configuration +The allowlist and denylist can be configured in a config file located at `/etc/spotify-adblock/config.toml`, which can be overriden by (in ascending order of precedence): +* `~/.config/spotify-adblock/config.toml` +* `config.toml` in the working directory diff --git a/config.toml b/config.toml new file mode 100644 index 0000000..ae6187b --- /dev/null +++ b/config.toml @@ -0,0 +1,69 @@ +allowlist = [ + 'localhost', # local proxies + 'audio-sp-.*\.pscdn\.co', # audio + 'audio-fa\.scdn\.co', # audio + 'audio4-fa\.scdn\.co', # audio + 'charts-images\.scdn\.co', # charts images + 'daily-mix\.scdn\.co', # daily mix images + 'dailymix-images\.scdn\.co', # daily mix images + 'heads-fa\.scdn\.co', # audio (heads) + 'i\.scdn\.co', # cover art + 'lineup-images\.scdn\.co', # playlists lineup images + 'merch-img\.scdn\.co', # merch images + 'misc\.scdn\.co', # miscellaneous images + 'mosaic\.scdn\.co', # playlist mosaic images + 'newjams-images\.scdn\.co', # release radar images + 'o\.scdn\.co', # cover art + 'pl\.scdn\.co', # playlist images + 'profile-images\.scdn\.co', # artist profile images + 'seeded-session-images\.scdn\.co', # radio images + 't\.scdn\.co', # background images + 'thisis-images\.scdn\.co', # 'this is' playlists images + 'video-fa\.scdn\.co', # videos + 'content\.production\.cdn\.art19\.com', # podcasts + 'rss\.art19\.com', # podcasts + '.*\.buzzsprout\.com', # podcasts + 'platform-lookaside\.fbsbx\.com', # Facebook profile images + 'genius\.com', # lyrics (genius-spicetify) + '.*\.gvt1\.com', # Widevine download + 'hwcdn\.libsyn\.com', # podcasts + 'traffic\.libsyn\.com', # podcasts + 'api.*-desktop\.musixmatch\.com', # lyrics (genius-spicetify) + '.*\.podbean\.com', # podcasts + 'dts\.podtrac\.com', # podcasts + 'www\.podtrac\.com', # podcasts + 'audio\.simplecast\.com', # podcasts + 'media\.simplecast\.com', # podcasts + 'ap\.spotify\.com', # audio (access point) + '.*\.ap\.spotify\.com', # resolved access points + 'api\.spotify\.com', # client APIs + 'api-partner\.spotify\.com', # album/artist pages + 'xpui\.app\.spotify\.com', # user interface + 'apresolve\.spotify\.com', # access point resolving + 'clienttoken\.spotify\.com', # login + '.*dealer\.spotify\.com', # websocket connections + 'image-upload.*\.spotify\.com', # image uploading + 'login.*\.spotify\.com', # login + '.*-spclient\.spotify\.com', # client APIs + 'spclient\.wg\.spotify\.com', # client APIs, ads/tracking (blocked in blacklist) + 'audio-fa\.spotifycdn\.com', # audio + 'seed-mix-image\.spotifycdn\.com', # mix images + 'download\.ted\.com', # podcasts + 'dcs.*\.megaphone\.fm', # podcasts + 'traffic\.megaphone\.fm', # podcasts + 'audio-ak-spotify-com\.akamaized\.net', # audio + 'audio4-ak-spotify-com\.akamaized\.net', # audio + 'heads4-ak-spotify-com\.akamaized\.net', # audio (heads) + 'audio4-ak\.spotify\.com\.edgesuite\.net', # audio + 'scontent.*\.fbcdn\.net', # Facebook profile images + 'audio-sp-.*\.spotifycdn\.net', # audio + 'dovetail\.prxu\.org', # podcasts + 'dovetail-cdn\.prxu\.org', # podcasts + +] + +denylist = [ + 'https://spclient\.wg\.spotify\.com/ads/.*', # ads + 'https://spclient\.wg\.spotify\.com/ad-logic/.*', # ads + 'https://spclient\.wg\.spotify\.com/gabo-receiver-service/.*', # tracking +] diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..7530651 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1 @@ +max_width = 120 diff --git a/src/cef_urlrequest_capi.rs b/src/cef_urlrequest_capi.rs new file mode 100644 index 0000000..9aefeb1 --- /dev/null +++ b/src/cef_urlrequest_capi.rs @@ -0,0 +1,3666 @@ +// Copyright (c) 2020 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// bindgen --no-doc-comments --no-derive-copy --no-derive-debug --no-layout-tests include/capi/cef_urlrequest_capi.h -- -I. + +#![allow(dead_code, non_camel_case_types, non_snake_case, non_upper_case_globals)] + +/* automatically generated by rust-bindgen 0.57.0 */ +pub const _STDINT_H: u32 = 1; +pub const _FEATURES_H: u32 = 1; +pub const _DEFAULT_SOURCE: u32 = 1; +pub const __GLIBC_USE_ISOC2X: u32 = 0; +pub const __USE_ISOC11: u32 = 1; +pub const __USE_ISOC99: u32 = 1; +pub const __USE_ISOC95: u32 = 1; +pub const __USE_POSIX_IMPLICITLY: u32 = 1; +pub const _POSIX_SOURCE: u32 = 1; +pub const _POSIX_C_SOURCE: u32 = 200809; +pub const __USE_POSIX: u32 = 1; +pub const __USE_POSIX2: u32 = 1; +pub const __USE_POSIX199309: u32 = 1; +pub const __USE_POSIX199506: u32 = 1; +pub const __USE_XOPEN2K: u32 = 1; +pub const __USE_XOPEN2K8: u32 = 1; +pub const _ATFILE_SOURCE: u32 = 1; +pub const __USE_MISC: u32 = 1; +pub const __USE_ATFILE: u32 = 1; +pub const __USE_FORTIFY_LEVEL: u32 = 0; +pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0; +pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0; +pub const _STDC_PREDEF_H: u32 = 1; +pub const __STDC_IEC_559__: u32 = 1; +pub const __STDC_IEC_559_COMPLEX__: u32 = 1; +pub const __STDC_ISO_10646__: u32 = 201706; +pub const __GNU_LIBRARY__: u32 = 6; +pub const __GLIBC__: u32 = 2; +pub const __GLIBC_MINOR__: u32 = 33; +pub const _SYS_CDEFS_H: u32 = 1; +pub const __glibc_c99_flexarr_available: u32 = 1; +pub const __WORDSIZE: u32 = 64; +pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1; +pub const __SYSCALL_WORDSIZE: u32 = 64; +pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0; +pub const __HAVE_GENERIC_SELECTION: u32 = 1; +pub const __GLIBC_USE_LIB_EXT2: u32 = 0; +pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0; +pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0; +pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0; +pub const _BITS_TYPES_H: u32 = 1; +pub const __TIMESIZE: u32 = 64; +pub const _BITS_TYPESIZES_H: u32 = 1; +pub const __OFF_T_MATCHES_OFF64_T: u32 = 1; +pub const __INO_T_MATCHES_INO64_T: u32 = 1; +pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1; +pub const __STATFS_MATCHES_STATFS64: u32 = 1; +pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1; +pub const __FD_SETSIZE: u32 = 1024; +pub const _BITS_TIME64_H: u32 = 1; +pub const _BITS_WCHAR_H: u32 = 1; +pub const _BITS_STDINT_INTN_H: u32 = 1; +pub const _BITS_STDINT_UINTN_H: u32 = 1; +pub const INT8_MIN: i32 = -128; +pub const INT16_MIN: i32 = -32768; +pub const INT32_MIN: i32 = -2147483648; +pub const INT8_MAX: u32 = 127; +pub const INT16_MAX: u32 = 32767; +pub const INT32_MAX: u32 = 2147483647; +pub const UINT8_MAX: u32 = 255; +pub const UINT16_MAX: u32 = 65535; +pub const UINT32_MAX: u32 = 4294967295; +pub const INT_LEAST8_MIN: i32 = -128; +pub const INT_LEAST16_MIN: i32 = -32768; +pub const INT_LEAST32_MIN: i32 = -2147483648; +pub const INT_LEAST8_MAX: u32 = 127; +pub const INT_LEAST16_MAX: u32 = 32767; +pub const INT_LEAST32_MAX: u32 = 2147483647; +pub const UINT_LEAST8_MAX: u32 = 255; +pub const UINT_LEAST16_MAX: u32 = 65535; +pub const UINT_LEAST32_MAX: u32 = 4294967295; +pub const INT_FAST8_MIN: i32 = -128; +pub const INT_FAST16_MIN: i64 = -9223372036854775808; +pub const INT_FAST32_MIN: i64 = -9223372036854775808; +pub const INT_FAST8_MAX: u32 = 127; +pub const INT_FAST16_MAX: u64 = 9223372036854775807; +pub const INT_FAST32_MAX: u64 = 9223372036854775807; +pub const UINT_FAST8_MAX: u32 = 255; +pub const UINT_FAST16_MAX: i32 = -1; +pub const UINT_FAST32_MAX: i32 = -1; +pub const INTPTR_MIN: i64 = -9223372036854775808; +pub const INTPTR_MAX: u64 = 9223372036854775807; +pub const UINTPTR_MAX: i32 = -1; +pub const PTRDIFF_MIN: i64 = -9223372036854775808; +pub const PTRDIFF_MAX: u64 = 9223372036854775807; +pub const SIG_ATOMIC_MIN: i32 = -2147483648; +pub const SIG_ATOMIC_MAX: u32 = 2147483647; +pub const SIZE_MAX: i32 = -1; +pub const WINT_MIN: u32 = 0; +pub const WINT_MAX: u32 = 4294967295; +pub const OS_LINUX: u32 = 1; +pub const OS_POSIX: u32 = 1; +pub const COMPILER_GCC: u32 = 1; +pub const ARCH_CPU_X86_FAMILY: u32 = 1; +pub const ARCH_CPU_X86_64: u32 = 1; +pub const ARCH_CPU_64_BITS: u32 = 1; +pub const ARCH_CPU_LITTLE_ENDIAN: u32 = 1; +pub const CEF_STRING_TYPE_UTF16: u32 = 1; +pub const _LIBC_LIMITS_H_: u32 = 1; +pub const MB_LEN_MAX: u32 = 16; +pub const _BITS_POSIX1_LIM_H: u32 = 1; +pub const _POSIX_AIO_LISTIO_MAX: u32 = 2; +pub const _POSIX_AIO_MAX: u32 = 1; +pub const _POSIX_ARG_MAX: u32 = 4096; +pub const _POSIX_CHILD_MAX: u32 = 25; +pub const _POSIX_DELAYTIMER_MAX: u32 = 32; +pub const _POSIX_HOST_NAME_MAX: u32 = 255; +pub const _POSIX_LINK_MAX: u32 = 8; +pub const _POSIX_LOGIN_NAME_MAX: u32 = 9; +pub const _POSIX_MAX_CANON: u32 = 255; +pub const _POSIX_MAX_INPUT: u32 = 255; +pub const _POSIX_MQ_OPEN_MAX: u32 = 8; +pub const _POSIX_MQ_PRIO_MAX: u32 = 32; +pub const _POSIX_NAME_MAX: u32 = 14; +pub const _POSIX_NGROUPS_MAX: u32 = 8; +pub const _POSIX_OPEN_MAX: u32 = 20; +pub const _POSIX_PATH_MAX: u32 = 256; +pub const _POSIX_PIPE_BUF: u32 = 512; +pub const _POSIX_RE_DUP_MAX: u32 = 255; +pub const _POSIX_RTSIG_MAX: u32 = 8; +pub const _POSIX_SEM_NSEMS_MAX: u32 = 256; +pub const _POSIX_SEM_VALUE_MAX: u32 = 32767; +pub const _POSIX_SIGQUEUE_MAX: u32 = 32; +pub const _POSIX_SSIZE_MAX: u32 = 32767; +pub const _POSIX_STREAM_MAX: u32 = 8; +pub const _POSIX_SYMLINK_MAX: u32 = 255; +pub const _POSIX_SYMLOOP_MAX: u32 = 8; +pub const _POSIX_TIMER_MAX: u32 = 32; +pub const _POSIX_TTY_NAME_MAX: u32 = 9; +pub const _POSIX_TZNAME_MAX: u32 = 6; +pub const _POSIX_CLOCKRES_MIN: u32 = 20000000; +pub const NR_OPEN: u32 = 1024; +pub const NGROUPS_MAX: u32 = 65536; +pub const ARG_MAX: u32 = 131072; +pub const LINK_MAX: u32 = 127; +pub const MAX_CANON: u32 = 255; +pub const MAX_INPUT: u32 = 255; +pub const NAME_MAX: u32 = 255; +pub const PATH_MAX: u32 = 4096; +pub const PIPE_BUF: u32 = 4096; +pub const XATTR_NAME_MAX: u32 = 255; +pub const XATTR_SIZE_MAX: u32 = 65536; +pub const XATTR_LIST_MAX: u32 = 65536; +pub const RTSIG_MAX: u32 = 32; +pub const _POSIX_THREAD_KEYS_MAX: u32 = 128; +pub const PTHREAD_KEYS_MAX: u32 = 1024; +pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4; +pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4; +pub const _POSIX_THREAD_THREADS_MAX: u32 = 64; +pub const AIO_PRIO_DELTA_MAX: u32 = 20; +pub const PTHREAD_STACK_MIN: u32 = 16384; +pub const DELAYTIMER_MAX: u32 = 2147483647; +pub const TTY_NAME_MAX: u32 = 32; +pub const LOGIN_NAME_MAX: u32 = 256; +pub const HOST_NAME_MAX: u32 = 64; +pub const MQ_PRIO_MAX: u32 = 32768; +pub const SEM_VALUE_MAX: u32 = 2147483647; +pub const _BITS_POSIX2_LIM_H: u32 = 1; +pub const _POSIX2_BC_BASE_MAX: u32 = 99; +pub const _POSIX2_BC_DIM_MAX: u32 = 2048; +pub const _POSIX2_BC_SCALE_MAX: u32 = 99; +pub const _POSIX2_BC_STRING_MAX: u32 = 1000; +pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2; +pub const _POSIX2_EXPR_NEST_MAX: u32 = 32; +pub const _POSIX2_LINE_MAX: u32 = 2048; +pub const _POSIX2_RE_DUP_MAX: u32 = 255; +pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14; +pub const BC_BASE_MAX: u32 = 99; +pub const BC_DIM_MAX: u32 = 2048; +pub const BC_SCALE_MAX: u32 = 99; +pub const BC_STRING_MAX: u32 = 1000; +pub const COLL_WEIGHTS_MAX: u32 = 255; +pub const EXPR_NEST_MAX: u32 = 32; +pub const LINE_MAX: u32 = 2048; +pub const CHARCLASS_NAME_MAX: u32 = 2048; +pub const RE_DUP_MAX: u32 = 32767; +pub const _TIME_H: u32 = 1; +pub const _BITS_TIME_H: u32 = 1; +pub const CLOCK_REALTIME: u32 = 0; +pub const CLOCK_MONOTONIC: u32 = 1; +pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2; +pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3; +pub const CLOCK_MONOTONIC_RAW: u32 = 4; +pub const CLOCK_REALTIME_COARSE: u32 = 5; +pub const CLOCK_MONOTONIC_COARSE: u32 = 6; +pub const CLOCK_BOOTTIME: u32 = 7; +pub const CLOCK_REALTIME_ALARM: u32 = 8; +pub const CLOCK_BOOTTIME_ALARM: u32 = 9; +pub const CLOCK_TAI: u32 = 11; +pub const TIMER_ABSTIME: u32 = 1; +pub const __clock_t_defined: u32 = 1; +pub const __time_t_defined: u32 = 1; +pub const __struct_tm_defined: u32 = 1; +pub const _STRUCT_TIMESPEC: u32 = 1; +pub const _BITS_ENDIAN_H: u32 = 1; +pub const __LITTLE_ENDIAN: u32 = 1234; +pub const __BIG_ENDIAN: u32 = 4321; +pub const __PDP_ENDIAN: u32 = 3412; +pub const _BITS_ENDIANNESS_H: u32 = 1; +pub const __BYTE_ORDER: u32 = 1234; +pub const __FLOAT_WORD_ORDER: u32 = 1234; +pub const __clockid_t_defined: u32 = 1; +pub const __timer_t_defined: u32 = 1; +pub const __itimerspec_defined: u32 = 1; +pub const _BITS_TYPES_LOCALE_T_H: u32 = 1; +pub const _BITS_TYPES___LOCALE_T_H: u32 = 1; +pub const TIME_UTC: u32 = 1; +pub const kNullCursorHandle: u32 = 0; +pub const kNullWindowHandle: u32 = 0; +pub type __u_char = ::std::os::raw::c_uchar; +pub type __u_short = ::std::os::raw::c_ushort; +pub type __u_int = ::std::os::raw::c_uint; +pub type __u_long = ::std::os::raw::c_ulong; +pub type __int8_t = ::std::os::raw::c_schar; +pub type __uint8_t = ::std::os::raw::c_uchar; +pub type __int16_t = ::std::os::raw::c_short; +pub type __uint16_t = ::std::os::raw::c_ushort; +pub type __int32_t = ::std::os::raw::c_int; +pub type __uint32_t = ::std::os::raw::c_uint; +pub type __int64_t = ::std::os::raw::c_long; +pub type __uint64_t = ::std::os::raw::c_ulong; +pub type __int_least8_t = __int8_t; +pub type __uint_least8_t = __uint8_t; +pub type __int_least16_t = __int16_t; +pub type __uint_least16_t = __uint16_t; +pub type __int_least32_t = __int32_t; +pub type __uint_least32_t = __uint32_t; +pub type __int_least64_t = __int64_t; +pub type __uint_least64_t = __uint64_t; +pub type __quad_t = ::std::os::raw::c_long; +pub type __u_quad_t = ::std::os::raw::c_ulong; +pub type __intmax_t = ::std::os::raw::c_long; +pub type __uintmax_t = ::std::os::raw::c_ulong; +pub type __dev_t = ::std::os::raw::c_ulong; +pub type __uid_t = ::std::os::raw::c_uint; +pub type __gid_t = ::std::os::raw::c_uint; +pub type __ino_t = ::std::os::raw::c_ulong; +pub type __ino64_t = ::std::os::raw::c_ulong; +pub type __mode_t = ::std::os::raw::c_uint; +pub type __nlink_t = ::std::os::raw::c_ulong; +pub type __off_t = ::std::os::raw::c_long; +pub type __off64_t = ::std::os::raw::c_long; +pub type __pid_t = ::std::os::raw::c_int; +#[repr(C)] +pub struct __fsid_t { + pub __val: [::std::os::raw::c_int; 2usize], +} +pub type __clock_t = ::std::os::raw::c_long; +pub type __rlim_t = ::std::os::raw::c_ulong; +pub type __rlim64_t = ::std::os::raw::c_ulong; +pub type __id_t = ::std::os::raw::c_uint; +pub type __time_t = ::std::os::raw::c_long; +pub type __useconds_t = ::std::os::raw::c_uint; +pub type __suseconds_t = ::std::os::raw::c_long; +pub type __suseconds64_t = ::std::os::raw::c_long; +pub type __daddr_t = ::std::os::raw::c_int; +pub type __key_t = ::std::os::raw::c_int; +pub type __clockid_t = ::std::os::raw::c_int; +pub type __timer_t = *mut ::std::os::raw::c_void; +pub type __blksize_t = ::std::os::raw::c_long; +pub type __blkcnt_t = ::std::os::raw::c_long; +pub type __blkcnt64_t = ::std::os::raw::c_long; +pub type __fsblkcnt_t = ::std::os::raw::c_ulong; +pub type __fsblkcnt64_t = ::std::os::raw::c_ulong; +pub type __fsfilcnt_t = ::std::os::raw::c_ulong; +pub type __fsfilcnt64_t = ::std::os::raw::c_ulong; +pub type __fsword_t = ::std::os::raw::c_long; +pub type __ssize_t = ::std::os::raw::c_long; +pub type __syscall_slong_t = ::std::os::raw::c_long; +pub type __syscall_ulong_t = ::std::os::raw::c_ulong; +pub type __loff_t = __off64_t; +pub type __caddr_t = *mut ::std::os::raw::c_char; +pub type __intptr_t = ::std::os::raw::c_long; +pub type __socklen_t = ::std::os::raw::c_uint; +pub type __sig_atomic_t = ::std::os::raw::c_int; +pub type int_least8_t = __int_least8_t; +pub type int_least16_t = __int_least16_t; +pub type int_least32_t = __int_least32_t; +pub type int_least64_t = __int_least64_t; +pub type uint_least8_t = __uint_least8_t; +pub type uint_least16_t = __uint_least16_t; +pub type uint_least32_t = __uint_least32_t; +pub type uint_least64_t = __uint_least64_t; +pub type int_fast8_t = ::std::os::raw::c_schar; +pub type int_fast16_t = ::std::os::raw::c_long; +pub type int_fast32_t = ::std::os::raw::c_long; +pub type int_fast64_t = ::std::os::raw::c_long; +pub type uint_fast8_t = ::std::os::raw::c_uchar; +pub type uint_fast16_t = ::std::os::raw::c_ulong; +pub type uint_fast32_t = ::std::os::raw::c_ulong; +pub type uint_fast64_t = ::std::os::raw::c_ulong; +pub type intmax_t = __intmax_t; +pub type uintmax_t = __uintmax_t; +pub type wchar_t = ::std::os::raw::c_int; +#[repr(C)] +#[repr(align(16))] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __bindgen_padding_0: u64, + pub __clang_max_align_nonce2: u128, +} +pub type int64 = ::std::os::raw::c_long; +pub type uint64 = ::std::os::raw::c_ulong; +pub type int32 = ::std::os::raw::c_int; +pub type uint32 = ::std::os::raw::c_uint; +pub type int16 = ::std::os::raw::c_short; +pub type uint16 = ::std::os::raw::c_ushort; +pub type char16 = ::std::os::raw::c_ushort; +#[repr(C)] +pub struct _cef_string_wide_t { + pub str_: *mut wchar_t, + pub length: usize, + pub dtor: ::std::option::Option, +} +pub type cef_string_wide_t = _cef_string_wide_t; +#[repr(C)] +pub struct _cef_string_utf8_t { + pub str_: *mut ::std::os::raw::c_char, + pub length: usize, + pub dtor: ::std::option::Option, +} +pub type cef_string_utf8_t = _cef_string_utf8_t; +#[repr(C)] +pub struct _cef_string_utf16_t { + pub str_: *mut char16, + pub length: usize, + pub dtor: ::std::option::Option, +} +pub type cef_string_utf16_t = _cef_string_utf16_t; +extern "C" { + pub fn cef_string_wide_set( + src: *const wchar_t, + src_len: usize, + output: *mut cef_string_wide_t, + copy: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf8_set( + src: *const ::std::os::raw::c_char, + src_len: usize, + output: *mut cef_string_utf8_t, + copy: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf16_set( + src: *const char16, + src_len: usize, + output: *mut cef_string_utf16_t, + copy: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_wide_clear(str_: *mut cef_string_wide_t); +} +extern "C" { + pub fn cef_string_utf8_clear(str_: *mut cef_string_utf8_t); +} +extern "C" { + pub fn cef_string_utf16_clear(str_: *mut cef_string_utf16_t); +} +extern "C" { + pub fn cef_string_wide_cmp(str1: *const cef_string_wide_t, str2: *const cef_string_wide_t) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf8_cmp(str1: *const cef_string_utf8_t, str2: *const cef_string_utf8_t) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf16_cmp( + str1: *const cef_string_utf16_t, + str2: *const cef_string_utf16_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_wide_to_utf8( + src: *const wchar_t, + src_len: usize, + output: *mut cef_string_utf8_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf8_to_wide( + src: *const ::std::os::raw::c_char, + src_len: usize, + output: *mut cef_string_wide_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_wide_to_utf16( + src: *const wchar_t, + src_len: usize, + output: *mut cef_string_utf16_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf16_to_wide( + src: *const char16, + src_len: usize, + output: *mut cef_string_wide_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf8_to_utf16( + src: *const ::std::os::raw::c_char, + src_len: usize, + output: *mut cef_string_utf16_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf16_to_utf8( + src: *const char16, + src_len: usize, + output: *mut cef_string_utf8_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_ascii_to_wide( + src: *const ::std::os::raw::c_char, + src_len: usize, + output: *mut cef_string_wide_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_ascii_to_utf16( + src: *const ::std::os::raw::c_char, + src_len: usize, + output: *mut cef_string_utf16_t, + ) -> ::std::os::raw::c_int; +} +pub type cef_string_userfree_wide_t = *mut cef_string_wide_t; +pub type cef_string_userfree_utf8_t = *mut cef_string_utf8_t; +pub type cef_string_userfree_utf16_t = *mut cef_string_utf16_t; +extern "C" { + pub fn cef_string_userfree_wide_alloc() -> cef_string_userfree_wide_t; +} +extern "C" { + pub fn cef_string_userfree_utf8_alloc() -> cef_string_userfree_utf8_t; +} +extern "C" { + pub fn cef_string_userfree_utf16_alloc() -> cef_string_userfree_utf16_t; +} +extern "C" { + pub fn cef_string_userfree_wide_free(str_: cef_string_userfree_wide_t); +} +extern "C" { + pub fn cef_string_userfree_utf8_free(str_: cef_string_userfree_utf8_t); +} +extern "C" { + pub fn cef_string_userfree_utf16_free(str_: cef_string_userfree_utf16_t); +} +extern "C" { + pub fn cef_string_utf16_to_lower( + src: *const char16, + src_len: usize, + output: *mut cef_string_utf16_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_utf16_to_upper( + src: *const char16, + src_len: usize, + output: *mut cef_string_utf16_t, + ) -> ::std::os::raw::c_int; +} +pub type cef_char_t = char16; +pub type cef_string_userfree_t = cef_string_userfree_utf16_t; +pub type cef_string_t = cef_string_utf16_t; +pub type cef_string_list_t = *mut ::std::os::raw::c_void; +extern "C" { + pub fn cef_string_list_alloc() -> cef_string_list_t; +} +extern "C" { + pub fn cef_string_list_size(list: cef_string_list_t) -> usize; +} +extern "C" { + pub fn cef_string_list_value( + list: cef_string_list_t, + index: usize, + value: *mut cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_list_append(list: cef_string_list_t, value: *const cef_string_t); +} +extern "C" { + pub fn cef_string_list_clear(list: cef_string_list_t); +} +extern "C" { + pub fn cef_string_list_free(list: cef_string_list_t); +} +extern "C" { + pub fn cef_string_list_copy(list: cef_string_list_t) -> cef_string_list_t; +} +pub type cef_string_map_t = *mut ::std::os::raw::c_void; +extern "C" { + pub fn cef_string_map_alloc() -> cef_string_map_t; +} +extern "C" { + pub fn cef_string_map_size(map: cef_string_map_t) -> usize; +} +extern "C" { + pub fn cef_string_map_find( + map: cef_string_map_t, + key: *const cef_string_t, + value: *mut cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_map_key(map: cef_string_map_t, index: usize, key: *mut cef_string_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_map_value(map: cef_string_map_t, index: usize, value: *mut cef_string_t) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_map_append( + map: cef_string_map_t, + key: *const cef_string_t, + value: *const cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_map_clear(map: cef_string_map_t); +} +extern "C" { + pub fn cef_string_map_free(map: cef_string_map_t); +} +pub type cef_string_multimap_t = *mut ::std::os::raw::c_void; +extern "C" { + pub fn cef_string_multimap_alloc() -> cef_string_multimap_t; +} +extern "C" { + pub fn cef_string_multimap_size(map: cef_string_multimap_t) -> usize; +} +extern "C" { + pub fn cef_string_multimap_find_count(map: cef_string_multimap_t, key: *const cef_string_t) -> usize; +} +extern "C" { + pub fn cef_string_multimap_enumerate( + map: cef_string_multimap_t, + key: *const cef_string_t, + value_index: usize, + value: *mut cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_multimap_key( + map: cef_string_multimap_t, + index: usize, + key: *mut cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_multimap_value( + map: cef_string_multimap_t, + index: usize, + value: *mut cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_multimap_append( + map: cef_string_multimap_t, + key: *const cef_string_t, + value: *const cef_string_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_string_multimap_clear(map: cef_string_multimap_t); +} +extern "C" { + pub fn cef_string_multimap_free(map: cef_string_multimap_t); +} +pub type clock_t = __clock_t; +pub type time_t = __time_t; +#[repr(C)] +pub struct tm { + pub tm_sec: ::std::os::raw::c_int, + pub tm_min: ::std::os::raw::c_int, + pub tm_hour: ::std::os::raw::c_int, + pub tm_mday: ::std::os::raw::c_int, + pub tm_mon: ::std::os::raw::c_int, + pub tm_year: ::std::os::raw::c_int, + pub tm_wday: ::std::os::raw::c_int, + pub tm_yday: ::std::os::raw::c_int, + pub tm_isdst: ::std::os::raw::c_int, + pub tm_gmtoff: ::std::os::raw::c_long, + pub tm_zone: *const ::std::os::raw::c_char, +} +#[repr(C)] +pub struct timespec { + pub tv_sec: __time_t, + pub tv_nsec: __syscall_slong_t, +} +pub type clockid_t = __clockid_t; +pub type timer_t = __timer_t; +#[repr(C)] +pub struct itimerspec { + pub it_interval: timespec, + pub it_value: timespec, +} +#[repr(C)] +pub struct sigevent { + _unused: [u8; 0], +} +pub type pid_t = __pid_t; +#[repr(C)] +pub struct __locale_struct { + pub __locales: [*mut __locale_data; 13usize], + pub __ctype_b: *const ::std::os::raw::c_ushort, + pub __ctype_tolower: *const ::std::os::raw::c_int, + pub __ctype_toupper: *const ::std::os::raw::c_int, + pub __names: [*const ::std::os::raw::c_char; 13usize], +} +pub type __locale_t = *mut __locale_struct; +pub type locale_t = __locale_t; +extern "C" { + pub fn clock() -> clock_t; +} +extern "C" { + pub fn time(__timer: *mut time_t) -> time_t; +} +extern "C" { + pub fn difftime(__time1: time_t, __time0: time_t) -> f64; +} +extern "C" { + pub fn mktime(__tp: *mut tm) -> time_t; +} +extern "C" { + pub fn strftime( + __s: *mut ::std::os::raw::c_char, + __maxsize: usize, + __format: *const ::std::os::raw::c_char, + __tp: *const tm, + ) -> usize; +} +extern "C" { + pub fn strftime_l( + __s: *mut ::std::os::raw::c_char, + __maxsize: usize, + __format: *const ::std::os::raw::c_char, + __tp: *const tm, + __loc: locale_t, + ) -> usize; +} +extern "C" { + pub fn gmtime(__timer: *const time_t) -> *mut tm; +} +extern "C" { + pub fn localtime(__timer: *const time_t) -> *mut tm; +} +extern "C" { + pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm; +} +extern "C" { + pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm; +} +extern "C" { + pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn asctime_r(__tp: *const tm, __buf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn ctime_r(__timer: *const time_t, __buf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize]; +} +extern "C" { + pub static mut __daylight: ::std::os::raw::c_int; +} +extern "C" { + pub static mut __timezone: ::std::os::raw::c_long; +} +extern "C" { + pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize]; +} +extern "C" { + pub fn tzset(); +} +extern "C" { + pub static mut daylight: ::std::os::raw::c_int; +} +extern "C" { + pub static mut timezone: ::std::os::raw::c_long; +} +extern "C" { + pub fn timegm(__tp: *mut tm) -> time_t; +} +extern "C" { + pub fn timelocal(__tp: *mut tm) -> time_t; +} +extern "C" { + pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn nanosleep(__requested_time: *const timespec, __remaining: *mut timespec) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn clock_nanosleep( + __clock_id: clockid_t, + __flags: ::std::os::raw::c_int, + __req: *const timespec, + __rem: *mut timespec, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn timer_create(__clock_id: clockid_t, __evp: *mut sigevent, __timerid: *mut timer_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn timer_settime( + __timerid: timer_t, + __flags: ::std::os::raw::c_int, + __value: *const itimerspec, + __ovalue: *mut itimerspec, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn timespec_get(__ts: *mut timespec, __base: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +#[repr(C)] +pub struct _cef_time_t { + pub year: ::std::os::raw::c_int, + pub month: ::std::os::raw::c_int, + pub day_of_week: ::std::os::raw::c_int, + pub day_of_month: ::std::os::raw::c_int, + pub hour: ::std::os::raw::c_int, + pub minute: ::std::os::raw::c_int, + pub second: ::std::os::raw::c_int, + pub millisecond: ::std::os::raw::c_int, +} +pub type cef_time_t = _cef_time_t; +extern "C" { + pub fn cef_time_to_timet(cef_time: *const cef_time_t, time: *mut time_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_time_from_timet(time: time_t, cef_time: *mut cef_time_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_time_to_doublet(cef_time: *const cef_time_t, time: *mut f64) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_time_from_doublet(time: f64, cef_time: *mut cef_time_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_time_now(cef_time: *mut cef_time_t) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_time_delta( + cef_time1: *const cef_time_t, + cef_time2: *const cef_time_t, + delta: *mut ::std::os::raw::c_longlong, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +pub struct _cef_main_args_t { + pub argc: ::std::os::raw::c_int, + pub argv: *mut *mut ::std::os::raw::c_char, +} +pub type cef_main_args_t = _cef_main_args_t; +#[repr(C)] +pub struct _cef_window_info_t { + pub window_name: cef_string_t, + pub x: ::std::os::raw::c_uint, + pub y: ::std::os::raw::c_uint, + pub width: ::std::os::raw::c_uint, + pub height: ::std::os::raw::c_uint, + pub parent_window: ::std::os::raw::c_ulong, + pub windowless_rendering_enabled: ::std::os::raw::c_int, + pub shared_texture_enabled: ::std::os::raw::c_int, + pub external_begin_frame_enabled: ::std::os::raw::c_int, + pub window: ::std::os::raw::c_ulong, +} +pub type cef_window_info_t = _cef_window_info_t; +pub type cef_color_t = uint32; +pub const cef_log_severity_t_LOGSEVERITY_DEFAULT: cef_log_severity_t = 0; +pub const cef_log_severity_t_LOGSEVERITY_VERBOSE: cef_log_severity_t = 1; +pub const cef_log_severity_t_LOGSEVERITY_DEBUG: cef_log_severity_t = 1; +pub const cef_log_severity_t_LOGSEVERITY_INFO: cef_log_severity_t = 2; +pub const cef_log_severity_t_LOGSEVERITY_WARNING: cef_log_severity_t = 3; +pub const cef_log_severity_t_LOGSEVERITY_ERROR: cef_log_severity_t = 4; +pub const cef_log_severity_t_LOGSEVERITY_FATAL: cef_log_severity_t = 5; +pub const cef_log_severity_t_LOGSEVERITY_DISABLE: cef_log_severity_t = 99; +pub type cef_log_severity_t = ::std::os::raw::c_uint; +pub const cef_state_t_STATE_DEFAULT: cef_state_t = 0; +pub const cef_state_t_STATE_ENABLED: cef_state_t = 1; +pub const cef_state_t_STATE_DISABLED: cef_state_t = 2; +pub type cef_state_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_settings_t { + pub size: usize, + pub no_sandbox: ::std::os::raw::c_int, + pub browser_subprocess_path: cef_string_t, + pub framework_dir_path: cef_string_t, + pub main_bundle_path: cef_string_t, + pub multi_threaded_message_loop: ::std::os::raw::c_int, + pub external_message_pump: ::std::os::raw::c_int, + pub windowless_rendering_enabled: ::std::os::raw::c_int, + pub command_line_args_disabled: ::std::os::raw::c_int, + pub cache_path: cef_string_t, + pub root_cache_path: cef_string_t, + pub user_data_path: cef_string_t, + pub persist_session_cookies: ::std::os::raw::c_int, + pub persist_user_preferences: ::std::os::raw::c_int, + pub user_agent: cef_string_t, + pub product_version: cef_string_t, + pub locale: cef_string_t, + pub log_file: cef_string_t, + pub log_severity: cef_log_severity_t, + pub javascript_flags: cef_string_t, + pub resources_dir_path: cef_string_t, + pub locales_dir_path: cef_string_t, + pub pack_loading_disabled: ::std::os::raw::c_int, + pub remote_debugging_port: ::std::os::raw::c_int, + pub uncaught_exception_stack_size: ::std::os::raw::c_int, + pub ignore_certificate_errors: ::std::os::raw::c_int, + pub background_color: cef_color_t, + pub accept_language_list: cef_string_t, + pub application_client_id_for_file_scanning: cef_string_t, +} +pub type cef_settings_t = _cef_settings_t; +#[repr(C)] +pub struct _cef_request_context_settings_t { + pub size: usize, + pub cache_path: cef_string_t, + pub persist_session_cookies: ::std::os::raw::c_int, + pub persist_user_preferences: ::std::os::raw::c_int, + pub ignore_certificate_errors: ::std::os::raw::c_int, + pub accept_language_list: cef_string_t, +} +pub type cef_request_context_settings_t = _cef_request_context_settings_t; +#[repr(C)] +pub struct _cef_browser_settings_t { + pub size: usize, + pub windowless_frame_rate: ::std::os::raw::c_int, + pub standard_font_family: cef_string_t, + pub fixed_font_family: cef_string_t, + pub serif_font_family: cef_string_t, + pub sans_serif_font_family: cef_string_t, + pub cursive_font_family: cef_string_t, + pub fantasy_font_family: cef_string_t, + pub default_font_size: ::std::os::raw::c_int, + pub default_fixed_font_size: ::std::os::raw::c_int, + pub minimum_font_size: ::std::os::raw::c_int, + pub minimum_logical_font_size: ::std::os::raw::c_int, + pub default_encoding: cef_string_t, + pub remote_fonts: cef_state_t, + pub javascript: cef_state_t, + pub javascript_close_windows: cef_state_t, + pub javascript_access_clipboard: cef_state_t, + pub javascript_dom_paste: cef_state_t, + pub plugins: cef_state_t, + pub universal_access_from_file_urls: cef_state_t, + pub file_access_from_file_urls: cef_state_t, + pub web_security: cef_state_t, + pub image_loading: cef_state_t, + pub image_shrink_standalone_to_fit: cef_state_t, + pub text_area_resize: cef_state_t, + pub tab_to_links: cef_state_t, + pub local_storage: cef_state_t, + pub databases: cef_state_t, + pub application_cache: cef_state_t, + pub webgl: cef_state_t, + pub background_color: cef_color_t, + pub accept_language_list: cef_string_t, +} +pub type cef_browser_settings_t = _cef_browser_settings_t; +pub const cef_return_value_t_RV_CANCEL: cef_return_value_t = 0; +pub const cef_return_value_t_RV_CONTINUE: cef_return_value_t = 1; +pub const cef_return_value_t_RV_CONTINUE_ASYNC: cef_return_value_t = 2; +pub type cef_return_value_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_urlparts_t { + pub spec: cef_string_t, + pub scheme: cef_string_t, + pub username: cef_string_t, + pub password: cef_string_t, + pub host: cef_string_t, + pub port: cef_string_t, + pub origin: cef_string_t, + pub path: cef_string_t, + pub query: cef_string_t, +} +pub type cef_urlparts_t = _cef_urlparts_t; +#[repr(C)] +pub struct _cef_cookie_t { + pub name: cef_string_t, + pub value: cef_string_t, + pub domain: cef_string_t, + pub path: cef_string_t, + pub secure: ::std::os::raw::c_int, + pub httponly: ::std::os::raw::c_int, + pub creation: cef_time_t, + pub last_access: cef_time_t, + pub has_expires: ::std::os::raw::c_int, + pub expires: cef_time_t, +} +pub type cef_cookie_t = _cef_cookie_t; +pub const cef_termination_status_t_TS_ABNORMAL_TERMINATION: cef_termination_status_t = 0; +pub const cef_termination_status_t_TS_PROCESS_WAS_KILLED: cef_termination_status_t = 1; +pub const cef_termination_status_t_TS_PROCESS_CRASHED: cef_termination_status_t = 2; +pub const cef_termination_status_t_TS_PROCESS_OOM: cef_termination_status_t = 3; +pub type cef_termination_status_t = ::std::os::raw::c_uint; +pub const cef_path_key_t_PK_DIR_CURRENT: cef_path_key_t = 0; +pub const cef_path_key_t_PK_DIR_EXE: cef_path_key_t = 1; +pub const cef_path_key_t_PK_DIR_MODULE: cef_path_key_t = 2; +pub const cef_path_key_t_PK_DIR_TEMP: cef_path_key_t = 3; +pub const cef_path_key_t_PK_FILE_EXE: cef_path_key_t = 4; +pub const cef_path_key_t_PK_FILE_MODULE: cef_path_key_t = 5; +pub const cef_path_key_t_PK_LOCAL_APP_DATA: cef_path_key_t = 6; +pub const cef_path_key_t_PK_USER_DATA: cef_path_key_t = 7; +pub const cef_path_key_t_PK_DIR_RESOURCES: cef_path_key_t = 8; +pub type cef_path_key_t = ::std::os::raw::c_uint; +pub const cef_storage_type_t_ST_LOCALSTORAGE: cef_storage_type_t = 0; +pub const cef_storage_type_t_ST_SESSIONSTORAGE: cef_storage_type_t = 1; +pub type cef_storage_type_t = ::std::os::raw::c_uint; +pub const cef_errorcode_t_ERR_NONE: cef_errorcode_t = 0; +pub const cef_errorcode_t_ERR_IO_PENDING: cef_errorcode_t = -1; +pub const cef_errorcode_t_ERR_FAILED: cef_errorcode_t = -2; +pub const cef_errorcode_t_ERR_ABORTED: cef_errorcode_t = -3; +pub const cef_errorcode_t_ERR_INVALID_ARGUMENT: cef_errorcode_t = -4; +pub const cef_errorcode_t_ERR_INVALID_HANDLE: cef_errorcode_t = -5; +pub const cef_errorcode_t_ERR_FILE_NOT_FOUND: cef_errorcode_t = -6; +pub const cef_errorcode_t_ERR_TIMED_OUT: cef_errorcode_t = -7; +pub const cef_errorcode_t_ERR_FILE_TOO_BIG: cef_errorcode_t = -8; +pub const cef_errorcode_t_ERR_UNEXPECTED: cef_errorcode_t = -9; +pub const cef_errorcode_t_ERR_ACCESS_DENIED: cef_errorcode_t = -10; +pub const cef_errorcode_t_ERR_NOT_IMPLEMENTED: cef_errorcode_t = -11; +pub const cef_errorcode_t_ERR_INSUFFICIENT_RESOURCES: cef_errorcode_t = -12; +pub const cef_errorcode_t_ERR_OUT_OF_MEMORY: cef_errorcode_t = -13; +pub const cef_errorcode_t_ERR_UPLOAD_FILE_CHANGED: cef_errorcode_t = -14; +pub const cef_errorcode_t_ERR_SOCKET_NOT_CONNECTED: cef_errorcode_t = -15; +pub const cef_errorcode_t_ERR_FILE_EXISTS: cef_errorcode_t = -16; +pub const cef_errorcode_t_ERR_FILE_PATH_TOO_LONG: cef_errorcode_t = -17; +pub const cef_errorcode_t_ERR_FILE_NO_SPACE: cef_errorcode_t = -18; +pub const cef_errorcode_t_ERR_FILE_VIRUS_INFECTED: cef_errorcode_t = -19; +pub const cef_errorcode_t_ERR_BLOCKED_BY_CLIENT: cef_errorcode_t = -20; +pub const cef_errorcode_t_ERR_NETWORK_CHANGED: cef_errorcode_t = -21; +pub const cef_errorcode_t_ERR_BLOCKED_BY_ADMINISTRATOR: cef_errorcode_t = -22; +pub const cef_errorcode_t_ERR_SOCKET_IS_CONNECTED: cef_errorcode_t = -23; +pub const cef_errorcode_t_ERR_BLOCKED_ENROLLMENT_CHECK_PENDING: cef_errorcode_t = -24; +pub const cef_errorcode_t_ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED: cef_errorcode_t = -25; +pub const cef_errorcode_t_ERR_CONTEXT_SHUT_DOWN: cef_errorcode_t = -26; +pub const cef_errorcode_t_ERR_BLOCKED_BY_RESPONSE: cef_errorcode_t = -27; +pub const cef_errorcode_t_ERR_CLEARTEXT_NOT_PERMITTED: cef_errorcode_t = -29; +pub const cef_errorcode_t_ERR_CONNECTION_CLOSED: cef_errorcode_t = -100; +pub const cef_errorcode_t_ERR_CONNECTION_RESET: cef_errorcode_t = -101; +pub const cef_errorcode_t_ERR_CONNECTION_REFUSED: cef_errorcode_t = -102; +pub const cef_errorcode_t_ERR_CONNECTION_ABORTED: cef_errorcode_t = -103; +pub const cef_errorcode_t_ERR_CONNECTION_FAILED: cef_errorcode_t = -104; +pub const cef_errorcode_t_ERR_NAME_NOT_RESOLVED: cef_errorcode_t = -105; +pub const cef_errorcode_t_ERR_INTERNET_DISCONNECTED: cef_errorcode_t = -106; +pub const cef_errorcode_t_ERR_SSL_PROTOCOL_ERROR: cef_errorcode_t = -107; +pub const cef_errorcode_t_ERR_ADDRESS_INVALID: cef_errorcode_t = -108; +pub const cef_errorcode_t_ERR_ADDRESS_UNREACHABLE: cef_errorcode_t = -109; +pub const cef_errorcode_t_ERR_SSL_CLIENT_AUTH_CERT_NEEDED: cef_errorcode_t = -110; +pub const cef_errorcode_t_ERR_TUNNEL_CONNECTION_FAILED: cef_errorcode_t = -111; +pub const cef_errorcode_t_ERR_NO_SSL_VERSIONS_ENABLED: cef_errorcode_t = -112; +pub const cef_errorcode_t_ERR_SSL_VERSION_OR_CIPHER_MISMATCH: cef_errorcode_t = -113; +pub const cef_errorcode_t_ERR_SSL_RENEGOTIATION_REQUESTED: cef_errorcode_t = -114; +pub const cef_errorcode_t_ERR_PROXY_AUTH_UNSUPPORTED: cef_errorcode_t = -115; +pub const cef_errorcode_t_ERR_CERT_ERROR_IN_SSL_RENEGOTIATION: cef_errorcode_t = -116; +pub const cef_errorcode_t_ERR_BAD_SSL_CLIENT_AUTH_CERT: cef_errorcode_t = -117; +pub const cef_errorcode_t_ERR_CONNECTION_TIMED_OUT: cef_errorcode_t = -118; +pub const cef_errorcode_t_ERR_HOST_RESOLVER_QUEUE_TOO_LARGE: cef_errorcode_t = -119; +pub const cef_errorcode_t_ERR_SOCKS_CONNECTION_FAILED: cef_errorcode_t = -120; +pub const cef_errorcode_t_ERR_SOCKS_CONNECTION_HOST_UNREACHABLE: cef_errorcode_t = -121; +pub const cef_errorcode_t_ERR_ALPN_NEGOTIATION_FAILED: cef_errorcode_t = -122; +pub const cef_errorcode_t_ERR_SSL_NO_RENEGOTIATION: cef_errorcode_t = -123; +pub const cef_errorcode_t_ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES: cef_errorcode_t = -124; +pub const cef_errorcode_t_ERR_SSL_DECOMPRESSION_FAILURE_ALERT: cef_errorcode_t = -125; +pub const cef_errorcode_t_ERR_SSL_BAD_RECORD_MAC_ALERT: cef_errorcode_t = -126; +pub const cef_errorcode_t_ERR_PROXY_AUTH_REQUESTED: cef_errorcode_t = -127; +pub const cef_errorcode_t_ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY: cef_errorcode_t = -129; +pub const cef_errorcode_t_ERR_PROXY_CONNECTION_FAILED: cef_errorcode_t = -130; +pub const cef_errorcode_t_ERR_MANDATORY_PROXY_CONFIGURATION_FAILED: cef_errorcode_t = -131; +pub const cef_errorcode_t_ERR_PRECONNECT_MAX_SOCKET_LIMIT: cef_errorcode_t = -133; +pub const cef_errorcode_t_ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED: cef_errorcode_t = -134; +pub const cef_errorcode_t_ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY: cef_errorcode_t = -135; +pub const cef_errorcode_t_ERR_PROXY_CERTIFICATE_INVALID: cef_errorcode_t = -136; +pub const cef_errorcode_t_ERR_NAME_RESOLUTION_FAILED: cef_errorcode_t = -137; +pub const cef_errorcode_t_ERR_NETWORK_ACCESS_DENIED: cef_errorcode_t = -138; +pub const cef_errorcode_t_ERR_TEMPORARILY_THROTTLED: cef_errorcode_t = -139; +pub const cef_errorcode_t_ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT: cef_errorcode_t = -140; +pub const cef_errorcode_t_ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED: cef_errorcode_t = -141; +pub const cef_errorcode_t_ERR_MSG_TOO_BIG: cef_errorcode_t = -142; +pub const cef_errorcode_t_ERR_WS_PROTOCOL_ERROR: cef_errorcode_t = -145; +pub const cef_errorcode_t_ERR_ADDRESS_IN_USE: cef_errorcode_t = -147; +pub const cef_errorcode_t_ERR_SSL_HANDSHAKE_NOT_COMPLETED: cef_errorcode_t = -148; +pub const cef_errorcode_t_ERR_SSL_BAD_PEER_PUBLIC_KEY: cef_errorcode_t = -149; +pub const cef_errorcode_t_ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN: cef_errorcode_t = -150; +pub const cef_errorcode_t_ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED: cef_errorcode_t = -151; +pub const cef_errorcode_t_ERR_SSL_DECRYPT_ERROR_ALERT: cef_errorcode_t = -153; +pub const cef_errorcode_t_ERR_WS_THROTTLE_QUEUE_TOO_LARGE: cef_errorcode_t = -154; +pub const cef_errorcode_t_ERR_SSL_SERVER_CERT_CHANGED: cef_errorcode_t = -156; +pub const cef_errorcode_t_ERR_SSL_UNRECOGNIZED_NAME_ALERT: cef_errorcode_t = -159; +pub const cef_errorcode_t_ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR: cef_errorcode_t = -160; +pub const cef_errorcode_t_ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR: cef_errorcode_t = -161; +pub const cef_errorcode_t_ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE: cef_errorcode_t = -162; +pub const cef_errorcode_t_ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE: cef_errorcode_t = -163; +pub const cef_errorcode_t_ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT: cef_errorcode_t = -164; +pub const cef_errorcode_t_ERR_ICANN_NAME_COLLISION: cef_errorcode_t = -166; +pub const cef_errorcode_t_ERR_SSL_SERVER_CERT_BAD_FORMAT: cef_errorcode_t = -167; +pub const cef_errorcode_t_ERR_CT_STH_PARSING_FAILED: cef_errorcode_t = -168; +pub const cef_errorcode_t_ERR_CT_STH_INCOMPLETE: cef_errorcode_t = -169; +pub const cef_errorcode_t_ERR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH: cef_errorcode_t = -170; +pub const cef_errorcode_t_ERR_CT_CONSISTENCY_PROOF_PARSING_FAILED: cef_errorcode_t = -171; +pub const cef_errorcode_t_ERR_SSL_OBSOLETE_CIPHER: cef_errorcode_t = -172; +pub const cef_errorcode_t_ERR_WS_UPGRADE: cef_errorcode_t = -173; +pub const cef_errorcode_t_ERR_READ_IF_READY_NOT_IMPLEMENTED: cef_errorcode_t = -174; +pub const cef_errorcode_t_ERR_NO_BUFFER_SPACE: cef_errorcode_t = -176; +pub const cef_errorcode_t_ERR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS: cef_errorcode_t = -177; +pub const cef_errorcode_t_ERR_EARLY_DATA_REJECTED: cef_errorcode_t = -178; +pub const cef_errorcode_t_ERR_WRONG_VERSION_ON_EARLY_DATA: cef_errorcode_t = -179; +pub const cef_errorcode_t_ERR_TLS13_DOWNGRADE_DETECTED: cef_errorcode_t = -180; +pub const cef_errorcode_t_ERR_SSL_KEY_USAGE_INCOMPATIBLE: cef_errorcode_t = -181; +pub const cef_errorcode_t_ERR_CERT_COMMON_NAME_INVALID: cef_errorcode_t = -200; +pub const cef_errorcode_t_ERR_CERT_DATE_INVALID: cef_errorcode_t = -201; +pub const cef_errorcode_t_ERR_CERT_AUTHORITY_INVALID: cef_errorcode_t = -202; +pub const cef_errorcode_t_ERR_CERT_CONTAINS_ERRORS: cef_errorcode_t = -203; +pub const cef_errorcode_t_ERR_CERT_NO_REVOCATION_MECHANISM: cef_errorcode_t = -204; +pub const cef_errorcode_t_ERR_CERT_UNABLE_TO_CHECK_REVOCATION: cef_errorcode_t = -205; +pub const cef_errorcode_t_ERR_CERT_REVOKED: cef_errorcode_t = -206; +pub const cef_errorcode_t_ERR_CERT_INVALID: cef_errorcode_t = -207; +pub const cef_errorcode_t_ERR_CERT_WEAK_SIGNATURE_ALGORITHM: cef_errorcode_t = -208; +pub const cef_errorcode_t_ERR_CERT_NON_UNIQUE_NAME: cef_errorcode_t = -210; +pub const cef_errorcode_t_ERR_CERT_WEAK_KEY: cef_errorcode_t = -211; +pub const cef_errorcode_t_ERR_CERT_NAME_CONSTRAINT_VIOLATION: cef_errorcode_t = -212; +pub const cef_errorcode_t_ERR_CERT_VALIDITY_TOO_LONG: cef_errorcode_t = -213; +pub const cef_errorcode_t_ERR_CERTIFICATE_TRANSPARENCY_REQUIRED: cef_errorcode_t = -214; +pub const cef_errorcode_t_ERR_CERT_SYMANTEC_LEGACY: cef_errorcode_t = -215; +pub const cef_errorcode_t_ERR_CERT_KNOWN_INTERCEPTION_BLOCKED: cef_errorcode_t = -217; +pub const cef_errorcode_t_ERR_CERT_END: cef_errorcode_t = -218; +pub const cef_errorcode_t_ERR_INVALID_URL: cef_errorcode_t = -300; +pub const cef_errorcode_t_ERR_DISALLOWED_URL_SCHEME: cef_errorcode_t = -301; +pub const cef_errorcode_t_ERR_UNKNOWN_URL_SCHEME: cef_errorcode_t = -302; +pub const cef_errorcode_t_ERR_INVALID_REDIRECT: cef_errorcode_t = -303; +pub const cef_errorcode_t_ERR_TOO_MANY_REDIRECTS: cef_errorcode_t = -310; +pub const cef_errorcode_t_ERR_UNSAFE_REDIRECT: cef_errorcode_t = -311; +pub const cef_errorcode_t_ERR_UNSAFE_PORT: cef_errorcode_t = -312; +pub const cef_errorcode_t_ERR_INVALID_RESPONSE: cef_errorcode_t = -320; +pub const cef_errorcode_t_ERR_INVALID_CHUNKED_ENCODING: cef_errorcode_t = -321; +pub const cef_errorcode_t_ERR_METHOD_NOT_SUPPORTED: cef_errorcode_t = -322; +pub const cef_errorcode_t_ERR_UNEXPECTED_PROXY_AUTH: cef_errorcode_t = -323; +pub const cef_errorcode_t_ERR_EMPTY_RESPONSE: cef_errorcode_t = -324; +pub const cef_errorcode_t_ERR_RESPONSE_HEADERS_TOO_BIG: cef_errorcode_t = -325; +pub const cef_errorcode_t_ERR_PAC_SCRIPT_FAILED: cef_errorcode_t = -327; +pub const cef_errorcode_t_ERR_REQUEST_RANGE_NOT_SATISFIABLE: cef_errorcode_t = -328; +pub const cef_errorcode_t_ERR_MALFORMED_IDENTITY: cef_errorcode_t = -329; +pub const cef_errorcode_t_ERR_CONTENT_DECODING_FAILED: cef_errorcode_t = -330; +pub const cef_errorcode_t_ERR_NETWORK_IO_SUSPENDED: cef_errorcode_t = -331; +pub const cef_errorcode_t_ERR_SYN_REPLY_NOT_RECEIVED: cef_errorcode_t = -332; +pub const cef_errorcode_t_ERR_ENCODING_CONVERSION_FAILED: cef_errorcode_t = -333; +pub const cef_errorcode_t_ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT: cef_errorcode_t = -334; +pub const cef_errorcode_t_ERR_NO_SUPPORTED_PROXIES: cef_errorcode_t = -336; +pub const cef_errorcode_t_ERR_HTTP2_PROTOCOL_ERROR: cef_errorcode_t = -337; +pub const cef_errorcode_t_ERR_INVALID_AUTH_CREDENTIALS: cef_errorcode_t = -338; +pub const cef_errorcode_t_ERR_UNSUPPORTED_AUTH_SCHEME: cef_errorcode_t = -339; +pub const cef_errorcode_t_ERR_ENCODING_DETECTION_FAILED: cef_errorcode_t = -340; +pub const cef_errorcode_t_ERR_MISSING_AUTH_CREDENTIALS: cef_errorcode_t = -341; +pub const cef_errorcode_t_ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS: cef_errorcode_t = -342; +pub const cef_errorcode_t_ERR_MISCONFIGURED_AUTH_ENVIRONMENT: cef_errorcode_t = -343; +pub const cef_errorcode_t_ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS: cef_errorcode_t = -344; +pub const cef_errorcode_t_ERR_RESPONSE_BODY_TOO_BIG_TO_DRAIN: cef_errorcode_t = -345; +pub const cef_errorcode_t_ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH: cef_errorcode_t = -346; +pub const cef_errorcode_t_ERR_INCOMPLETE_HTTP2_HEADERS: cef_errorcode_t = -347; +pub const cef_errorcode_t_ERR_PAC_NOT_IN_DHCP: cef_errorcode_t = -348; +pub const cef_errorcode_t_ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION: cef_errorcode_t = -349; +pub const cef_errorcode_t_ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION: cef_errorcode_t = -350; +pub const cef_errorcode_t_ERR_HTTP2_SERVER_REFUSED_STREAM: cef_errorcode_t = -351; +pub const cef_errorcode_t_ERR_HTTP2_PING_FAILED: cef_errorcode_t = -352; +pub const cef_errorcode_t_ERR_CONTENT_LENGTH_MISMATCH: cef_errorcode_t = -354; +pub const cef_errorcode_t_ERR_INCOMPLETE_CHUNKED_ENCODING: cef_errorcode_t = -355; +pub const cef_errorcode_t_ERR_QUIC_PROTOCOL_ERROR: cef_errorcode_t = -356; +pub const cef_errorcode_t_ERR_RESPONSE_HEADERS_TRUNCATED: cef_errorcode_t = -357; +pub const cef_errorcode_t_ERR_QUIC_HANDSHAKE_FAILED: cef_errorcode_t = -358; +pub const cef_errorcode_t_ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY: cef_errorcode_t = -360; +pub const cef_errorcode_t_ERR_HTTP2_FLOW_CONTROL_ERROR: cef_errorcode_t = -361; +pub const cef_errorcode_t_ERR_HTTP2_FRAME_SIZE_ERROR: cef_errorcode_t = -362; +pub const cef_errorcode_t_ERR_HTTP2_COMPRESSION_ERROR: cef_errorcode_t = -363; +pub const cef_errorcode_t_ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION: cef_errorcode_t = -364; +pub const cef_errorcode_t_ERR_HTTP_1_1_REQUIRED: cef_errorcode_t = -365; +pub const cef_errorcode_t_ERR_PROXY_HTTP_1_1_REQUIRED: cef_errorcode_t = -366; +pub const cef_errorcode_t_ERR_PAC_SCRIPT_TERMINATED: cef_errorcode_t = -367; +pub const cef_errorcode_t_ERR_INVALID_HTTP_RESPONSE: cef_errorcode_t = -370; +pub const cef_errorcode_t_ERR_CONTENT_DECODING_INIT_FAILED: cef_errorcode_t = -371; +pub const cef_errorcode_t_ERR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED: cef_errorcode_t = -372; +pub const cef_errorcode_t_ERR_HTTP2_PUSHED_STREAM_NOT_AVAILABLE: cef_errorcode_t = -373; +pub const cef_errorcode_t_ERR_HTTP2_CLAIMED_PUSHED_STREAM_RESET_BY_SERVER: cef_errorcode_t = -374; +pub const cef_errorcode_t_ERR_TOO_MANY_RETRIES: cef_errorcode_t = -375; +pub const cef_errorcode_t_ERR_HTTP2_STREAM_CLOSED: cef_errorcode_t = -376; +pub const cef_errorcode_t_ERR_HTTP2_CLIENT_REFUSED_STREAM: cef_errorcode_t = -377; +pub const cef_errorcode_t_ERR_HTTP2_PUSHED_RESPONSE_DOES_NOT_MATCH: cef_errorcode_t = -378; +pub const cef_errorcode_t_ERR_HTTP_RESPONSE_CODE_FAILURE: cef_errorcode_t = -379; +pub const cef_errorcode_t_ERR_QUIC_CERT_ROOT_NOT_KNOWN: cef_errorcode_t = -380; +pub const cef_errorcode_t_ERR_CACHE_MISS: cef_errorcode_t = -400; +pub const cef_errorcode_t_ERR_CACHE_READ_FAILURE: cef_errorcode_t = -401; +pub const cef_errorcode_t_ERR_CACHE_WRITE_FAILURE: cef_errorcode_t = -402; +pub const cef_errorcode_t_ERR_CACHE_OPERATION_NOT_SUPPORTED: cef_errorcode_t = -403; +pub const cef_errorcode_t_ERR_CACHE_OPEN_FAILURE: cef_errorcode_t = -404; +pub const cef_errorcode_t_ERR_CACHE_CREATE_FAILURE: cef_errorcode_t = -405; +pub const cef_errorcode_t_ERR_CACHE_RACE: cef_errorcode_t = -406; +pub const cef_errorcode_t_ERR_CACHE_CHECKSUM_READ_FAILURE: cef_errorcode_t = -407; +pub const cef_errorcode_t_ERR_CACHE_CHECKSUM_MISMATCH: cef_errorcode_t = -408; +pub const cef_errorcode_t_ERR_CACHE_LOCK_TIMEOUT: cef_errorcode_t = -409; +pub const cef_errorcode_t_ERR_CACHE_AUTH_FAILURE_AFTER_READ: cef_errorcode_t = -410; +pub const cef_errorcode_t_ERR_CACHE_ENTRY_NOT_SUITABLE: cef_errorcode_t = -411; +pub const cef_errorcode_t_ERR_CACHE_DOOM_FAILURE: cef_errorcode_t = -412; +pub const cef_errorcode_t_ERR_CACHE_OPEN_OR_CREATE_FAILURE: cef_errorcode_t = -413; +pub const cef_errorcode_t_ERR_INSECURE_RESPONSE: cef_errorcode_t = -501; +pub const cef_errorcode_t_ERR_NO_PRIVATE_KEY_FOR_CERT: cef_errorcode_t = -502; +pub const cef_errorcode_t_ERR_ADD_USER_CERT_FAILED: cef_errorcode_t = -503; +pub const cef_errorcode_t_ERR_INVALID_SIGNED_EXCHANGE: cef_errorcode_t = -504; +pub const cef_errorcode_t_ERR_INVALID_WEB_BUNDLE: cef_errorcode_t = -505; +pub const cef_errorcode_t_ERR_FTP_FAILED: cef_errorcode_t = -601; +pub const cef_errorcode_t_ERR_FTP_SERVICE_UNAVAILABLE: cef_errorcode_t = -602; +pub const cef_errorcode_t_ERR_FTP_TRANSFER_ABORTED: cef_errorcode_t = -603; +pub const cef_errorcode_t_ERR_FTP_FILE_BUSY: cef_errorcode_t = -604; +pub const cef_errorcode_t_ERR_FTP_SYNTAX_ERROR: cef_errorcode_t = -605; +pub const cef_errorcode_t_ERR_FTP_COMMAND_NOT_SUPPORTED: cef_errorcode_t = -606; +pub const cef_errorcode_t_ERR_FTP_BAD_COMMAND_SEQUENCE: cef_errorcode_t = -607; +pub const cef_errorcode_t_ERR_PKCS12_IMPORT_BAD_PASSWORD: cef_errorcode_t = -701; +pub const cef_errorcode_t_ERR_PKCS12_IMPORT_FAILED: cef_errorcode_t = -702; +pub const cef_errorcode_t_ERR_IMPORT_CA_CERT_NOT_CA: cef_errorcode_t = -703; +pub const cef_errorcode_t_ERR_IMPORT_CERT_ALREADY_EXISTS: cef_errorcode_t = -704; +pub const cef_errorcode_t_ERR_IMPORT_CA_CERT_FAILED: cef_errorcode_t = -705; +pub const cef_errorcode_t_ERR_IMPORT_SERVER_CERT_FAILED: cef_errorcode_t = -706; +pub const cef_errorcode_t_ERR_PKCS12_IMPORT_INVALID_MAC: cef_errorcode_t = -707; +pub const cef_errorcode_t_ERR_PKCS12_IMPORT_INVALID_FILE: cef_errorcode_t = -708; +pub const cef_errorcode_t_ERR_PKCS12_IMPORT_UNSUPPORTED: cef_errorcode_t = -709; +pub const cef_errorcode_t_ERR_KEY_GENERATION_FAILED: cef_errorcode_t = -710; +pub const cef_errorcode_t_ERR_PRIVATE_KEY_EXPORT_FAILED: cef_errorcode_t = -712; +pub const cef_errorcode_t_ERR_SELF_SIGNED_CERT_GENERATION_FAILED: cef_errorcode_t = -713; +pub const cef_errorcode_t_ERR_CERT_DATABASE_CHANGED: cef_errorcode_t = -714; +pub const cef_errorcode_t_ERR_DNS_MALFORMED_RESPONSE: cef_errorcode_t = -800; +pub const cef_errorcode_t_ERR_DNS_SERVER_REQUIRES_TCP: cef_errorcode_t = -801; +pub const cef_errorcode_t_ERR_DNS_SERVER_FAILED: cef_errorcode_t = -802; +pub const cef_errorcode_t_ERR_DNS_TIMED_OUT: cef_errorcode_t = -803; +pub const cef_errorcode_t_ERR_DNS_CACHE_MISS: cef_errorcode_t = -804; +pub const cef_errorcode_t_ERR_DNS_SEARCH_EMPTY: cef_errorcode_t = -805; +pub const cef_errorcode_t_ERR_DNS_SORT_ERROR: cef_errorcode_t = -806; +pub const cef_errorcode_t_ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED: cef_errorcode_t = -808; +pub type cef_errorcode_t = ::std::os::raw::c_int; +pub const cef_cert_status_t_CERT_STATUS_NONE: cef_cert_status_t = 0; +pub const cef_cert_status_t_CERT_STATUS_COMMON_NAME_INVALID: cef_cert_status_t = 1; +pub const cef_cert_status_t_CERT_STATUS_DATE_INVALID: cef_cert_status_t = 2; +pub const cef_cert_status_t_CERT_STATUS_AUTHORITY_INVALID: cef_cert_status_t = 4; +pub const cef_cert_status_t_CERT_STATUS_NO_REVOCATION_MECHANISM: cef_cert_status_t = 16; +pub const cef_cert_status_t_CERT_STATUS_UNABLE_TO_CHECK_REVOCATION: cef_cert_status_t = 32; +pub const cef_cert_status_t_CERT_STATUS_REVOKED: cef_cert_status_t = 64; +pub const cef_cert_status_t_CERT_STATUS_INVALID: cef_cert_status_t = 128; +pub const cef_cert_status_t_CERT_STATUS_WEAK_SIGNATURE_ALGORITHM: cef_cert_status_t = 256; +pub const cef_cert_status_t_CERT_STATUS_NON_UNIQUE_NAME: cef_cert_status_t = 1024; +pub const cef_cert_status_t_CERT_STATUS_WEAK_KEY: cef_cert_status_t = 2048; +pub const cef_cert_status_t_CERT_STATUS_PINNED_KEY_MISSING: cef_cert_status_t = 8192; +pub const cef_cert_status_t_CERT_STATUS_NAME_CONSTRAINT_VIOLATION: cef_cert_status_t = 16384; +pub const cef_cert_status_t_CERT_STATUS_VALIDITY_TOO_LONG: cef_cert_status_t = 32768; +pub const cef_cert_status_t_CERT_STATUS_IS_EV: cef_cert_status_t = 65536; +pub const cef_cert_status_t_CERT_STATUS_REV_CHECKING_ENABLED: cef_cert_status_t = 131072; +pub const cef_cert_status_t_CERT_STATUS_SHA1_SIGNATURE_PRESENT: cef_cert_status_t = 524288; +pub const cef_cert_status_t_CERT_STATUS_CT_COMPLIANCE_FAILED: cef_cert_status_t = 1048576; +pub type cef_cert_status_t = ::std::os::raw::c_uint; +pub const cef_window_open_disposition_t_WOD_UNKNOWN: cef_window_open_disposition_t = 0; +pub const cef_window_open_disposition_t_WOD_CURRENT_TAB: cef_window_open_disposition_t = 1; +pub const cef_window_open_disposition_t_WOD_SINGLETON_TAB: cef_window_open_disposition_t = 2; +pub const cef_window_open_disposition_t_WOD_NEW_FOREGROUND_TAB: cef_window_open_disposition_t = 3; +pub const cef_window_open_disposition_t_WOD_NEW_BACKGROUND_TAB: cef_window_open_disposition_t = 4; +pub const cef_window_open_disposition_t_WOD_NEW_POPUP: cef_window_open_disposition_t = 5; +pub const cef_window_open_disposition_t_WOD_NEW_WINDOW: cef_window_open_disposition_t = 6; +pub const cef_window_open_disposition_t_WOD_SAVE_TO_DISK: cef_window_open_disposition_t = 7; +pub const cef_window_open_disposition_t_WOD_OFF_THE_RECORD: cef_window_open_disposition_t = 8; +pub const cef_window_open_disposition_t_WOD_IGNORE_ACTION: cef_window_open_disposition_t = 9; +pub type cef_window_open_disposition_t = ::std::os::raw::c_uint; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_NONE: cef_drag_operations_mask_t = 0; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_COPY: cef_drag_operations_mask_t = 1; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_LINK: cef_drag_operations_mask_t = 2; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_GENERIC: cef_drag_operations_mask_t = 4; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_PRIVATE: cef_drag_operations_mask_t = 8; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_MOVE: cef_drag_operations_mask_t = 16; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_DELETE: cef_drag_operations_mask_t = 32; +pub const cef_drag_operations_mask_t_DRAG_OPERATION_EVERY: cef_drag_operations_mask_t = 4294967295; +pub type cef_drag_operations_mask_t = ::std::os::raw::c_uint; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_DEFAULT: cef_text_input_mode_t = 0; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_NONE: cef_text_input_mode_t = 1; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_TEXT: cef_text_input_mode_t = 2; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_TEL: cef_text_input_mode_t = 3; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_URL: cef_text_input_mode_t = 4; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_EMAIL: cef_text_input_mode_t = 5; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_NUMERIC: cef_text_input_mode_t = 6; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_DECIMAL: cef_text_input_mode_t = 7; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_SEARCH: cef_text_input_mode_t = 8; +pub const cef_text_input_mode_t_CEF_TEXT_INPUT_MODE_MAX: cef_text_input_mode_t = 8; +pub type cef_text_input_mode_t = ::std::os::raw::c_uint; +pub const cef_v8_accesscontrol_t_V8_ACCESS_CONTROL_DEFAULT: cef_v8_accesscontrol_t = 0; +pub const cef_v8_accesscontrol_t_V8_ACCESS_CONTROL_ALL_CAN_READ: cef_v8_accesscontrol_t = 1; +pub const cef_v8_accesscontrol_t_V8_ACCESS_CONTROL_ALL_CAN_WRITE: cef_v8_accesscontrol_t = 2; +pub const cef_v8_accesscontrol_t_V8_ACCESS_CONTROL_PROHIBITS_OVERWRITING: cef_v8_accesscontrol_t = 4; +pub type cef_v8_accesscontrol_t = ::std::os::raw::c_uint; +pub const cef_v8_propertyattribute_t_V8_PROPERTY_ATTRIBUTE_NONE: cef_v8_propertyattribute_t = 0; +pub const cef_v8_propertyattribute_t_V8_PROPERTY_ATTRIBUTE_READONLY: cef_v8_propertyattribute_t = 1; +pub const cef_v8_propertyattribute_t_V8_PROPERTY_ATTRIBUTE_DONTENUM: cef_v8_propertyattribute_t = 2; +pub const cef_v8_propertyattribute_t_V8_PROPERTY_ATTRIBUTE_DONTDELETE: cef_v8_propertyattribute_t = 4; +pub type cef_v8_propertyattribute_t = ::std::os::raw::c_uint; +pub const cef_postdataelement_type_t_PDE_TYPE_EMPTY: cef_postdataelement_type_t = 0; +pub const cef_postdataelement_type_t_PDE_TYPE_BYTES: cef_postdataelement_type_t = 1; +pub const cef_postdataelement_type_t_PDE_TYPE_FILE: cef_postdataelement_type_t = 2; +pub type cef_postdataelement_type_t = ::std::os::raw::c_uint; +pub const cef_resource_type_t_RT_MAIN_FRAME: cef_resource_type_t = 0; +pub const cef_resource_type_t_RT_SUB_FRAME: cef_resource_type_t = 1; +pub const cef_resource_type_t_RT_STYLESHEET: cef_resource_type_t = 2; +pub const cef_resource_type_t_RT_SCRIPT: cef_resource_type_t = 3; +pub const cef_resource_type_t_RT_IMAGE: cef_resource_type_t = 4; +pub const cef_resource_type_t_RT_FONT_RESOURCE: cef_resource_type_t = 5; +pub const cef_resource_type_t_RT_SUB_RESOURCE: cef_resource_type_t = 6; +pub const cef_resource_type_t_RT_OBJECT: cef_resource_type_t = 7; +pub const cef_resource_type_t_RT_MEDIA: cef_resource_type_t = 8; +pub const cef_resource_type_t_RT_WORKER: cef_resource_type_t = 9; +pub const cef_resource_type_t_RT_SHARED_WORKER: cef_resource_type_t = 10; +pub const cef_resource_type_t_RT_PREFETCH: cef_resource_type_t = 11; +pub const cef_resource_type_t_RT_FAVICON: cef_resource_type_t = 12; +pub const cef_resource_type_t_RT_XHR: cef_resource_type_t = 13; +pub const cef_resource_type_t_RT_PING: cef_resource_type_t = 14; +pub const cef_resource_type_t_RT_SERVICE_WORKER: cef_resource_type_t = 15; +pub const cef_resource_type_t_RT_CSP_REPORT: cef_resource_type_t = 16; +pub const cef_resource_type_t_RT_PLUGIN_RESOURCE: cef_resource_type_t = 17; +pub type cef_resource_type_t = ::std::os::raw::c_uint; +pub const cef_transition_type_t_TT_LINK: cef_transition_type_t = 0; +pub const cef_transition_type_t_TT_EXPLICIT: cef_transition_type_t = 1; +pub const cef_transition_type_t_TT_AUTO_SUBFRAME: cef_transition_type_t = 3; +pub const cef_transition_type_t_TT_MANUAL_SUBFRAME: cef_transition_type_t = 4; +pub const cef_transition_type_t_TT_FORM_SUBMIT: cef_transition_type_t = 7; +pub const cef_transition_type_t_TT_RELOAD: cef_transition_type_t = 8; +pub const cef_transition_type_t_TT_SOURCE_MASK: cef_transition_type_t = 255; +pub const cef_transition_type_t_TT_BLOCKED_FLAG: cef_transition_type_t = 8388608; +pub const cef_transition_type_t_TT_FORWARD_BACK_FLAG: cef_transition_type_t = 16777216; +pub const cef_transition_type_t_TT_DIRECT_LOAD_FLAG: cef_transition_type_t = 33554432; +pub const cef_transition_type_t_TT_CHAIN_START_FLAG: cef_transition_type_t = 268435456; +pub const cef_transition_type_t_TT_CHAIN_END_FLAG: cef_transition_type_t = 536870912; +pub const cef_transition_type_t_TT_CLIENT_REDIRECT_FLAG: cef_transition_type_t = 1073741824; +pub const cef_transition_type_t_TT_SERVER_REDIRECT_FLAG: cef_transition_type_t = 2147483648; +pub const cef_transition_type_t_TT_IS_REDIRECT_MASK: cef_transition_type_t = 3221225472; +pub const cef_transition_type_t_TT_QUALIFIER_MASK: cef_transition_type_t = 4294967040; +pub type cef_transition_type_t = ::std::os::raw::c_uint; +pub const cef_urlrequest_flags_t_UR_FLAG_NONE: cef_urlrequest_flags_t = 0; +pub const cef_urlrequest_flags_t_UR_FLAG_SKIP_CACHE: cef_urlrequest_flags_t = 1; +pub const cef_urlrequest_flags_t_UR_FLAG_ONLY_FROM_CACHE: cef_urlrequest_flags_t = 2; +pub const cef_urlrequest_flags_t_UR_FLAG_DISABLE_CACHE: cef_urlrequest_flags_t = 4; +pub const cef_urlrequest_flags_t_UR_FLAG_ALLOW_STORED_CREDENTIALS: cef_urlrequest_flags_t = 8; +pub const cef_urlrequest_flags_t_UR_FLAG_REPORT_UPLOAD_PROGRESS: cef_urlrequest_flags_t = 16; +pub const cef_urlrequest_flags_t_UR_FLAG_NO_DOWNLOAD_DATA: cef_urlrequest_flags_t = 32; +pub const cef_urlrequest_flags_t_UR_FLAG_NO_RETRY_ON_5XX: cef_urlrequest_flags_t = 64; +pub const cef_urlrequest_flags_t_UR_FLAG_STOP_ON_REDIRECT: cef_urlrequest_flags_t = 128; +pub type cef_urlrequest_flags_t = ::std::os::raw::c_uint; +pub const cef_urlrequest_status_t_UR_UNKNOWN: cef_urlrequest_status_t = 0; +pub const cef_urlrequest_status_t_UR_SUCCESS: cef_urlrequest_status_t = 1; +pub const cef_urlrequest_status_t_UR_IO_PENDING: cef_urlrequest_status_t = 2; +pub const cef_urlrequest_status_t_UR_CANCELED: cef_urlrequest_status_t = 3; +pub const cef_urlrequest_status_t_UR_FAILED: cef_urlrequest_status_t = 4; +pub type cef_urlrequest_status_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_point_t { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, +} +pub type cef_point_t = _cef_point_t; +#[repr(C)] +pub struct _cef_rect_t { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, + pub width: ::std::os::raw::c_int, + pub height: ::std::os::raw::c_int, +} +pub type cef_rect_t = _cef_rect_t; +#[repr(C)] +pub struct _cef_size_t { + pub width: ::std::os::raw::c_int, + pub height: ::std::os::raw::c_int, +} +pub type cef_size_t = _cef_size_t; +#[repr(C)] +pub struct _cef_range_t { + pub from: ::std::os::raw::c_int, + pub to: ::std::os::raw::c_int, +} +pub type cef_range_t = _cef_range_t; +#[repr(C)] +pub struct _cef_insets_t { + pub top: ::std::os::raw::c_int, + pub left: ::std::os::raw::c_int, + pub bottom: ::std::os::raw::c_int, + pub right: ::std::os::raw::c_int, +} +pub type cef_insets_t = _cef_insets_t; +#[repr(C)] +pub struct _cef_draggable_region_t { + pub bounds: cef_rect_t, + pub draggable: ::std::os::raw::c_int, +} +pub type cef_draggable_region_t = _cef_draggable_region_t; +pub const cef_process_id_t_PID_BROWSER: cef_process_id_t = 0; +pub const cef_process_id_t_PID_RENDERER: cef_process_id_t = 1; +pub type cef_process_id_t = ::std::os::raw::c_uint; +pub const cef_thread_id_t_TID_UI: cef_thread_id_t = 0; +pub const cef_thread_id_t_TID_FILE_BACKGROUND: cef_thread_id_t = 1; +pub const cef_thread_id_t_TID_FILE: cef_thread_id_t = 1; +pub const cef_thread_id_t_TID_FILE_USER_VISIBLE: cef_thread_id_t = 2; +pub const cef_thread_id_t_TID_FILE_USER_BLOCKING: cef_thread_id_t = 3; +pub const cef_thread_id_t_TID_PROCESS_LAUNCHER: cef_thread_id_t = 4; +pub const cef_thread_id_t_TID_IO: cef_thread_id_t = 5; +pub const cef_thread_id_t_TID_RENDERER: cef_thread_id_t = 6; +pub type cef_thread_id_t = ::std::os::raw::c_uint; +pub const cef_thread_priority_t_TP_BACKGROUND: cef_thread_priority_t = 0; +pub const cef_thread_priority_t_TP_NORMAL: cef_thread_priority_t = 1; +pub const cef_thread_priority_t_TP_DISPLAY: cef_thread_priority_t = 2; +pub const cef_thread_priority_t_TP_REALTIME_AUDIO: cef_thread_priority_t = 3; +pub type cef_thread_priority_t = ::std::os::raw::c_uint; +pub const cef_message_loop_type_t_ML_TYPE_DEFAULT: cef_message_loop_type_t = 0; +pub const cef_message_loop_type_t_ML_TYPE_UI: cef_message_loop_type_t = 1; +pub const cef_message_loop_type_t_ML_TYPE_IO: cef_message_loop_type_t = 2; +pub type cef_message_loop_type_t = ::std::os::raw::c_uint; +pub const cef_com_init_mode_t_COM_INIT_MODE_NONE: cef_com_init_mode_t = 0; +pub const cef_com_init_mode_t_COM_INIT_MODE_STA: cef_com_init_mode_t = 1; +pub const cef_com_init_mode_t_COM_INIT_MODE_MTA: cef_com_init_mode_t = 2; +pub type cef_com_init_mode_t = ::std::os::raw::c_uint; +pub const cef_value_type_t_VTYPE_INVALID: cef_value_type_t = 0; +pub const cef_value_type_t_VTYPE_NULL: cef_value_type_t = 1; +pub const cef_value_type_t_VTYPE_BOOL: cef_value_type_t = 2; +pub const cef_value_type_t_VTYPE_INT: cef_value_type_t = 3; +pub const cef_value_type_t_VTYPE_DOUBLE: cef_value_type_t = 4; +pub const cef_value_type_t_VTYPE_STRING: cef_value_type_t = 5; +pub const cef_value_type_t_VTYPE_BINARY: cef_value_type_t = 6; +pub const cef_value_type_t_VTYPE_DICTIONARY: cef_value_type_t = 7; +pub const cef_value_type_t_VTYPE_LIST: cef_value_type_t = 8; +pub type cef_value_type_t = ::std::os::raw::c_uint; +pub const cef_jsdialog_type_t_JSDIALOGTYPE_ALERT: cef_jsdialog_type_t = 0; +pub const cef_jsdialog_type_t_JSDIALOGTYPE_CONFIRM: cef_jsdialog_type_t = 1; +pub const cef_jsdialog_type_t_JSDIALOGTYPE_PROMPT: cef_jsdialog_type_t = 2; +pub type cef_jsdialog_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_screen_info_t { + pub device_scale_factor: f32, + pub depth: ::std::os::raw::c_int, + pub depth_per_component: ::std::os::raw::c_int, + pub is_monochrome: ::std::os::raw::c_int, + pub rect: cef_rect_t, + pub available_rect: cef_rect_t, +} +pub type cef_screen_info_t = _cef_screen_info_t; +pub const cef_menu_id_t_MENU_ID_BACK: cef_menu_id_t = 100; +pub const cef_menu_id_t_MENU_ID_FORWARD: cef_menu_id_t = 101; +pub const cef_menu_id_t_MENU_ID_RELOAD: cef_menu_id_t = 102; +pub const cef_menu_id_t_MENU_ID_RELOAD_NOCACHE: cef_menu_id_t = 103; +pub const cef_menu_id_t_MENU_ID_STOPLOAD: cef_menu_id_t = 104; +pub const cef_menu_id_t_MENU_ID_UNDO: cef_menu_id_t = 110; +pub const cef_menu_id_t_MENU_ID_REDO: cef_menu_id_t = 111; +pub const cef_menu_id_t_MENU_ID_CUT: cef_menu_id_t = 112; +pub const cef_menu_id_t_MENU_ID_COPY: cef_menu_id_t = 113; +pub const cef_menu_id_t_MENU_ID_PASTE: cef_menu_id_t = 114; +pub const cef_menu_id_t_MENU_ID_DELETE: cef_menu_id_t = 115; +pub const cef_menu_id_t_MENU_ID_SELECT_ALL: cef_menu_id_t = 116; +pub const cef_menu_id_t_MENU_ID_FIND: cef_menu_id_t = 130; +pub const cef_menu_id_t_MENU_ID_PRINT: cef_menu_id_t = 131; +pub const cef_menu_id_t_MENU_ID_VIEW_SOURCE: cef_menu_id_t = 132; +pub const cef_menu_id_t_MENU_ID_SPELLCHECK_SUGGESTION_0: cef_menu_id_t = 200; +pub const cef_menu_id_t_MENU_ID_SPELLCHECK_SUGGESTION_1: cef_menu_id_t = 201; +pub const cef_menu_id_t_MENU_ID_SPELLCHECK_SUGGESTION_2: cef_menu_id_t = 202; +pub const cef_menu_id_t_MENU_ID_SPELLCHECK_SUGGESTION_3: cef_menu_id_t = 203; +pub const cef_menu_id_t_MENU_ID_SPELLCHECK_SUGGESTION_4: cef_menu_id_t = 204; +pub const cef_menu_id_t_MENU_ID_SPELLCHECK_SUGGESTION_LAST: cef_menu_id_t = 204; +pub const cef_menu_id_t_MENU_ID_NO_SPELLING_SUGGESTIONS: cef_menu_id_t = 205; +pub const cef_menu_id_t_MENU_ID_ADD_TO_DICTIONARY: cef_menu_id_t = 206; +pub const cef_menu_id_t_MENU_ID_CUSTOM_FIRST: cef_menu_id_t = 220; +pub const cef_menu_id_t_MENU_ID_CUSTOM_LAST: cef_menu_id_t = 250; +pub const cef_menu_id_t_MENU_ID_USER_FIRST: cef_menu_id_t = 26500; +pub const cef_menu_id_t_MENU_ID_USER_LAST: cef_menu_id_t = 28500; +pub type cef_menu_id_t = ::std::os::raw::c_uint; +pub const cef_mouse_button_type_t_MBT_LEFT: cef_mouse_button_type_t = 0; +pub const cef_mouse_button_type_t_MBT_MIDDLE: cef_mouse_button_type_t = 1; +pub const cef_mouse_button_type_t_MBT_RIGHT: cef_mouse_button_type_t = 2; +pub type cef_mouse_button_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_mouse_event_t { + pub x: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, + pub modifiers: uint32, +} +pub type cef_mouse_event_t = _cef_mouse_event_t; +pub const cef_touch_event_type_t_CEF_TET_RELEASED: cef_touch_event_type_t = 0; +pub const cef_touch_event_type_t_CEF_TET_PRESSED: cef_touch_event_type_t = 1; +pub const cef_touch_event_type_t_CEF_TET_MOVED: cef_touch_event_type_t = 2; +pub const cef_touch_event_type_t_CEF_TET_CANCELLED: cef_touch_event_type_t = 3; +pub type cef_touch_event_type_t = ::std::os::raw::c_uint; +pub const cef_pointer_type_t_CEF_POINTER_TYPE_TOUCH: cef_pointer_type_t = 0; +pub const cef_pointer_type_t_CEF_POINTER_TYPE_MOUSE: cef_pointer_type_t = 1; +pub const cef_pointer_type_t_CEF_POINTER_TYPE_PEN: cef_pointer_type_t = 2; +pub const cef_pointer_type_t_CEF_POINTER_TYPE_ERASER: cef_pointer_type_t = 3; +pub const cef_pointer_type_t_CEF_POINTER_TYPE_UNKNOWN: cef_pointer_type_t = 4; +pub type cef_pointer_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_touch_event_t { + pub id: ::std::os::raw::c_int, + pub x: f32, + pub y: f32, + pub radius_x: f32, + pub radius_y: f32, + pub rotation_angle: f32, + pub pressure: f32, + pub type_: cef_touch_event_type_t, + pub modifiers: uint32, + pub pointer_type: cef_pointer_type_t, +} +pub type cef_touch_event_t = _cef_touch_event_t; +pub const cef_paint_element_type_t_PET_VIEW: cef_paint_element_type_t = 0; +pub const cef_paint_element_type_t_PET_POPUP: cef_paint_element_type_t = 1; +pub type cef_paint_element_type_t = ::std::os::raw::c_uint; +pub const cef_event_flags_t_EVENTFLAG_NONE: cef_event_flags_t = 0; +pub const cef_event_flags_t_EVENTFLAG_CAPS_LOCK_ON: cef_event_flags_t = 1; +pub const cef_event_flags_t_EVENTFLAG_SHIFT_DOWN: cef_event_flags_t = 2; +pub const cef_event_flags_t_EVENTFLAG_CONTROL_DOWN: cef_event_flags_t = 4; +pub const cef_event_flags_t_EVENTFLAG_ALT_DOWN: cef_event_flags_t = 8; +pub const cef_event_flags_t_EVENTFLAG_LEFT_MOUSE_BUTTON: cef_event_flags_t = 16; +pub const cef_event_flags_t_EVENTFLAG_MIDDLE_MOUSE_BUTTON: cef_event_flags_t = 32; +pub const cef_event_flags_t_EVENTFLAG_RIGHT_MOUSE_BUTTON: cef_event_flags_t = 64; +pub const cef_event_flags_t_EVENTFLAG_COMMAND_DOWN: cef_event_flags_t = 128; +pub const cef_event_flags_t_EVENTFLAG_NUM_LOCK_ON: cef_event_flags_t = 256; +pub const cef_event_flags_t_EVENTFLAG_IS_KEY_PAD: cef_event_flags_t = 512; +pub const cef_event_flags_t_EVENTFLAG_IS_LEFT: cef_event_flags_t = 1024; +pub const cef_event_flags_t_EVENTFLAG_IS_RIGHT: cef_event_flags_t = 2048; +pub type cef_event_flags_t = ::std::os::raw::c_uint; +pub const cef_menu_item_type_t_MENUITEMTYPE_NONE: cef_menu_item_type_t = 0; +pub const cef_menu_item_type_t_MENUITEMTYPE_COMMAND: cef_menu_item_type_t = 1; +pub const cef_menu_item_type_t_MENUITEMTYPE_CHECK: cef_menu_item_type_t = 2; +pub const cef_menu_item_type_t_MENUITEMTYPE_RADIO: cef_menu_item_type_t = 3; +pub const cef_menu_item_type_t_MENUITEMTYPE_SEPARATOR: cef_menu_item_type_t = 4; +pub const cef_menu_item_type_t_MENUITEMTYPE_SUBMENU: cef_menu_item_type_t = 5; +pub type cef_menu_item_type_t = ::std::os::raw::c_uint; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_NONE: cef_context_menu_type_flags_t = 0; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_PAGE: cef_context_menu_type_flags_t = 1; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_FRAME: cef_context_menu_type_flags_t = 2; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_LINK: cef_context_menu_type_flags_t = 4; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_MEDIA: cef_context_menu_type_flags_t = 8; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_SELECTION: cef_context_menu_type_flags_t = 16; +pub const cef_context_menu_type_flags_t_CM_TYPEFLAG_EDITABLE: cef_context_menu_type_flags_t = 32; +pub type cef_context_menu_type_flags_t = ::std::os::raw::c_uint; +pub const cef_context_menu_media_type_t_CM_MEDIATYPE_NONE: cef_context_menu_media_type_t = 0; +pub const cef_context_menu_media_type_t_CM_MEDIATYPE_IMAGE: cef_context_menu_media_type_t = 1; +pub const cef_context_menu_media_type_t_CM_MEDIATYPE_VIDEO: cef_context_menu_media_type_t = 2; +pub const cef_context_menu_media_type_t_CM_MEDIATYPE_AUDIO: cef_context_menu_media_type_t = 3; +pub const cef_context_menu_media_type_t_CM_MEDIATYPE_FILE: cef_context_menu_media_type_t = 4; +pub const cef_context_menu_media_type_t_CM_MEDIATYPE_PLUGIN: cef_context_menu_media_type_t = 5; +pub type cef_context_menu_media_type_t = ::std::os::raw::c_uint; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_NONE: cef_context_menu_media_state_flags_t = 0; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_ERROR: cef_context_menu_media_state_flags_t = 1; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_PAUSED: cef_context_menu_media_state_flags_t = 2; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_MUTED: cef_context_menu_media_state_flags_t = 4; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_LOOP: cef_context_menu_media_state_flags_t = 8; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_CAN_SAVE: cef_context_menu_media_state_flags_t = 16; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_HAS_AUDIO: cef_context_menu_media_state_flags_t = 32; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_HAS_VIDEO: cef_context_menu_media_state_flags_t = 64; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_CONTROL_ROOT_ELEMENT: cef_context_menu_media_state_flags_t = + 128; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_CAN_PRINT: cef_context_menu_media_state_flags_t = 256; +pub const cef_context_menu_media_state_flags_t_CM_MEDIAFLAG_CAN_ROTATE: cef_context_menu_media_state_flags_t = 512; +pub type cef_context_menu_media_state_flags_t = ::std::os::raw::c_uint; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_NONE: cef_context_menu_edit_state_flags_t = 0; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_UNDO: cef_context_menu_edit_state_flags_t = 1; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_REDO: cef_context_menu_edit_state_flags_t = 2; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_CUT: cef_context_menu_edit_state_flags_t = 4; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_COPY: cef_context_menu_edit_state_flags_t = 8; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_PASTE: cef_context_menu_edit_state_flags_t = 16; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_DELETE: cef_context_menu_edit_state_flags_t = 32; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_SELECT_ALL: cef_context_menu_edit_state_flags_t = 64; +pub const cef_context_menu_edit_state_flags_t_CM_EDITFLAG_CAN_TRANSLATE: cef_context_menu_edit_state_flags_t = 128; +pub type cef_context_menu_edit_state_flags_t = ::std::os::raw::c_uint; +pub const cef_key_event_type_t_KEYEVENT_RAWKEYDOWN: cef_key_event_type_t = 0; +pub const cef_key_event_type_t_KEYEVENT_KEYDOWN: cef_key_event_type_t = 1; +pub const cef_key_event_type_t_KEYEVENT_KEYUP: cef_key_event_type_t = 2; +pub const cef_key_event_type_t_KEYEVENT_CHAR: cef_key_event_type_t = 3; +pub type cef_key_event_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_key_event_t { + pub type_: cef_key_event_type_t, + pub modifiers: uint32, + pub windows_key_code: ::std::os::raw::c_int, + pub native_key_code: ::std::os::raw::c_int, + pub is_system_key: ::std::os::raw::c_int, + pub character: char16, + pub unmodified_character: char16, + pub focus_on_editable_field: ::std::os::raw::c_int, +} +pub type cef_key_event_t = _cef_key_event_t; +pub const cef_focus_source_t_FOCUS_SOURCE_NAVIGATION: cef_focus_source_t = 0; +pub const cef_focus_source_t_FOCUS_SOURCE_SYSTEM: cef_focus_source_t = 1; +pub type cef_focus_source_t = ::std::os::raw::c_uint; +pub const cef_navigation_type_t_NAVIGATION_LINK_CLICKED: cef_navigation_type_t = 0; +pub const cef_navigation_type_t_NAVIGATION_FORM_SUBMITTED: cef_navigation_type_t = 1; +pub const cef_navigation_type_t_NAVIGATION_BACK_FORWARD: cef_navigation_type_t = 2; +pub const cef_navigation_type_t_NAVIGATION_RELOAD: cef_navigation_type_t = 3; +pub const cef_navigation_type_t_NAVIGATION_FORM_RESUBMITTED: cef_navigation_type_t = 4; +pub const cef_navigation_type_t_NAVIGATION_OTHER: cef_navigation_type_t = 5; +pub type cef_navigation_type_t = ::std::os::raw::c_uint; +pub const cef_xml_encoding_type_t_XML_ENCODING_NONE: cef_xml_encoding_type_t = 0; +pub const cef_xml_encoding_type_t_XML_ENCODING_UTF8: cef_xml_encoding_type_t = 1; +pub const cef_xml_encoding_type_t_XML_ENCODING_UTF16LE: cef_xml_encoding_type_t = 2; +pub const cef_xml_encoding_type_t_XML_ENCODING_UTF16BE: cef_xml_encoding_type_t = 3; +pub const cef_xml_encoding_type_t_XML_ENCODING_ASCII: cef_xml_encoding_type_t = 4; +pub type cef_xml_encoding_type_t = ::std::os::raw::c_uint; +pub const cef_xml_node_type_t_XML_NODE_UNSUPPORTED: cef_xml_node_type_t = 0; +pub const cef_xml_node_type_t_XML_NODE_PROCESSING_INSTRUCTION: cef_xml_node_type_t = 1; +pub const cef_xml_node_type_t_XML_NODE_DOCUMENT_TYPE: cef_xml_node_type_t = 2; +pub const cef_xml_node_type_t_XML_NODE_ELEMENT_START: cef_xml_node_type_t = 3; +pub const cef_xml_node_type_t_XML_NODE_ELEMENT_END: cef_xml_node_type_t = 4; +pub const cef_xml_node_type_t_XML_NODE_ATTRIBUTE: cef_xml_node_type_t = 5; +pub const cef_xml_node_type_t_XML_NODE_TEXT: cef_xml_node_type_t = 6; +pub const cef_xml_node_type_t_XML_NODE_CDATA: cef_xml_node_type_t = 7; +pub const cef_xml_node_type_t_XML_NODE_ENTITY_REFERENCE: cef_xml_node_type_t = 8; +pub const cef_xml_node_type_t_XML_NODE_WHITESPACE: cef_xml_node_type_t = 9; +pub const cef_xml_node_type_t_XML_NODE_COMMENT: cef_xml_node_type_t = 10; +pub type cef_xml_node_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_popup_features_t { + pub x: ::std::os::raw::c_int, + pub xSet: ::std::os::raw::c_int, + pub y: ::std::os::raw::c_int, + pub ySet: ::std::os::raw::c_int, + pub width: ::std::os::raw::c_int, + pub widthSet: ::std::os::raw::c_int, + pub height: ::std::os::raw::c_int, + pub heightSet: ::std::os::raw::c_int, + pub menuBarVisible: ::std::os::raw::c_int, + pub statusBarVisible: ::std::os::raw::c_int, + pub toolBarVisible: ::std::os::raw::c_int, + pub scrollbarsVisible: ::std::os::raw::c_int, +} +pub type cef_popup_features_t = _cef_popup_features_t; +pub const cef_dom_document_type_t_DOM_DOCUMENT_TYPE_UNKNOWN: cef_dom_document_type_t = 0; +pub const cef_dom_document_type_t_DOM_DOCUMENT_TYPE_HTML: cef_dom_document_type_t = 1; +pub const cef_dom_document_type_t_DOM_DOCUMENT_TYPE_XHTML: cef_dom_document_type_t = 2; +pub const cef_dom_document_type_t_DOM_DOCUMENT_TYPE_PLUGIN: cef_dom_document_type_t = 3; +pub type cef_dom_document_type_t = ::std::os::raw::c_uint; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_UNKNOWN: cef_dom_event_category_t = 0; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_UI: cef_dom_event_category_t = 1; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_MOUSE: cef_dom_event_category_t = 2; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_MUTATION: cef_dom_event_category_t = 4; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_KEYBOARD: cef_dom_event_category_t = 8; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_TEXT: cef_dom_event_category_t = 16; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_COMPOSITION: cef_dom_event_category_t = 32; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_DRAG: cef_dom_event_category_t = 64; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_CLIPBOARD: cef_dom_event_category_t = 128; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_MESSAGE: cef_dom_event_category_t = 256; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_WHEEL: cef_dom_event_category_t = 512; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_BEFORE_TEXT_INSERTED: cef_dom_event_category_t = 1024; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_OVERFLOW: cef_dom_event_category_t = 2048; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_PAGE_TRANSITION: cef_dom_event_category_t = 4096; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_POPSTATE: cef_dom_event_category_t = 8192; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_PROGRESS: cef_dom_event_category_t = 16384; +pub const cef_dom_event_category_t_DOM_EVENT_CATEGORY_XMLHTTPREQUEST_PROGRESS: cef_dom_event_category_t = 32768; +pub type cef_dom_event_category_t = ::std::os::raw::c_uint; +pub const cef_dom_event_phase_t_DOM_EVENT_PHASE_UNKNOWN: cef_dom_event_phase_t = 0; +pub const cef_dom_event_phase_t_DOM_EVENT_PHASE_CAPTURING: cef_dom_event_phase_t = 1; +pub const cef_dom_event_phase_t_DOM_EVENT_PHASE_AT_TARGET: cef_dom_event_phase_t = 2; +pub const cef_dom_event_phase_t_DOM_EVENT_PHASE_BUBBLING: cef_dom_event_phase_t = 3; +pub type cef_dom_event_phase_t = ::std::os::raw::c_uint; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_UNSUPPORTED: cef_dom_node_type_t = 0; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_ELEMENT: cef_dom_node_type_t = 1; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_ATTRIBUTE: cef_dom_node_type_t = 2; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_TEXT: cef_dom_node_type_t = 3; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_CDATA_SECTION: cef_dom_node_type_t = 4; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_PROCESSING_INSTRUCTIONS: cef_dom_node_type_t = 5; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_COMMENT: cef_dom_node_type_t = 6; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_DOCUMENT: cef_dom_node_type_t = 7; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_DOCUMENT_TYPE: cef_dom_node_type_t = 8; +pub const cef_dom_node_type_t_DOM_NODE_TYPE_DOCUMENT_FRAGMENT: cef_dom_node_type_t = 9; +pub type cef_dom_node_type_t = ::std::os::raw::c_uint; +pub const cef_file_dialog_mode_t_FILE_DIALOG_OPEN: cef_file_dialog_mode_t = 0; +pub const cef_file_dialog_mode_t_FILE_DIALOG_OPEN_MULTIPLE: cef_file_dialog_mode_t = 1; +pub const cef_file_dialog_mode_t_FILE_DIALOG_OPEN_FOLDER: cef_file_dialog_mode_t = 2; +pub const cef_file_dialog_mode_t_FILE_DIALOG_SAVE: cef_file_dialog_mode_t = 3; +pub const cef_file_dialog_mode_t_FILE_DIALOG_TYPE_MASK: cef_file_dialog_mode_t = 255; +pub const cef_file_dialog_mode_t_FILE_DIALOG_OVERWRITEPROMPT_FLAG: cef_file_dialog_mode_t = 16777216; +pub const cef_file_dialog_mode_t_FILE_DIALOG_HIDEREADONLY_FLAG: cef_file_dialog_mode_t = 33554432; +pub type cef_file_dialog_mode_t = ::std::os::raw::c_uint; +pub const cef_color_model_t_COLOR_MODEL_UNKNOWN: cef_color_model_t = 0; +pub const cef_color_model_t_COLOR_MODEL_GRAY: cef_color_model_t = 1; +pub const cef_color_model_t_COLOR_MODEL_COLOR: cef_color_model_t = 2; +pub const cef_color_model_t_COLOR_MODEL_CMYK: cef_color_model_t = 3; +pub const cef_color_model_t_COLOR_MODEL_CMY: cef_color_model_t = 4; +pub const cef_color_model_t_COLOR_MODEL_KCMY: cef_color_model_t = 5; +pub const cef_color_model_t_COLOR_MODEL_CMY_K: cef_color_model_t = 6; +pub const cef_color_model_t_COLOR_MODEL_BLACK: cef_color_model_t = 7; +pub const cef_color_model_t_COLOR_MODEL_GRAYSCALE: cef_color_model_t = 8; +pub const cef_color_model_t_COLOR_MODEL_RGB: cef_color_model_t = 9; +pub const cef_color_model_t_COLOR_MODEL_RGB16: cef_color_model_t = 10; +pub const cef_color_model_t_COLOR_MODEL_RGBA: cef_color_model_t = 11; +pub const cef_color_model_t_COLOR_MODEL_COLORMODE_COLOR: cef_color_model_t = 12; +pub const cef_color_model_t_COLOR_MODEL_COLORMODE_MONOCHROME: cef_color_model_t = 13; +pub const cef_color_model_t_COLOR_MODEL_HP_COLOR_COLOR: cef_color_model_t = 14; +pub const cef_color_model_t_COLOR_MODEL_HP_COLOR_BLACK: cef_color_model_t = 15; +pub const cef_color_model_t_COLOR_MODEL_PRINTOUTMODE_NORMAL: cef_color_model_t = 16; +pub const cef_color_model_t_COLOR_MODEL_PRINTOUTMODE_NORMAL_GRAY: cef_color_model_t = 17; +pub const cef_color_model_t_COLOR_MODEL_PROCESSCOLORMODEL_CMYK: cef_color_model_t = 18; +pub const cef_color_model_t_COLOR_MODEL_PROCESSCOLORMODEL_GREYSCALE: cef_color_model_t = 19; +pub const cef_color_model_t_COLOR_MODEL_PROCESSCOLORMODEL_RGB: cef_color_model_t = 20; +pub type cef_color_model_t = ::std::os::raw::c_uint; +pub const cef_duplex_mode_t_DUPLEX_MODE_UNKNOWN: cef_duplex_mode_t = -1; +pub const cef_duplex_mode_t_DUPLEX_MODE_SIMPLEX: cef_duplex_mode_t = 0; +pub const cef_duplex_mode_t_DUPLEX_MODE_LONG_EDGE: cef_duplex_mode_t = 1; +pub const cef_duplex_mode_t_DUPLEX_MODE_SHORT_EDGE: cef_duplex_mode_t = 2; +pub type cef_duplex_mode_t = ::std::os::raw::c_int; +pub const cef_cursor_type_t_CT_POINTER: cef_cursor_type_t = 0; +pub const cef_cursor_type_t_CT_CROSS: cef_cursor_type_t = 1; +pub const cef_cursor_type_t_CT_HAND: cef_cursor_type_t = 2; +pub const cef_cursor_type_t_CT_IBEAM: cef_cursor_type_t = 3; +pub const cef_cursor_type_t_CT_WAIT: cef_cursor_type_t = 4; +pub const cef_cursor_type_t_CT_HELP: cef_cursor_type_t = 5; +pub const cef_cursor_type_t_CT_EASTRESIZE: cef_cursor_type_t = 6; +pub const cef_cursor_type_t_CT_NORTHRESIZE: cef_cursor_type_t = 7; +pub const cef_cursor_type_t_CT_NORTHEASTRESIZE: cef_cursor_type_t = 8; +pub const cef_cursor_type_t_CT_NORTHWESTRESIZE: cef_cursor_type_t = 9; +pub const cef_cursor_type_t_CT_SOUTHRESIZE: cef_cursor_type_t = 10; +pub const cef_cursor_type_t_CT_SOUTHEASTRESIZE: cef_cursor_type_t = 11; +pub const cef_cursor_type_t_CT_SOUTHWESTRESIZE: cef_cursor_type_t = 12; +pub const cef_cursor_type_t_CT_WESTRESIZE: cef_cursor_type_t = 13; +pub const cef_cursor_type_t_CT_NORTHSOUTHRESIZE: cef_cursor_type_t = 14; +pub const cef_cursor_type_t_CT_EASTWESTRESIZE: cef_cursor_type_t = 15; +pub const cef_cursor_type_t_CT_NORTHEASTSOUTHWESTRESIZE: cef_cursor_type_t = 16; +pub const cef_cursor_type_t_CT_NORTHWESTSOUTHEASTRESIZE: cef_cursor_type_t = 17; +pub const cef_cursor_type_t_CT_COLUMNRESIZE: cef_cursor_type_t = 18; +pub const cef_cursor_type_t_CT_ROWRESIZE: cef_cursor_type_t = 19; +pub const cef_cursor_type_t_CT_MIDDLEPANNING: cef_cursor_type_t = 20; +pub const cef_cursor_type_t_CT_EASTPANNING: cef_cursor_type_t = 21; +pub const cef_cursor_type_t_CT_NORTHPANNING: cef_cursor_type_t = 22; +pub const cef_cursor_type_t_CT_NORTHEASTPANNING: cef_cursor_type_t = 23; +pub const cef_cursor_type_t_CT_NORTHWESTPANNING: cef_cursor_type_t = 24; +pub const cef_cursor_type_t_CT_SOUTHPANNING: cef_cursor_type_t = 25; +pub const cef_cursor_type_t_CT_SOUTHEASTPANNING: cef_cursor_type_t = 26; +pub const cef_cursor_type_t_CT_SOUTHWESTPANNING: cef_cursor_type_t = 27; +pub const cef_cursor_type_t_CT_WESTPANNING: cef_cursor_type_t = 28; +pub const cef_cursor_type_t_CT_MOVE: cef_cursor_type_t = 29; +pub const cef_cursor_type_t_CT_VERTICALTEXT: cef_cursor_type_t = 30; +pub const cef_cursor_type_t_CT_CELL: cef_cursor_type_t = 31; +pub const cef_cursor_type_t_CT_CONTEXTMENU: cef_cursor_type_t = 32; +pub const cef_cursor_type_t_CT_ALIAS: cef_cursor_type_t = 33; +pub const cef_cursor_type_t_CT_PROGRESS: cef_cursor_type_t = 34; +pub const cef_cursor_type_t_CT_NODROP: cef_cursor_type_t = 35; +pub const cef_cursor_type_t_CT_COPY: cef_cursor_type_t = 36; +pub const cef_cursor_type_t_CT_NONE: cef_cursor_type_t = 37; +pub const cef_cursor_type_t_CT_NOTALLOWED: cef_cursor_type_t = 38; +pub const cef_cursor_type_t_CT_ZOOMIN: cef_cursor_type_t = 39; +pub const cef_cursor_type_t_CT_ZOOMOUT: cef_cursor_type_t = 40; +pub const cef_cursor_type_t_CT_GRAB: cef_cursor_type_t = 41; +pub const cef_cursor_type_t_CT_GRABBING: cef_cursor_type_t = 42; +pub const cef_cursor_type_t_CT_CUSTOM: cef_cursor_type_t = 43; +pub type cef_cursor_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_cursor_info_t { + pub hotspot: cef_point_t, + pub image_scale_factor: f32, + pub buffer: *mut ::std::os::raw::c_void, + pub size: cef_size_t, +} +pub type cef_cursor_info_t = _cef_cursor_info_t; +pub const cef_uri_unescape_rule_t_UU_NONE: cef_uri_unescape_rule_t = 0; +pub const cef_uri_unescape_rule_t_UU_NORMAL: cef_uri_unescape_rule_t = 1; +pub const cef_uri_unescape_rule_t_UU_SPACES: cef_uri_unescape_rule_t = 2; +pub const cef_uri_unescape_rule_t_UU_PATH_SEPARATORS: cef_uri_unescape_rule_t = 4; +pub const cef_uri_unescape_rule_t_UU_URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS: cef_uri_unescape_rule_t = 8; +pub const cef_uri_unescape_rule_t_UU_SPOOFING_AND_CONTROL_CHARS: cef_uri_unescape_rule_t = 16; +pub const cef_uri_unescape_rule_t_UU_REPLACE_PLUS_WITH_SPACE: cef_uri_unescape_rule_t = 32; +pub type cef_uri_unescape_rule_t = ::std::os::raw::c_uint; +pub const cef_json_parser_options_t_JSON_PARSER_RFC: cef_json_parser_options_t = 0; +pub const cef_json_parser_options_t_JSON_PARSER_ALLOW_TRAILING_COMMAS: cef_json_parser_options_t = 1; +pub type cef_json_parser_options_t = ::std::os::raw::c_uint; +pub const cef_json_parser_error_t_JSON_NO_ERROR: cef_json_parser_error_t = 0; +pub const cef_json_parser_error_t_JSON_INVALID_ESCAPE: cef_json_parser_error_t = 1; +pub const cef_json_parser_error_t_JSON_SYNTAX_ERROR: cef_json_parser_error_t = 2; +pub const cef_json_parser_error_t_JSON_UNEXPECTED_TOKEN: cef_json_parser_error_t = 3; +pub const cef_json_parser_error_t_JSON_TRAILING_COMMA: cef_json_parser_error_t = 4; +pub const cef_json_parser_error_t_JSON_TOO_MUCH_NESTING: cef_json_parser_error_t = 5; +pub const cef_json_parser_error_t_JSON_UNEXPECTED_DATA_AFTER_ROOT: cef_json_parser_error_t = 6; +pub const cef_json_parser_error_t_JSON_UNSUPPORTED_ENCODING: cef_json_parser_error_t = 7; +pub const cef_json_parser_error_t_JSON_UNQUOTED_DICTIONARY_KEY: cef_json_parser_error_t = 8; +pub const cef_json_parser_error_t_JSON_PARSE_ERROR_COUNT: cef_json_parser_error_t = 9; +pub type cef_json_parser_error_t = ::std::os::raw::c_uint; +pub const cef_json_writer_options_t_JSON_WRITER_DEFAULT: cef_json_writer_options_t = 0; +pub const cef_json_writer_options_t_JSON_WRITER_OMIT_BINARY_VALUES: cef_json_writer_options_t = 1; +pub const cef_json_writer_options_t_JSON_WRITER_OMIT_DOUBLE_TYPE_PRESERVATION: cef_json_writer_options_t = 2; +pub const cef_json_writer_options_t_JSON_WRITER_PRETTY_PRINT: cef_json_writer_options_t = 4; +pub type cef_json_writer_options_t = ::std::os::raw::c_uint; +pub const cef_pdf_print_margin_type_t_PDF_PRINT_MARGIN_DEFAULT: cef_pdf_print_margin_type_t = 0; +pub const cef_pdf_print_margin_type_t_PDF_PRINT_MARGIN_NONE: cef_pdf_print_margin_type_t = 1; +pub const cef_pdf_print_margin_type_t_PDF_PRINT_MARGIN_MINIMUM: cef_pdf_print_margin_type_t = 2; +pub const cef_pdf_print_margin_type_t_PDF_PRINT_MARGIN_CUSTOM: cef_pdf_print_margin_type_t = 3; +pub type cef_pdf_print_margin_type_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_pdf_print_settings_t { + pub header_footer_title: cef_string_t, + pub header_footer_url: cef_string_t, + pub page_width: ::std::os::raw::c_int, + pub page_height: ::std::os::raw::c_int, + pub scale_factor: ::std::os::raw::c_int, + pub margin_top: f64, + pub margin_right: f64, + pub margin_bottom: f64, + pub margin_left: f64, + pub margin_type: cef_pdf_print_margin_type_t, + pub header_footer_enabled: ::std::os::raw::c_int, + pub selection_only: ::std::os::raw::c_int, + pub landscape: ::std::os::raw::c_int, + pub backgrounds_enabled: ::std::os::raw::c_int, +} +pub type cef_pdf_print_settings_t = _cef_pdf_print_settings_t; +pub const cef_scale_factor_t_SCALE_FACTOR_NONE: cef_scale_factor_t = 0; +pub const cef_scale_factor_t_SCALE_FACTOR_100P: cef_scale_factor_t = 1; +pub const cef_scale_factor_t_SCALE_FACTOR_125P: cef_scale_factor_t = 2; +pub const cef_scale_factor_t_SCALE_FACTOR_133P: cef_scale_factor_t = 3; +pub const cef_scale_factor_t_SCALE_FACTOR_140P: cef_scale_factor_t = 4; +pub const cef_scale_factor_t_SCALE_FACTOR_150P: cef_scale_factor_t = 5; +pub const cef_scale_factor_t_SCALE_FACTOR_180P: cef_scale_factor_t = 6; +pub const cef_scale_factor_t_SCALE_FACTOR_200P: cef_scale_factor_t = 7; +pub const cef_scale_factor_t_SCALE_FACTOR_250P: cef_scale_factor_t = 8; +pub const cef_scale_factor_t_SCALE_FACTOR_300P: cef_scale_factor_t = 9; +pub type cef_scale_factor_t = ::std::os::raw::c_uint; +pub const cef_plugin_policy_t_PLUGIN_POLICY_ALLOW: cef_plugin_policy_t = 0; +pub const cef_plugin_policy_t_PLUGIN_POLICY_DETECT_IMPORTANT: cef_plugin_policy_t = 1; +pub const cef_plugin_policy_t_PLUGIN_POLICY_BLOCK: cef_plugin_policy_t = 2; +pub const cef_plugin_policy_t_PLUGIN_POLICY_DISABLE: cef_plugin_policy_t = 3; +pub type cef_plugin_policy_t = ::std::os::raw::c_uint; +pub const cef_referrer_policy_t_REFERRER_POLICY_CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE: + cef_referrer_policy_t = 0; +pub const cef_referrer_policy_t_REFERRER_POLICY_DEFAULT: cef_referrer_policy_t = 0; +pub const cef_referrer_policy_t_REFERRER_POLICY_REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN: + cef_referrer_policy_t = 1; +pub const cef_referrer_policy_t_REFERRER_POLICY_ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN: cef_referrer_policy_t = 2; +pub const cef_referrer_policy_t_REFERRER_POLICY_NEVER_CLEAR_REFERRER: cef_referrer_policy_t = 3; +pub const cef_referrer_policy_t_REFERRER_POLICY_ORIGIN: cef_referrer_policy_t = 4; +pub const cef_referrer_policy_t_REFERRER_POLICY_CLEAR_REFERRER_ON_TRANSITION_CROSS_ORIGIN: cef_referrer_policy_t = 5; +pub const cef_referrer_policy_t_REFERRER_POLICY_ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE: + cef_referrer_policy_t = 6; +pub const cef_referrer_policy_t_REFERRER_POLICY_NO_REFERRER: cef_referrer_policy_t = 7; +pub const cef_referrer_policy_t_REFERRER_POLICY_LAST_VALUE: cef_referrer_policy_t = 7; +pub type cef_referrer_policy_t = ::std::os::raw::c_uint; +pub const cef_response_filter_status_t_RESPONSE_FILTER_NEED_MORE_DATA: cef_response_filter_status_t = 0; +pub const cef_response_filter_status_t_RESPONSE_FILTER_DONE: cef_response_filter_status_t = 1; +pub const cef_response_filter_status_t_RESPONSE_FILTER_ERROR: cef_response_filter_status_t = 2; +pub type cef_response_filter_status_t = ::std::os::raw::c_uint; +pub const cef_color_type_t_CEF_COLOR_TYPE_RGBA_8888: cef_color_type_t = 0; +pub const cef_color_type_t_CEF_COLOR_TYPE_BGRA_8888: cef_color_type_t = 1; +pub type cef_color_type_t = ::std::os::raw::c_uint; +pub const cef_alpha_type_t_CEF_ALPHA_TYPE_OPAQUE: cef_alpha_type_t = 0; +pub const cef_alpha_type_t_CEF_ALPHA_TYPE_PREMULTIPLIED: cef_alpha_type_t = 1; +pub const cef_alpha_type_t_CEF_ALPHA_TYPE_POSTMULTIPLIED: cef_alpha_type_t = 2; +pub type cef_alpha_type_t = ::std::os::raw::c_uint; +pub const cef_text_style_t_CEF_TEXT_STYLE_BOLD: cef_text_style_t = 0; +pub const cef_text_style_t_CEF_TEXT_STYLE_ITALIC: cef_text_style_t = 1; +pub const cef_text_style_t_CEF_TEXT_STYLE_STRIKE: cef_text_style_t = 2; +pub const cef_text_style_t_CEF_TEXT_STYLE_DIAGONAL_STRIKE: cef_text_style_t = 3; +pub const cef_text_style_t_CEF_TEXT_STYLE_UNDERLINE: cef_text_style_t = 4; +pub type cef_text_style_t = ::std::os::raw::c_uint; +pub const cef_main_axis_alignment_t_CEF_MAIN_AXIS_ALIGNMENT_START: cef_main_axis_alignment_t = 0; +pub const cef_main_axis_alignment_t_CEF_MAIN_AXIS_ALIGNMENT_CENTER: cef_main_axis_alignment_t = 1; +pub const cef_main_axis_alignment_t_CEF_MAIN_AXIS_ALIGNMENT_END: cef_main_axis_alignment_t = 2; +pub type cef_main_axis_alignment_t = ::std::os::raw::c_uint; +pub const cef_cross_axis_alignment_t_CEF_CROSS_AXIS_ALIGNMENT_STRETCH: cef_cross_axis_alignment_t = 0; +pub const cef_cross_axis_alignment_t_CEF_CROSS_AXIS_ALIGNMENT_START: cef_cross_axis_alignment_t = 1; +pub const cef_cross_axis_alignment_t_CEF_CROSS_AXIS_ALIGNMENT_CENTER: cef_cross_axis_alignment_t = 2; +pub const cef_cross_axis_alignment_t_CEF_CROSS_AXIS_ALIGNMENT_END: cef_cross_axis_alignment_t = 3; +pub type cef_cross_axis_alignment_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_box_layout_settings_t { + pub horizontal: ::std::os::raw::c_int, + pub inside_border_horizontal_spacing: ::std::os::raw::c_int, + pub inside_border_vertical_spacing: ::std::os::raw::c_int, + pub inside_border_insets: cef_insets_t, + pub between_child_spacing: ::std::os::raw::c_int, + pub main_axis_alignment: cef_main_axis_alignment_t, + pub cross_axis_alignment: cef_cross_axis_alignment_t, + pub minimum_cross_axis_size: ::std::os::raw::c_int, + pub default_flex: ::std::os::raw::c_int, +} +pub type cef_box_layout_settings_t = _cef_box_layout_settings_t; +pub const cef_button_state_t_CEF_BUTTON_STATE_NORMAL: cef_button_state_t = 0; +pub const cef_button_state_t_CEF_BUTTON_STATE_HOVERED: cef_button_state_t = 1; +pub const cef_button_state_t_CEF_BUTTON_STATE_PRESSED: cef_button_state_t = 2; +pub const cef_button_state_t_CEF_BUTTON_STATE_DISABLED: cef_button_state_t = 3; +pub type cef_button_state_t = ::std::os::raw::c_uint; +pub const cef_horizontal_alignment_t_CEF_HORIZONTAL_ALIGNMENT_LEFT: cef_horizontal_alignment_t = 0; +pub const cef_horizontal_alignment_t_CEF_HORIZONTAL_ALIGNMENT_CENTER: cef_horizontal_alignment_t = 1; +pub const cef_horizontal_alignment_t_CEF_HORIZONTAL_ALIGNMENT_RIGHT: cef_horizontal_alignment_t = 2; +pub type cef_horizontal_alignment_t = ::std::os::raw::c_uint; +pub const cef_menu_anchor_position_t_CEF_MENU_ANCHOR_TOPLEFT: cef_menu_anchor_position_t = 0; +pub const cef_menu_anchor_position_t_CEF_MENU_ANCHOR_TOPRIGHT: cef_menu_anchor_position_t = 1; +pub const cef_menu_anchor_position_t_CEF_MENU_ANCHOR_BOTTOMCENTER: cef_menu_anchor_position_t = 2; +pub type cef_menu_anchor_position_t = ::std::os::raw::c_uint; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_TEXT: cef_menu_color_type_t = 0; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_TEXT_HOVERED: cef_menu_color_type_t = 1; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_TEXT_ACCELERATOR: cef_menu_color_type_t = 2; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_TEXT_ACCELERATOR_HOVERED: cef_menu_color_type_t = 3; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_BACKGROUND: cef_menu_color_type_t = 4; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_BACKGROUND_HOVERED: cef_menu_color_type_t = 5; +pub const cef_menu_color_type_t_CEF_MENU_COLOR_COUNT: cef_menu_color_type_t = 6; +pub type cef_menu_color_type_t = ::std::os::raw::c_uint; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_UNKNOWN: cef_ssl_version_t = 0; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_SSL2: cef_ssl_version_t = 1; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_SSL3: cef_ssl_version_t = 2; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_TLS1: cef_ssl_version_t = 3; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_TLS1_1: cef_ssl_version_t = 4; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_TLS1_2: cef_ssl_version_t = 5; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_TLS1_3: cef_ssl_version_t = 6; +pub const cef_ssl_version_t_SSL_CONNECTION_VERSION_QUIC: cef_ssl_version_t = 7; +pub type cef_ssl_version_t = ::std::os::raw::c_uint; +pub const cef_ssl_content_status_t_SSL_CONTENT_NORMAL_CONTENT: cef_ssl_content_status_t = 0; +pub const cef_ssl_content_status_t_SSL_CONTENT_DISPLAYED_INSECURE_CONTENT: cef_ssl_content_status_t = 1; +pub const cef_ssl_content_status_t_SSL_CONTENT_RAN_INSECURE_CONTENT: cef_ssl_content_status_t = 2; +pub type cef_ssl_content_status_t = ::std::os::raw::c_uint; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_NONE: cef_scheme_options_t = 0; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_STANDARD: cef_scheme_options_t = 1; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_LOCAL: cef_scheme_options_t = 2; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_DISPLAY_ISOLATED: cef_scheme_options_t = 4; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_SECURE: cef_scheme_options_t = 8; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_CORS_ENABLED: cef_scheme_options_t = 16; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_CSP_BYPASSING: cef_scheme_options_t = 32; +pub const cef_scheme_options_t_CEF_SCHEME_OPTION_FETCH_ENABLED: cef_scheme_options_t = 64; +pub type cef_scheme_options_t = ::std::os::raw::c_uint; +pub const cef_cdm_registration_error_t_CEF_CDM_REGISTRATION_ERROR_NONE: cef_cdm_registration_error_t = 0; +pub const cef_cdm_registration_error_t_CEF_CDM_REGISTRATION_ERROR_INCORRECT_CONTENTS: cef_cdm_registration_error_t = 1; +pub const cef_cdm_registration_error_t_CEF_CDM_REGISTRATION_ERROR_INCOMPATIBLE: cef_cdm_registration_error_t = 2; +pub const cef_cdm_registration_error_t_CEF_CDM_REGISTRATION_ERROR_NOT_SUPPORTED: cef_cdm_registration_error_t = 3; +pub type cef_cdm_registration_error_t = ::std::os::raw::c_uint; +#[repr(C)] +pub struct _cef_composition_underline_t { + pub range: cef_range_t, + pub color: cef_color_t, + pub background_color: cef_color_t, + pub thick: ::std::os::raw::c_int, +} +pub type cef_composition_underline_t = _cef_composition_underline_t; +#[repr(C)] +pub struct _cef_base_ref_counted_t { + pub size: usize, + pub add_ref: ::std::option::Option, + pub release: + ::std::option::Option ::std::os::raw::c_int>, + pub has_one_ref: + ::std::option::Option ::std::os::raw::c_int>, + pub has_at_least_one_ref: + ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_base_ref_counted_t = _cef_base_ref_counted_t; +#[repr(C)] +pub struct _cef_base_scoped_t { + pub size: usize, + pub del: ::std::option::Option, +} +pub type cef_base_scoped_t = _cef_base_scoped_t; +#[repr(C)] +pub struct _cef_auth_callback_t { + pub base: cef_base_ref_counted_t, + pub cont: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_auth_callback_t, + username: *const cef_string_t, + password: *const cef_string_t, + ), + >, + pub cancel: ::std::option::Option, +} +pub type cef_auth_callback_t = _cef_auth_callback_t; +#[repr(C)] +pub struct _cef_request_t { + pub base: cef_base_ref_counted_t, + pub is_read_only: ::std::option::Option ::std::os::raw::c_int>, + pub get_url: ::std::option::Option cef_string_userfree_t>, + pub set_url: ::std::option::Option, + pub get_method: ::std::option::Option cef_string_userfree_t>, + pub set_method: + ::std::option::Option, + pub set_referrer: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_t, + referrer_url: *const cef_string_t, + policy: cef_referrer_policy_t, + ), + >, + pub get_referrer_url: + ::std::option::Option cef_string_userfree_t>, + pub get_referrer_policy: + ::std::option::Option cef_referrer_policy_t>, + pub get_post_data: ::std::option::Option *mut _cef_post_data_t>, + pub set_post_data: + ::std::option::Option, + pub get_header_map: + ::std::option::Option, + pub set_header_map: + ::std::option::Option, + pub get_header_by_name: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_t, name: *const cef_string_t) -> cef_string_userfree_t, + >, + pub set_header_by_name: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_t, + name: *const cef_string_t, + value: *const cef_string_t, + overwrite: ::std::os::raw::c_int, + ), + >, + pub set: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_t, + url: *const cef_string_t, + method: *const cef_string_t, + postData: *mut _cef_post_data_t, + headerMap: cef_string_multimap_t, + ), + >, + pub get_flags: ::std::option::Option ::std::os::raw::c_int>, + pub set_flags: + ::std::option::Option, + pub get_first_party_for_cookies: + ::std::option::Option cef_string_userfree_t>, + pub set_first_party_for_cookies: + ::std::option::Option, + pub get_resource_type: + ::std::option::Option cef_resource_type_t>, + pub get_transition_type: + ::std::option::Option cef_transition_type_t>, + pub get_identifier: ::std::option::Option uint64>, +} +pub type cef_request_t = _cef_request_t; +extern "C" { + pub fn cef_request_create() -> *mut cef_request_t; +} +#[repr(C)] +pub struct _cef_post_data_t { + pub base: cef_base_ref_counted_t, + pub is_read_only: + ::std::option::Option ::std::os::raw::c_int>, + pub has_excluded_elements: + ::std::option::Option ::std::os::raw::c_int>, + pub get_element_count: ::std::option::Option usize>, + pub get_elements: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_post_data_t, + elementsCount: *mut usize, + elements: *mut *mut _cef_post_data_element_t, + ), + >, + pub remove_element: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_post_data_t, + element: *mut _cef_post_data_element_t, + ) -> ::std::os::raw::c_int, + >, + pub add_element: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_post_data_t, + element: *mut _cef_post_data_element_t, + ) -> ::std::os::raw::c_int, + >, + pub remove_elements: ::std::option::Option, +} +pub type cef_post_data_t = _cef_post_data_t; +extern "C" { + pub fn cef_post_data_create() -> *mut cef_post_data_t; +} +#[repr(C)] +pub struct _cef_post_data_element_t { + pub base: cef_base_ref_counted_t, + pub is_read_only: + ::std::option::Option ::std::os::raw::c_int>, + pub set_to_empty: ::std::option::Option, + pub set_to_file: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_post_data_element_t, fileName: *const cef_string_t), + >, + pub set_to_bytes: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_post_data_element_t, size: usize, bytes: *const ::std::os::raw::c_void), + >, + pub get_type: + ::std::option::Option cef_postdataelement_type_t>, + pub get_file: + ::std::option::Option cef_string_userfree_t>, + pub get_bytes_count: ::std::option::Option usize>, + pub get_bytes: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_post_data_element_t, + size: usize, + bytes: *mut ::std::os::raw::c_void, + ) -> usize, + >, +} +pub type cef_post_data_element_t = _cef_post_data_element_t; +extern "C" { + pub fn cef_post_data_element_create() -> *mut cef_post_data_element_t; +} +#[repr(C)] +pub struct _cef_callback_t { + pub base: cef_base_ref_counted_t, + pub cont: ::std::option::Option, + pub cancel: ::std::option::Option, +} +pub type cef_callback_t = _cef_callback_t; +#[repr(C)] +pub struct _cef_completion_callback_t { + pub base: cef_base_ref_counted_t, + pub on_complete: ::std::option::Option, +} +pub type cef_completion_callback_t = _cef_completion_callback_t; +#[repr(C)] +pub struct _cef_cookie_manager_t { + pub base: cef_base_ref_counted_t, + pub set_supported_schemes: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_manager_t, + schemes: cef_string_list_t, + include_defaults: ::std::os::raw::c_int, + callback: *mut _cef_completion_callback_t, + ), + >, + pub visit_all_cookies: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_manager_t, + visitor: *mut _cef_cookie_visitor_t, + ) -> ::std::os::raw::c_int, + >, + pub visit_url_cookies: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_manager_t, + url: *const cef_string_t, + includeHttpOnly: ::std::os::raw::c_int, + visitor: *mut _cef_cookie_visitor_t, + ) -> ::std::os::raw::c_int, + >, + pub set_cookie: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_manager_t, + url: *const cef_string_t, + cookie: *const _cef_cookie_t, + callback: *mut _cef_set_cookie_callback_t, + ) -> ::std::os::raw::c_int, + >, + pub delete_cookies: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_manager_t, + url: *const cef_string_t, + cookie_name: *const cef_string_t, + callback: *mut _cef_delete_cookies_callback_t, + ) -> ::std::os::raw::c_int, + >, + pub flush_store: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_manager_t, + callback: *mut _cef_completion_callback_t, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_cookie_manager_t = _cef_cookie_manager_t; +extern "C" { + pub fn cef_cookie_manager_get_global_manager( + callback: *mut _cef_completion_callback_t, + ) -> *mut cef_cookie_manager_t; +} +#[repr(C)] +pub struct _cef_cookie_visitor_t { + pub base: cef_base_ref_counted_t, + pub visit: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_cookie_visitor_t, + cookie: *const _cef_cookie_t, + count: ::std::os::raw::c_int, + total: ::std::os::raw::c_int, + deleteCookie: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_cookie_visitor_t = _cef_cookie_visitor_t; +#[repr(C)] +pub struct _cef_set_cookie_callback_t { + pub base: cef_base_ref_counted_t, + pub on_complete: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_set_cookie_callback_t, success: ::std::os::raw::c_int), + >, +} +pub type cef_set_cookie_callback_t = _cef_set_cookie_callback_t; +#[repr(C)] +pub struct _cef_delete_cookies_callback_t { + pub base: cef_base_ref_counted_t, + pub on_complete: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_delete_cookies_callback_t, num_deleted: ::std::os::raw::c_int), + >, +} +pub type cef_delete_cookies_callback_t = _cef_delete_cookies_callback_t; +#[repr(C)] +pub struct _cef_value_t { + pub base: cef_base_ref_counted_t, + pub is_valid: ::std::option::Option ::std::os::raw::c_int>, + pub is_owned: ::std::option::Option ::std::os::raw::c_int>, + pub is_read_only: ::std::option::Option ::std::os::raw::c_int>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, that: *mut _cef_value_t) -> ::std::os::raw::c_int, + >, + pub is_equal: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, that: *mut _cef_value_t) -> ::std::os::raw::c_int, + >, + pub copy: ::std::option::Option *mut _cef_value_t>, + pub get_type: ::std::option::Option cef_value_type_t>, + pub get_bool: ::std::option::Option ::std::os::raw::c_int>, + pub get_int: ::std::option::Option ::std::os::raw::c_int>, + pub get_double: ::std::option::Option f64>, + pub get_string: ::std::option::Option cef_string_userfree_t>, + pub get_binary: ::std::option::Option *mut _cef_binary_value_t>, + pub get_dictionary: + ::std::option::Option *mut _cef_dictionary_value_t>, + pub get_list: ::std::option::Option *mut _cef_list_value_t>, + pub set_null: ::std::option::Option ::std::os::raw::c_int>, + pub set_bool: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, value: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub set_int: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, value: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub set_double: + ::std::option::Option ::std::os::raw::c_int>, + pub set_string: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, value: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub set_binary: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, value: *mut _cef_binary_value_t) -> ::std::os::raw::c_int, + >, + pub set_dictionary: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, value: *mut _cef_dictionary_value_t) -> ::std::os::raw::c_int, + >, + pub set_list: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_value_t, value: *mut _cef_list_value_t) -> ::std::os::raw::c_int, + >, +} +pub type cef_value_t = _cef_value_t; +extern "C" { + pub fn cef_value_create() -> *mut cef_value_t; +} +#[repr(C)] +pub struct _cef_binary_value_t { + pub base: cef_base_ref_counted_t, + pub is_valid: ::std::option::Option ::std::os::raw::c_int>, + pub is_owned: ::std::option::Option ::std::os::raw::c_int>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_binary_value_t, that: *mut _cef_binary_value_t) -> ::std::os::raw::c_int, + >, + pub is_equal: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_binary_value_t, that: *mut _cef_binary_value_t) -> ::std::os::raw::c_int, + >, + pub copy: ::std::option::Option *mut _cef_binary_value_t>, + pub get_size: ::std::option::Option usize>, + pub get_data: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_binary_value_t, + buffer: *mut ::std::os::raw::c_void, + buffer_size: usize, + data_offset: usize, + ) -> usize, + >, +} +pub type cef_binary_value_t = _cef_binary_value_t; +extern "C" { + pub fn cef_binary_value_create(data: *const ::std::os::raw::c_void, data_size: usize) -> *mut cef_binary_value_t; +} +#[repr(C)] +pub struct _cef_dictionary_value_t { + pub base: cef_base_ref_counted_t, + pub is_valid: + ::std::option::Option ::std::os::raw::c_int>, + pub is_owned: + ::std::option::Option ::std::os::raw::c_int>, + pub is_read_only: + ::std::option::Option ::std::os::raw::c_int>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + that: *mut _cef_dictionary_value_t, + ) -> ::std::os::raw::c_int, + >, + pub is_equal: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + that: *mut _cef_dictionary_value_t, + ) -> ::std::os::raw::c_int, + >, + pub copy: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + exclude_empty_children: ::std::os::raw::c_int, + ) -> *mut _cef_dictionary_value_t, + >, + pub get_size: ::std::option::Option usize>, + pub clear: + ::std::option::Option ::std::os::raw::c_int>, + pub has_key: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_keys: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, keys: cef_string_list_t) -> ::std::os::raw::c_int, + >, + pub remove: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_type: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> cef_value_type_t, + >, + pub get_value: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> *mut _cef_value_t, + >, + pub get_bool: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_int: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_double: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> f64, + >, + pub get_string: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> cef_string_userfree_t, + >, + pub get_binary: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> *mut _cef_binary_value_t, + >, + pub get_dictionary: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + ) -> *mut _cef_dictionary_value_t, + >, + pub get_list: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> *mut _cef_list_value_t, + >, + pub set_value: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: *mut _cef_value_t, + ) -> ::std::os::raw::c_int, + >, + pub set_null: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_dictionary_value_t, key: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub set_bool: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub set_int: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub set_double: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: f64, + ) -> ::std::os::raw::c_int, + >, + pub set_string: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: *const cef_string_t, + ) -> ::std::os::raw::c_int, + >, + pub set_binary: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: *mut _cef_binary_value_t, + ) -> ::std::os::raw::c_int, + >, + pub set_dictionary: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: *mut _cef_dictionary_value_t, + ) -> ::std::os::raw::c_int, + >, + pub set_list: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_dictionary_value_t, + key: *const cef_string_t, + value: *mut _cef_list_value_t, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_dictionary_value_t = _cef_dictionary_value_t; +extern "C" { + pub fn cef_dictionary_value_create() -> *mut cef_dictionary_value_t; +} +#[repr(C)] +pub struct _cef_list_value_t { + pub base: cef_base_ref_counted_t, + pub is_valid: ::std::option::Option ::std::os::raw::c_int>, + pub is_owned: ::std::option::Option ::std::os::raw::c_int>, + pub is_read_only: + ::std::option::Option ::std::os::raw::c_int>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, that: *mut _cef_list_value_t) -> ::std::os::raw::c_int, + >, + pub is_equal: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, that: *mut _cef_list_value_t) -> ::std::os::raw::c_int, + >, + pub copy: ::std::option::Option *mut _cef_list_value_t>, + pub set_size: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, size: usize) -> ::std::os::raw::c_int, + >, + pub get_size: ::std::option::Option usize>, + pub clear: ::std::option::Option ::std::os::raw::c_int>, + pub remove: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> ::std::os::raw::c_int, + >, + pub get_type: + ::std::option::Option cef_value_type_t>, + pub get_value: + ::std::option::Option *mut _cef_value_t>, + pub get_bool: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> ::std::os::raw::c_int, + >, + pub get_int: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> ::std::os::raw::c_int, + >, + pub get_double: ::std::option::Option f64>, + pub get_string: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> cef_string_userfree_t, + >, + pub get_binary: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> *mut _cef_binary_value_t, + >, + pub get_dictionary: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> *mut _cef_dictionary_value_t, + >, + pub get_list: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> *mut _cef_list_value_t, + >, + pub set_value: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: *mut _cef_value_t, + ) -> ::std::os::raw::c_int, + >, + pub set_null: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize) -> ::std::os::raw::c_int, + >, + pub set_bool: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub set_int: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub set_double: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_list_value_t, index: usize, value: f64) -> ::std::os::raw::c_int, + >, + pub set_string: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: *const cef_string_t, + ) -> ::std::os::raw::c_int, + >, + pub set_binary: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: *mut _cef_binary_value_t, + ) -> ::std::os::raw::c_int, + >, + pub set_dictionary: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: *mut _cef_dictionary_value_t, + ) -> ::std::os::raw::c_int, + >, + pub set_list: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_list_value_t, + index: usize, + value: *mut _cef_list_value_t, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_list_value_t = _cef_list_value_t; +extern "C" { + pub fn cef_list_value_create() -> *mut cef_list_value_t; +} +#[repr(C)] +pub struct _cef_extension_t { + pub base: cef_base_ref_counted_t, + pub get_identifier: + ::std::option::Option cef_string_userfree_t>, + pub get_path: ::std::option::Option cef_string_userfree_t>, + pub get_manifest: + ::std::option::Option *mut _cef_dictionary_value_t>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_extension_t, that: *mut _cef_extension_t) -> ::std::os::raw::c_int, + >, + pub get_handler: + ::std::option::Option *mut _cef_extension_handler_t>, + pub get_loader_context: + ::std::option::Option *mut _cef_request_context_t>, + pub is_loaded: ::std::option::Option ::std::os::raw::c_int>, + pub unload: ::std::option::Option, +} +pub type cef_extension_t = _cef_extension_t; +#[repr(C)] +pub struct _cef_image_t { + pub base: cef_base_ref_counted_t, + pub is_empty: ::std::option::Option ::std::os::raw::c_int>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_image_t, that: *mut _cef_image_t) -> ::std::os::raw::c_int, + >, + pub add_bitmap: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + pixel_width: ::std::os::raw::c_int, + pixel_height: ::std::os::raw::c_int, + color_type: cef_color_type_t, + alpha_type: cef_alpha_type_t, + pixel_data: *const ::std::os::raw::c_void, + pixel_data_size: usize, + ) -> ::std::os::raw::c_int, + >, + pub add_png: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + png_data: *const ::std::os::raw::c_void, + png_data_size: usize, + ) -> ::std::os::raw::c_int, + >, + pub add_jpeg: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + jpeg_data: *const ::std::os::raw::c_void, + jpeg_data_size: usize, + ) -> ::std::os::raw::c_int, + >, + pub get_width: ::std::option::Option usize>, + pub get_height: ::std::option::Option usize>, + pub has_representation: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_image_t, scale_factor: f32) -> ::std::os::raw::c_int, + >, + pub remove_representation: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_image_t, scale_factor: f32) -> ::std::os::raw::c_int, + >, + pub get_representation_info: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + actual_scale_factor: *mut f32, + pixel_width: *mut ::std::os::raw::c_int, + pixel_height: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub get_as_bitmap: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + color_type: cef_color_type_t, + alpha_type: cef_alpha_type_t, + pixel_width: *mut ::std::os::raw::c_int, + pixel_height: *mut ::std::os::raw::c_int, + ) -> *mut _cef_binary_value_t, + >, + pub get_as_png: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + with_transparency: ::std::os::raw::c_int, + pixel_width: *mut ::std::os::raw::c_int, + pixel_height: *mut ::std::os::raw::c_int, + ) -> *mut _cef_binary_value_t, + >, + pub get_as_jpeg: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_image_t, + scale_factor: f32, + quality: ::std::os::raw::c_int, + pixel_width: *mut ::std::os::raw::c_int, + pixel_height: *mut ::std::os::raw::c_int, + ) -> *mut _cef_binary_value_t, + >, +} +pub type cef_image_t = _cef_image_t; +extern "C" { + pub fn cef_image_create() -> *mut cef_image_t; +} +#[repr(C)] +pub struct _cef_read_handler_t { + pub base: cef_base_ref_counted_t, + pub read: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_read_handler_t, + ptr: *mut ::std::os::raw::c_void, + size: usize, + n: usize, + ) -> usize, + >, + pub seek: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_read_handler_t, + offset: int64, + whence: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub tell: ::std::option::Option int64>, + pub eof: ::std::option::Option ::std::os::raw::c_int>, + pub may_block: + ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_read_handler_t = _cef_read_handler_t; +#[repr(C)] +pub struct _cef_stream_reader_t { + pub base: cef_base_ref_counted_t, + pub read: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_stream_reader_t, + ptr: *mut ::std::os::raw::c_void, + size: usize, + n: usize, + ) -> usize, + >, + pub seek: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_stream_reader_t, + offset: int64, + whence: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub tell: ::std::option::Option int64>, + pub eof: ::std::option::Option ::std::os::raw::c_int>, + pub may_block: + ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_stream_reader_t = _cef_stream_reader_t; +extern "C" { + pub fn cef_stream_reader_create_for_file(fileName: *const cef_string_t) -> *mut cef_stream_reader_t; +} +extern "C" { + pub fn cef_stream_reader_create_for_data( + data: *mut ::std::os::raw::c_void, + size: usize, + ) -> *mut cef_stream_reader_t; +} +extern "C" { + pub fn cef_stream_reader_create_for_handler(handler: *mut cef_read_handler_t) -> *mut cef_stream_reader_t; +} +#[repr(C)] +pub struct _cef_write_handler_t { + pub base: cef_base_ref_counted_t, + pub write: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_write_handler_t, + ptr: *const ::std::os::raw::c_void, + size: usize, + n: usize, + ) -> usize, + >, + pub seek: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_write_handler_t, + offset: int64, + whence: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub tell: ::std::option::Option int64>, + pub flush: ::std::option::Option ::std::os::raw::c_int>, + pub may_block: + ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_write_handler_t = _cef_write_handler_t; +#[repr(C)] +pub struct _cef_stream_writer_t { + pub base: cef_base_ref_counted_t, + pub write: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_stream_writer_t, + ptr: *const ::std::os::raw::c_void, + size: usize, + n: usize, + ) -> usize, + >, + pub seek: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_stream_writer_t, + offset: int64, + whence: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub tell: ::std::option::Option int64>, + pub flush: ::std::option::Option ::std::os::raw::c_int>, + pub may_block: + ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_stream_writer_t = _cef_stream_writer_t; +extern "C" { + pub fn cef_stream_writer_create_for_file(fileName: *const cef_string_t) -> *mut cef_stream_writer_t; +} +extern "C" { + pub fn cef_stream_writer_create_for_handler(handler: *mut cef_write_handler_t) -> *mut cef_stream_writer_t; +} +#[repr(C)] +pub struct _cef_drag_data_t { + pub base: cef_base_ref_counted_t, + pub clone: ::std::option::Option *mut _cef_drag_data_t>, + pub is_read_only: + ::std::option::Option ::std::os::raw::c_int>, + pub is_link: ::std::option::Option ::std::os::raw::c_int>, + pub is_fragment: ::std::option::Option ::std::os::raw::c_int>, + pub is_file: ::std::option::Option ::std::os::raw::c_int>, + pub get_link_url: + ::std::option::Option cef_string_userfree_t>, + pub get_link_title: + ::std::option::Option cef_string_userfree_t>, + pub get_link_metadata: + ::std::option::Option cef_string_userfree_t>, + pub get_fragment_text: + ::std::option::Option cef_string_userfree_t>, + pub get_fragment_html: + ::std::option::Option cef_string_userfree_t>, + pub get_fragment_base_url: + ::std::option::Option cef_string_userfree_t>, + pub get_file_name: + ::std::option::Option cef_string_userfree_t>, + pub get_file_contents: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_drag_data_t, writer: *mut _cef_stream_writer_t) -> usize, + >, + pub get_file_names: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_drag_data_t, names: cef_string_list_t) -> ::std::os::raw::c_int, + >, + pub set_link_url: + ::std::option::Option, + pub set_link_title: + ::std::option::Option, + pub set_link_metadata: + ::std::option::Option, + pub set_fragment_text: + ::std::option::Option, + pub set_fragment_html: + ::std::option::Option, + pub set_fragment_base_url: + ::std::option::Option, + pub reset_file_contents: ::std::option::Option, + pub add_file: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_drag_data_t, + path: *const cef_string_t, + display_name: *const cef_string_t, + ), + >, + pub get_image: ::std::option::Option *mut _cef_image_t>, + pub get_image_hotspot: ::std::option::Option cef_point_t>, + pub has_image: ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_drag_data_t = _cef_drag_data_t; +extern "C" { + pub fn cef_drag_data_create() -> *mut cef_drag_data_t; +} +#[repr(C)] +pub struct _cef_domvisitor_t { + pub base: cef_base_ref_counted_t, + pub visit: + ::std::option::Option, +} +pub type cef_domvisitor_t = _cef_domvisitor_t; +#[repr(C)] +pub struct _cef_domdocument_t { + pub base: cef_base_ref_counted_t, + pub get_type: + ::std::option::Option cef_dom_document_type_t>, + pub get_document: + ::std::option::Option *mut _cef_domnode_t>, + pub get_body: ::std::option::Option *mut _cef_domnode_t>, + pub get_head: ::std::option::Option *mut _cef_domnode_t>, + pub get_title: ::std::option::Option cef_string_userfree_t>, + pub get_element_by_id: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_domdocument_t, id: *const cef_string_t) -> *mut _cef_domnode_t, + >, + pub get_focused_node: + ::std::option::Option *mut _cef_domnode_t>, + pub has_selection: + ::std::option::Option ::std::os::raw::c_int>, + pub get_selection_start_offset: + ::std::option::Option ::std::os::raw::c_int>, + pub get_selection_end_offset: + ::std::option::Option ::std::os::raw::c_int>, + pub get_selection_as_markup: + ::std::option::Option cef_string_userfree_t>, + pub get_selection_as_text: + ::std::option::Option cef_string_userfree_t>, + pub get_base_url: + ::std::option::Option cef_string_userfree_t>, + pub get_complete_url: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_domdocument_t, partialURL: *const cef_string_t) -> cef_string_userfree_t, + >, +} +pub type cef_domdocument_t = _cef_domdocument_t; +#[repr(C)] +pub struct _cef_domnode_t { + pub base: cef_base_ref_counted_t, + pub get_type: ::std::option::Option cef_dom_node_type_t>, + pub is_text: ::std::option::Option ::std::os::raw::c_int>, + pub is_element: ::std::option::Option ::std::os::raw::c_int>, + pub is_editable: ::std::option::Option ::std::os::raw::c_int>, + pub is_form_control_element: + ::std::option::Option ::std::os::raw::c_int>, + pub get_form_control_element_type: + ::std::option::Option cef_string_userfree_t>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_domnode_t, that: *mut _cef_domnode_t) -> ::std::os::raw::c_int, + >, + pub get_name: ::std::option::Option cef_string_userfree_t>, + pub get_value: ::std::option::Option cef_string_userfree_t>, + pub set_value: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_domnode_t, value: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_as_markup: ::std::option::Option cef_string_userfree_t>, + pub get_document: + ::std::option::Option *mut _cef_domdocument_t>, + pub get_parent: ::std::option::Option *mut _cef_domnode_t>, + pub get_previous_sibling: + ::std::option::Option *mut _cef_domnode_t>, + pub get_next_sibling: + ::std::option::Option *mut _cef_domnode_t>, + pub has_children: ::std::option::Option ::std::os::raw::c_int>, + pub get_first_child: ::std::option::Option *mut _cef_domnode_t>, + pub get_last_child: ::std::option::Option *mut _cef_domnode_t>, + pub get_element_tag_name: + ::std::option::Option cef_string_userfree_t>, + pub has_element_attributes: + ::std::option::Option ::std::os::raw::c_int>, + pub has_element_attribute: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_domnode_t, attrName: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_element_attribute: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_domnode_t, attrName: *const cef_string_t) -> cef_string_userfree_t, + >, + pub get_element_attributes: + ::std::option::Option, + pub set_element_attribute: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_domnode_t, + attrName: *const cef_string_t, + value: *const cef_string_t, + ) -> ::std::os::raw::c_int, + >, + pub get_element_inner_text: + ::std::option::Option cef_string_userfree_t>, + pub get_element_bounds: ::std::option::Option cef_rect_t>, +} +pub type cef_domnode_t = _cef_domnode_t; +#[repr(C)] +pub struct _cef_process_message_t { + pub base: cef_base_ref_counted_t, + pub is_valid: + ::std::option::Option ::std::os::raw::c_int>, + pub is_read_only: + ::std::option::Option ::std::os::raw::c_int>, + pub copy: + ::std::option::Option *mut _cef_process_message_t>, + pub get_name: + ::std::option::Option cef_string_userfree_t>, + pub get_argument_list: + ::std::option::Option *mut _cef_list_value_t>, +} +pub type cef_process_message_t = _cef_process_message_t; +extern "C" { + pub fn cef_process_message_create(name: *const cef_string_t) -> *mut cef_process_message_t; +} +#[repr(C)] +pub struct _cef_string_visitor_t { + pub base: cef_base_ref_counted_t, + pub visit: + ::std::option::Option, +} +pub type cef_string_visitor_t = _cef_string_visitor_t; +#[repr(C)] +pub struct _cef_v8context_t { + _unused: [u8; 0], +} +#[repr(C)] +pub struct _cef_frame_t { + pub base: cef_base_ref_counted_t, + pub is_valid: ::std::option::Option ::std::os::raw::c_int>, + pub undo: ::std::option::Option, + pub redo: ::std::option::Option, + pub cut: ::std::option::Option, + pub copy: ::std::option::Option, + pub paste: ::std::option::Option, + pub del: ::std::option::Option, + pub select_all: ::std::option::Option, + pub view_source: ::std::option::Option, + pub get_source: + ::std::option::Option, + pub get_text: + ::std::option::Option, + pub load_request: + ::std::option::Option, + pub load_url: ::std::option::Option, + pub execute_java_script: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_frame_t, + code: *const cef_string_t, + script_url: *const cef_string_t, + start_line: ::std::os::raw::c_int, + ), + >, + pub is_main: ::std::option::Option ::std::os::raw::c_int>, + pub is_focused: ::std::option::Option ::std::os::raw::c_int>, + pub get_name: ::std::option::Option cef_string_userfree_t>, + pub get_identifier: ::std::option::Option int64>, + pub get_parent: ::std::option::Option *mut _cef_frame_t>, + pub get_url: ::std::option::Option cef_string_userfree_t>, + pub get_browser: ::std::option::Option *mut _cef_browser_t>, + pub get_v8context: ::std::option::Option *mut _cef_v8context_t>, + pub visit_dom: + ::std::option::Option, + pub create_urlrequest: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_frame_t, + request: *mut _cef_request_t, + client: *mut _cef_urlrequest_client_t, + ) -> *mut _cef_urlrequest_t, + >, + pub send_process_message: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_frame_t, + target_process: cef_process_id_t, + message: *mut _cef_process_message_t, + ), + >, +} +pub type cef_frame_t = _cef_frame_t; +#[repr(C)] +pub struct _cef_x509cert_principal_t { + pub base: cef_base_ref_counted_t, + pub get_display_name: + ::std::option::Option cef_string_userfree_t>, + pub get_common_name: + ::std::option::Option cef_string_userfree_t>, + pub get_locality_name: + ::std::option::Option cef_string_userfree_t>, + pub get_state_or_province_name: + ::std::option::Option cef_string_userfree_t>, + pub get_country_name: + ::std::option::Option cef_string_userfree_t>, + pub get_street_addresses: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_x509cert_principal_t, addresses: cef_string_list_t), + >, + pub get_organization_names: + ::std::option::Option, + pub get_organization_unit_names: + ::std::option::Option, + pub get_domain_components: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_x509cert_principal_t, components: cef_string_list_t), + >, +} +pub type cef_x509cert_principal_t = _cef_x509cert_principal_t; +#[repr(C)] +pub struct _cef_x509certificate_t { + pub base: cef_base_ref_counted_t, + pub get_subject: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_x509certificate_t) -> *mut _cef_x509cert_principal_t, + >, + pub get_issuer: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_x509certificate_t) -> *mut _cef_x509cert_principal_t, + >, + pub get_serial_number: + ::std::option::Option *mut _cef_binary_value_t>, + pub get_valid_start: ::std::option::Option cef_time_t>, + pub get_valid_expiry: ::std::option::Option cef_time_t>, + pub get_derencoded: + ::std::option::Option *mut _cef_binary_value_t>, + pub get_pemencoded: + ::std::option::Option *mut _cef_binary_value_t>, + pub get_issuer_chain_size: ::std::option::Option usize>, + pub get_derencoded_issuer_chain: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_x509certificate_t, + chainCount: *mut usize, + chain: *mut *mut _cef_binary_value_t, + ), + >, + pub get_pemencoded_issuer_chain: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_x509certificate_t, + chainCount: *mut usize, + chain: *mut *mut _cef_binary_value_t, + ), + >, +} +pub type cef_x509certificate_t = _cef_x509certificate_t; +#[repr(C)] +pub struct _cef_sslstatus_t { + pub base: cef_base_ref_counted_t, + pub is_secure_connection: + ::std::option::Option ::std::os::raw::c_int>, + pub get_cert_status: ::std::option::Option cef_cert_status_t>, + pub get_sslversion: ::std::option::Option cef_ssl_version_t>, + pub get_content_status: + ::std::option::Option cef_ssl_content_status_t>, + pub get_x509certificate: + ::std::option::Option *mut _cef_x509certificate_t>, +} +pub type cef_sslstatus_t = _cef_sslstatus_t; +#[repr(C)] +pub struct _cef_navigation_entry_t { + pub base: cef_base_ref_counted_t, + pub is_valid: + ::std::option::Option ::std::os::raw::c_int>, + pub get_url: + ::std::option::Option cef_string_userfree_t>, + pub get_display_url: + ::std::option::Option cef_string_userfree_t>, + pub get_original_url: + ::std::option::Option cef_string_userfree_t>, + pub get_title: + ::std::option::Option cef_string_userfree_t>, + pub get_transition_type: + ::std::option::Option cef_transition_type_t>, + pub has_post_data: + ::std::option::Option ::std::os::raw::c_int>, + pub get_completion_time: + ::std::option::Option cef_time_t>, + pub get_http_status_code: + ::std::option::Option ::std::os::raw::c_int>, + pub get_sslstatus: + ::std::option::Option *mut _cef_sslstatus_t>, +} +pub type cef_navigation_entry_t = _cef_navigation_entry_t; +#[repr(C)] +pub struct _cef_client_t { + _unused: [u8; 0], +} +#[repr(C)] +pub struct _cef_browser_t { + pub base: cef_base_ref_counted_t, + pub get_host: ::std::option::Option *mut _cef_browser_host_t>, + pub can_go_back: ::std::option::Option ::std::os::raw::c_int>, + pub go_back: ::std::option::Option, + pub can_go_forward: + ::std::option::Option ::std::os::raw::c_int>, + pub go_forward: ::std::option::Option, + pub is_loading: ::std::option::Option ::std::os::raw::c_int>, + pub reload: ::std::option::Option, + pub reload_ignore_cache: ::std::option::Option, + pub stop_load: ::std::option::Option, + pub get_identifier: + ::std::option::Option ::std::os::raw::c_int>, + pub is_same: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_browser_t, that: *mut _cef_browser_t) -> ::std::os::raw::c_int, + >, + pub is_popup: ::std::option::Option ::std::os::raw::c_int>, + pub has_document: ::std::option::Option ::std::os::raw::c_int>, + pub get_main_frame: ::std::option::Option *mut _cef_frame_t>, + pub get_focused_frame: ::std::option::Option *mut _cef_frame_t>, + pub get_frame_byident: + ::std::option::Option *mut _cef_frame_t>, + pub get_frame: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_browser_t, name: *const cef_string_t) -> *mut _cef_frame_t, + >, + pub get_frame_count: ::std::option::Option usize>, + pub get_frame_identifiers: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_browser_t, identifiersCount: *mut usize, identifiers: *mut int64), + >, + pub get_frame_names: + ::std::option::Option, +} +pub type cef_browser_t = _cef_browser_t; +#[repr(C)] +pub struct _cef_run_file_dialog_callback_t { + pub base: cef_base_ref_counted_t, + pub on_file_dialog_dismissed: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_run_file_dialog_callback_t, + selected_accept_filter: ::std::os::raw::c_int, + file_paths: cef_string_list_t, + ), + >, +} +pub type cef_run_file_dialog_callback_t = _cef_run_file_dialog_callback_t; +#[repr(C)] +pub struct _cef_navigation_entry_visitor_t { + pub base: cef_base_ref_counted_t, + pub visit: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_navigation_entry_visitor_t, + entry: *mut _cef_navigation_entry_t, + current: ::std::os::raw::c_int, + index: ::std::os::raw::c_int, + total: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_navigation_entry_visitor_t = _cef_navigation_entry_visitor_t; +#[repr(C)] +pub struct _cef_pdf_print_callback_t { + pub base: cef_base_ref_counted_t, + pub on_pdf_print_finished: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_pdf_print_callback_t, + path: *const cef_string_t, + ok: ::std::os::raw::c_int, + ), + >, +} +pub type cef_pdf_print_callback_t = _cef_pdf_print_callback_t; +#[repr(C)] +pub struct _cef_download_image_callback_t { + pub base: cef_base_ref_counted_t, + pub on_download_image_finished: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_download_image_callback_t, + image_url: *const cef_string_t, + http_status_code: ::std::os::raw::c_int, + image: *mut _cef_image_t, + ), + >, +} +pub type cef_download_image_callback_t = _cef_download_image_callback_t; +#[repr(C)] +pub struct _cef_browser_host_t { + pub base: cef_base_ref_counted_t, + pub get_browser: + ::std::option::Option *mut _cef_browser_t>, + pub close_browser: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_browser_host_t, force_close: ::std::os::raw::c_int), + >, + pub try_close_browser: + ::std::option::Option ::std::os::raw::c_int>, + pub set_focus: + ::std::option::Option, + pub get_window_handle: + ::std::option::Option ::std::os::raw::c_ulong>, + pub get_opener_window_handle: + ::std::option::Option ::std::os::raw::c_ulong>, + pub has_view: ::std::option::Option ::std::os::raw::c_int>, + pub get_client: ::std::option::Option *mut _cef_client_t>, + pub get_request_context: + ::std::option::Option *mut _cef_request_context_t>, + pub get_zoom_level: ::std::option::Option f64>, + pub set_zoom_level: ::std::option::Option, + pub run_file_dialog: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + mode: cef_file_dialog_mode_t, + title: *const cef_string_t, + default_file_path: *const cef_string_t, + accept_filters: cef_string_list_t, + selected_accept_filter: ::std::os::raw::c_int, + callback: *mut _cef_run_file_dialog_callback_t, + ), + >, + pub start_download: + ::std::option::Option, + pub download_image: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + image_url: *const cef_string_t, + is_favicon: ::std::os::raw::c_int, + max_image_size: uint32, + bypass_cache: ::std::os::raw::c_int, + callback: *mut _cef_download_image_callback_t, + ), + >, + pub print: ::std::option::Option, + pub print_to_pdf: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + path: *const cef_string_t, + settings: *const _cef_pdf_print_settings_t, + callback: *mut _cef_pdf_print_callback_t, + ), + >, + pub find: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + identifier: ::std::os::raw::c_int, + searchText: *const cef_string_t, + forward: ::std::os::raw::c_int, + matchCase: ::std::os::raw::c_int, + findNext: ::std::os::raw::c_int, + ), + >, + pub stop_finding: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_browser_host_t, clearSelection: ::std::os::raw::c_int), + >, + pub show_dev_tools: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + windowInfo: *const _cef_window_info_t, + client: *mut _cef_client_t, + settings: *const _cef_browser_settings_t, + inspect_element_at: *const cef_point_t, + ), + >, + pub close_dev_tools: ::std::option::Option, + pub has_dev_tools: + ::std::option::Option ::std::os::raw::c_int>, + pub get_navigation_entries: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + visitor: *mut _cef_navigation_entry_visitor_t, + current_only: ::std::os::raw::c_int, + ), + >, + pub set_mouse_cursor_change_disabled: + ::std::option::Option, + pub is_mouse_cursor_change_disabled: + ::std::option::Option ::std::os::raw::c_int>, + pub replace_misspelling: + ::std::option::Option, + pub add_word_to_dictionary: + ::std::option::Option, + pub is_window_rendering_disabled: + ::std::option::Option ::std::os::raw::c_int>, + pub was_resized: ::std::option::Option, + pub was_hidden: + ::std::option::Option, + pub notify_screen_info_changed: ::std::option::Option, + pub invalidate: + ::std::option::Option, + pub send_external_begin_frame: ::std::option::Option, + pub send_key_event: + ::std::option::Option, + pub send_mouse_click_event: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + event: *const _cef_mouse_event_t, + type_: cef_mouse_button_type_t, + mouseUp: ::std::os::raw::c_int, + clickCount: ::std::os::raw::c_int, + ), + >, + pub send_mouse_move_event: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + event: *const _cef_mouse_event_t, + mouseLeave: ::std::os::raw::c_int, + ), + >, + pub send_mouse_wheel_event: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + event: *const _cef_mouse_event_t, + deltaX: ::std::os::raw::c_int, + deltaY: ::std::os::raw::c_int, + ), + >, + pub send_touch_event: + ::std::option::Option, + pub send_focus_event: + ::std::option::Option, + pub send_capture_lost_event: ::std::option::Option, + pub notify_move_or_resize_started: ::std::option::Option, + pub get_windowless_frame_rate: + ::std::option::Option ::std::os::raw::c_int>, + pub set_windowless_frame_rate: + ::std::option::Option, + pub ime_set_composition: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + text: *const cef_string_t, + underlinesCount: usize, + underlines: *const cef_composition_underline_t, + replacement_range: *const cef_range_t, + selection_range: *const cef_range_t, + ), + >, + pub ime_commit_text: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + text: *const cef_string_t, + replacement_range: *const cef_range_t, + relative_cursor_pos: ::std::os::raw::c_int, + ), + >, + pub ime_finish_composing_text: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_browser_host_t, keep_selection: ::std::os::raw::c_int), + >, + pub ime_cancel_composition: ::std::option::Option, + pub drag_target_drag_enter: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + drag_data: *mut _cef_drag_data_t, + event: *const _cef_mouse_event_t, + allowed_ops: cef_drag_operations_mask_t, + ), + >, + pub drag_target_drag_over: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + event: *const _cef_mouse_event_t, + allowed_ops: cef_drag_operations_mask_t, + ), + >, + pub drag_target_drag_leave: ::std::option::Option, + pub drag_target_drop: + ::std::option::Option, + pub drag_source_ended_at: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + op: cef_drag_operations_mask_t, + ), + >, + pub drag_source_system_drag_ended: ::std::option::Option, + pub get_visible_navigation_entry: + ::std::option::Option *mut _cef_navigation_entry_t>, + pub set_accessibility_state: + ::std::option::Option, + pub set_auto_resize_enabled: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_browser_host_t, + enabled: ::std::os::raw::c_int, + min_size: *const cef_size_t, + max_size: *const cef_size_t, + ), + >, + pub get_extension: + ::std::option::Option *mut _cef_extension_t>, + pub is_background_host: + ::std::option::Option ::std::os::raw::c_int>, + pub set_audio_muted: + ::std::option::Option, + pub is_audio_muted: + ::std::option::Option ::std::os::raw::c_int>, +} +pub type cef_browser_host_t = _cef_browser_host_t; +extern "C" { + pub fn cef_browser_host_create_browser( + windowInfo: *const cef_window_info_t, + client: *mut _cef_client_t, + url: *const cef_string_t, + settings: *const _cef_browser_settings_t, + extra_info: *mut _cef_dictionary_value_t, + request_context: *mut _cef_request_context_t, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn cef_browser_host_create_browser_sync( + windowInfo: *const cef_window_info_t, + client: *mut _cef_client_t, + url: *const cef_string_t, + settings: *const _cef_browser_settings_t, + extra_info: *mut _cef_dictionary_value_t, + request_context: *mut _cef_request_context_t, + ) -> *mut cef_browser_t; +} +#[repr(C)] +pub struct _cef_get_extension_resource_callback_t { + pub base: cef_base_ref_counted_t, + pub cont: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_get_extension_resource_callback_t, stream: *mut _cef_stream_reader_t), + >, + pub cancel: ::std::option::Option, +} +pub type cef_get_extension_resource_callback_t = _cef_get_extension_resource_callback_t; +#[repr(C)] +pub struct _cef_extension_handler_t { + pub base: cef_base_ref_counted_t, + pub on_extension_load_failed: + ::std::option::Option, + pub on_extension_loaded: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_extension_handler_t, extension: *mut _cef_extension_t), + >, + pub on_extension_unloaded: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_extension_handler_t, extension: *mut _cef_extension_t), + >, + pub on_before_background_browser: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_extension_handler_t, + extension: *mut _cef_extension_t, + url: *const cef_string_t, + client: *mut *mut _cef_client_t, + settings: *mut _cef_browser_settings_t, + ) -> ::std::os::raw::c_int, + >, + pub on_before_browser: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_extension_handler_t, + extension: *mut _cef_extension_t, + browser: *mut _cef_browser_t, + active_browser: *mut _cef_browser_t, + index: ::std::os::raw::c_int, + url: *const cef_string_t, + active: ::std::os::raw::c_int, + windowInfo: *mut _cef_window_info_t, + client: *mut *mut _cef_client_t, + settings: *mut _cef_browser_settings_t, + ) -> ::std::os::raw::c_int, + >, + pub get_active_browser: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_extension_handler_t, + extension: *mut _cef_extension_t, + browser: *mut _cef_browser_t, + include_incognito: ::std::os::raw::c_int, + ) -> *mut _cef_browser_t, + >, + pub can_access_browser: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_extension_handler_t, + extension: *mut _cef_extension_t, + browser: *mut _cef_browser_t, + include_incognito: ::std::os::raw::c_int, + target_browser: *mut _cef_browser_t, + ) -> ::std::os::raw::c_int, + >, + pub get_extension_resource: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_extension_handler_t, + extension: *mut _cef_extension_t, + browser: *mut _cef_browser_t, + file: *const cef_string_t, + callback: *mut _cef_get_extension_resource_callback_t, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_extension_handler_t = _cef_extension_handler_t; +#[repr(C)] +pub struct _cef_request_context_handler_t { + _unused: [u8; 0], +} +#[repr(C)] +pub struct _cef_scheme_handler_factory_t { + _unused: [u8; 0], +} +#[repr(C)] +pub struct _cef_resolve_callback_t { + pub base: cef_base_ref_counted_t, + pub on_resolve_completed: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_resolve_callback_t, + result: cef_errorcode_t, + resolved_ips: cef_string_list_t, + ), + >, +} +pub type cef_resolve_callback_t = _cef_resolve_callback_t; +#[repr(C)] +pub struct _cef_request_context_t { + pub base: cef_base_ref_counted_t, + pub is_same: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + other: *mut _cef_request_context_t, + ) -> ::std::os::raw::c_int, + >, + pub is_sharing_with: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + other: *mut _cef_request_context_t, + ) -> ::std::os::raw::c_int, + >, + pub is_global: + ::std::option::Option ::std::os::raw::c_int>, + pub get_handler: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t) -> *mut _cef_request_context_handler_t, + >, + pub get_cache_path: + ::std::option::Option cef_string_userfree_t>, + pub get_cookie_manager: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + callback: *mut _cef_completion_callback_t, + ) -> *mut _cef_cookie_manager_t, + >, + pub register_scheme_handler_factory: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + scheme_name: *const cef_string_t, + domain_name: *const cef_string_t, + factory: *mut _cef_scheme_handler_factory_t, + ) -> ::std::os::raw::c_int, + >, + pub clear_scheme_handler_factories: + ::std::option::Option ::std::os::raw::c_int>, + pub purge_plugin_list_cache: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, reload_pages: ::std::os::raw::c_int), + >, + pub has_preference: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, name: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub get_preference: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, name: *const cef_string_t) -> *mut _cef_value_t, + >, + pub get_all_preferences: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + include_defaults: ::std::os::raw::c_int, + ) -> *mut _cef_dictionary_value_t, + >, + pub can_set_preference: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, name: *const cef_string_t) -> ::std::os::raw::c_int, + >, + pub set_preference: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + name: *const cef_string_t, + value: *mut _cef_value_t, + error: *mut cef_string_t, + ) -> ::std::os::raw::c_int, + >, + pub clear_certificate_exceptions: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, callback: *mut _cef_completion_callback_t), + >, + pub clear_http_auth_credentials: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, callback: *mut _cef_completion_callback_t), + >, + pub close_all_connections: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_request_context_t, callback: *mut _cef_completion_callback_t), + >, + pub resolve_host: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + origin: *const cef_string_t, + callback: *mut _cef_resolve_callback_t, + ), + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + root_directory: *const cef_string_t, + manifest: *mut _cef_dictionary_value_t, + handler: *mut _cef_extension_handler_t, + ), + >, + pub did_load_extension: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + extension_id: *const cef_string_t, + ) -> ::std::os::raw::c_int, + >, + pub has_extension: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + extension_id: *const cef_string_t, + ) -> ::std::os::raw::c_int, + >, + pub get_extensions: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + extension_ids: cef_string_list_t, + ) -> ::std::os::raw::c_int, + >, + pub get_extension: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_request_context_t, + extension_id: *const cef_string_t, + ) -> *mut _cef_extension_t, + >, +} +pub type cef_request_context_t = _cef_request_context_t; +extern "C" { + pub fn cef_request_context_get_global_context() -> *mut cef_request_context_t; +} +extern "C" { + pub fn cef_request_context_create_context( + settings: *const _cef_request_context_settings_t, + handler: *mut _cef_request_context_handler_t, + ) -> *mut cef_request_context_t; +} +extern "C" { + pub fn cef_create_context_shared( + other: *mut cef_request_context_t, + handler: *mut _cef_request_context_handler_t, + ) -> *mut cef_request_context_t; +} +#[repr(C)] +pub struct _cef_response_t { + pub base: cef_base_ref_counted_t, + pub is_read_only: ::std::option::Option ::std::os::raw::c_int>, + pub get_error: ::std::option::Option cef_errorcode_t>, + pub set_error: ::std::option::Option, + pub get_status: ::std::option::Option ::std::os::raw::c_int>, + pub set_status: + ::std::option::Option, + pub get_status_text: + ::std::option::Option cef_string_userfree_t>, + pub set_status_text: + ::std::option::Option, + pub get_mime_type: + ::std::option::Option cef_string_userfree_t>, + pub set_mime_type: + ::std::option::Option, + pub get_charset: ::std::option::Option cef_string_userfree_t>, + pub set_charset: + ::std::option::Option, + pub get_header_by_name: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_response_t, name: *const cef_string_t) -> cef_string_userfree_t, + >, + pub set_header_by_name: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_response_t, + name: *const cef_string_t, + value: *const cef_string_t, + overwrite: ::std::os::raw::c_int, + ), + >, + pub get_header_map: + ::std::option::Option, + pub set_header_map: + ::std::option::Option, + pub get_url: ::std::option::Option cef_string_userfree_t>, + pub set_url: ::std::option::Option, +} +pub type cef_response_t = _cef_response_t; +extern "C" { + pub fn cef_response_create() -> *mut cef_response_t; +} +#[repr(C)] +pub struct _cef_urlrequest_t { + pub base: cef_base_ref_counted_t, + pub get_request: ::std::option::Option *mut _cef_request_t>, + pub get_client: + ::std::option::Option *mut _cef_urlrequest_client_t>, + pub get_request_status: + ::std::option::Option cef_urlrequest_status_t>, + pub get_request_error: + ::std::option::Option cef_errorcode_t>, + pub get_response: + ::std::option::Option *mut _cef_response_t>, + pub response_was_cached: + ::std::option::Option ::std::os::raw::c_int>, + pub cancel: ::std::option::Option, +} +pub type cef_urlrequest_t = _cef_urlrequest_t; +extern "C" { + pub fn cef_urlrequest_create( + request: *mut _cef_request_t, + client: *mut _cef_urlrequest_client_t, + request_context: *mut _cef_request_context_t, + ) -> *mut cef_urlrequest_t; +} +#[repr(C)] +pub struct _cef_urlrequest_client_t { + pub base: cef_base_ref_counted_t, + pub on_request_complete: ::std::option::Option< + unsafe extern "C" fn(self_: *mut _cef_urlrequest_client_t, request: *mut _cef_urlrequest_t), + >, + pub on_upload_progress: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_urlrequest_client_t, + request: *mut _cef_urlrequest_t, + current: int64, + total: int64, + ), + >, + pub on_download_progress: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_urlrequest_client_t, + request: *mut _cef_urlrequest_t, + current: int64, + total: int64, + ), + >, + pub on_download_data: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_urlrequest_client_t, + request: *mut _cef_urlrequest_t, + data: *const ::std::os::raw::c_void, + data_length: usize, + ), + >, + pub get_auth_credentials: ::std::option::Option< + unsafe extern "C" fn( + self_: *mut _cef_urlrequest_client_t, + isProxy: ::std::os::raw::c_int, + host: *const cef_string_t, + port: ::std::os::raw::c_int, + realm: *const cef_string_t, + scheme: *const cef_string_t, + callback: *mut _cef_auth_callback_t, + ) -> ::std::os::raw::c_int, + >, +} +pub type cef_urlrequest_client_t = _cef_urlrequest_client_t; +#[repr(C)] +pub struct __locale_data { + pub _address: u8, +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..6e72cbd --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,104 @@ +mod cef_urlrequest_capi; + +use cef_urlrequest_capi::{ + _cef_request_context_t, _cef_request_t, _cef_urlrequest_client_t, cef_string_userfree_utf16_free, cef_urlrequest_t, +}; +use home::home_dir; +use lazy_static::lazy_static; +use libc::{addrinfo, c_char, EAI_FAIL}; +use redhook::{hook, real}; +use regex::Regex; +use serde::Deserialize; +use std::ffi::CStr; +use std::fs::read_to_string; +use std::path::PathBuf; +use std::ptr::null; +use std::slice::from_raw_parts; +use std::string::String; + +#[derive(Deserialize)] +struct Config { + allowlist: Vec, + denylist: Vec, +} + +lazy_static! { + static ref CONFIG: Config = { + let config_paths = vec![ + PathBuf::from("config.toml"), + home_dir().unwrap().join(".config/spotify-adblock/config.toml"), + PathBuf::from("/etc/spotify-adblock/config.toml"), + ]; + + if let Some(path) = config_paths.into_iter().find(|path| path.exists()) { + println!("[*] Config file: {}", path.to_str().unwrap()); + match read_to_string(path) { + Ok(config_string) => match toml::from_str(&config_string) { + Ok(config) => { + return config; + } + Err(error) => { + println!("[*] Error: Parse config file ({})", error); + } + }, + Err(error) => { + println!("[*] Error: Read config file ({})", error); + } + } + } else { + println!("[*] Error: No config file"); + }; + Config { + allowlist: Vec::new(), + denylist: Vec::new(), + } + }; +} + +fn listed(element: &str, regex_list: &Vec) -> bool { + for regex_string in regex_list { + // TODO: only generate each regex once outside of loop + match Regex::new(®ex_string) { + Ok(regex) => { + if regex.is_match(element) { + return true; + } + } + Err(error) => { + println!("[*] Warning: Invalid regex ({})", error); + } + } + } + false +} + +hook! { + unsafe fn getaddrinfo(node: *const c_char, service: *const c_char, hints: *const addrinfo, res: *const *const addrinfo) -> i32 => _getaddrinfo { + let domain = CStr::from_ptr(node).to_str().unwrap(); + + if listed(domain, &CONFIG.allowlist) { + println!("[+] getaddrinfo:\t\t {}", domain); + real!(getaddrinfo)(node, service, hints, res) + } else { + println!("[-] getaddrinfo:\t\t {}", domain); + EAI_FAIL + } + } +} + +hook! { + unsafe fn cef_urlrequest_create(request: *mut _cef_request_t, client: *const _cef_urlrequest_client_t, request_context: *const _cef_request_context_t) -> *const cef_urlrequest_t => _cef_urlrequest_create { + let url_cef = (*request).get_url.unwrap()(request); + let url_utf16 = from_raw_parts((*url_cef).str_, (*url_cef).length as usize); + let url = String::from_utf16(url_utf16).unwrap(); + cef_string_userfree_utf16_free(url_cef); + + if listed(&url, &CONFIG.denylist) { + println!("[-] cef_urlrequest_create:\t {}", url); + null() + } else { + println!("[+] cef_urlrequest_create:\t {}", url); + real!(cef_urlrequest_create)(request, client, request_context) + } + } +}