├── .gitattributes ├── .gitignore ├── Cef2623 ├── include │ ├── base │ │ ├── cef_atomic_ref_count.h │ │ ├── cef_atomicops.h │ │ ├── cef_basictypes.h │ │ ├── cef_bind.h │ │ ├── cef_bind_helpers.h │ │ ├── cef_build.h │ │ ├── cef_callback.h │ │ ├── cef_callback_forward.h │ │ ├── cef_callback_helpers.h │ │ ├── cef_callback_list.h │ │ ├── cef_cancelable_callback.h │ │ ├── cef_lock.h │ │ ├── cef_logging.h │ │ ├── cef_macros.h │ │ ├── cef_move.h │ │ ├── cef_platform_thread.h │ │ ├── cef_ref_counted.h │ │ ├── cef_scoped_ptr.h │ │ ├── cef_string16.h │ │ ├── cef_template_util.h │ │ ├── cef_thread_checker.h │ │ ├── cef_thread_collision_warner.h │ │ ├── cef_trace_event.h │ │ ├── cef_tuple.h │ │ ├── cef_weak_ptr.h │ │ └── internal │ │ │ ├── cef_atomicops_x86_msvc.h │ │ │ ├── cef_bind_internal.h │ │ │ ├── cef_bind_internal_win.h │ │ │ ├── cef_callback_internal.h │ │ │ ├── cef_lock_impl.h │ │ │ ├── cef_raw_scoped_refptr_mismatch_checker.h │ │ │ └── cef_thread_checker_impl.h │ ├── capi │ │ ├── cef_app_capi.h │ │ ├── cef_auth_callback_capi.h │ │ ├── cef_base_capi.h │ │ ├── cef_browser_capi.h │ │ ├── cef_browser_process_handler_capi.h │ │ ├── cef_callback_capi.h │ │ ├── cef_client_capi.h │ │ ├── cef_command_line_capi.h │ │ ├── cef_context_menu_handler_capi.h │ │ ├── cef_cookie_capi.h │ │ ├── cef_dialog_handler_capi.h │ │ ├── cef_display_handler_capi.h │ │ ├── cef_dom_capi.h │ │ ├── cef_download_handler_capi.h │ │ ├── cef_download_item_capi.h │ │ ├── cef_drag_data_capi.h │ │ ├── cef_drag_handler_capi.h │ │ ├── cef_find_handler_capi.h │ │ ├── cef_focus_handler_capi.h │ │ ├── cef_frame_capi.h │ │ ├── cef_geolocation_capi.h │ │ ├── cef_geolocation_handler_capi.h │ │ ├── cef_jsdialog_handler_capi.h │ │ ├── cef_keyboard_handler_capi.h │ │ ├── cef_life_span_handler_capi.h │ │ ├── cef_load_handler_capi.h │ │ ├── cef_menu_model_capi.h │ │ ├── cef_navigation_entry_capi.h │ │ ├── cef_origin_whitelist_capi.h │ │ ├── cef_parser_capi.h │ │ ├── cef_path_util_capi.h │ │ ├── cef_print_handler_capi.h │ │ ├── cef_print_settings_capi.h │ │ ├── cef_process_message_capi.h │ │ ├── cef_process_util_capi.h │ │ ├── cef_render_handler_capi.h │ │ ├── cef_render_process_handler_capi.h │ │ ├── cef_request_capi.h │ │ ├── cef_request_context_capi.h │ │ ├── cef_request_context_handler_capi.h │ │ ├── cef_request_handler_capi.h │ │ ├── cef_resource_bundle_capi.h │ │ ├── cef_resource_bundle_handler_capi.h │ │ ├── cef_resource_handler_capi.h │ │ ├── cef_response_capi.h │ │ ├── cef_response_filter_capi.h │ │ ├── cef_scheme_capi.h │ │ ├── cef_ssl_info_capi.h │ │ ├── cef_stream_capi.h │ │ ├── cef_string_visitor_capi.h │ │ ├── cef_task_capi.h │ │ ├── cef_trace_capi.h │ │ ├── cef_urlrequest_capi.h │ │ ├── cef_v8_capi.h │ │ ├── cef_values_capi.h │ │ ├── cef_web_plugin_capi.h │ │ ├── cef_xml_reader_capi.h │ │ └── cef_zip_reader_capi.h │ ├── cef_app.h │ ├── cef_auth_callback.h │ ├── cef_base.h │ ├── cef_browser.h │ ├── cef_browser_process_handler.h │ ├── cef_callback.h │ ├── cef_client.h │ ├── cef_command_line.h │ ├── cef_context_menu_handler.h │ ├── cef_cookie.h │ ├── cef_dialog_handler.h │ ├── cef_display_handler.h │ ├── cef_dom.h │ ├── cef_download_handler.h │ ├── cef_download_item.h │ ├── cef_drag_data.h │ ├── cef_drag_handler.h │ ├── cef_find_handler.h │ ├── cef_focus_handler.h │ ├── cef_frame.h │ ├── cef_geolocation.h │ ├── cef_geolocation_handler.h │ ├── cef_jsdialog_handler.h │ ├── cef_keyboard_handler.h │ ├── cef_life_span_handler.h │ ├── cef_load_handler.h │ ├── cef_menu_model.h │ ├── cef_navigation_entry.h │ ├── cef_origin_whitelist.h │ ├── cef_pack_resources.h │ ├── cef_pack_strings.h │ ├── cef_parser.h │ ├── cef_path_util.h │ ├── cef_print_handler.h │ ├── cef_print_settings.h │ ├── cef_process_message.h │ ├── cef_process_util.h │ ├── cef_render_handler.h │ ├── cef_render_process_handler.h │ ├── cef_request.h │ ├── cef_request_context.h │ ├── cef_request_context_handler.h │ ├── cef_request_handler.h │ ├── cef_resource_bundle.h │ ├── cef_resource_bundle_handler.h │ ├── cef_resource_handler.h │ ├── cef_response.h │ ├── cef_response_filter.h │ ├── cef_runnable.h │ ├── cef_sandbox_win.h │ ├── cef_scheme.h │ ├── cef_ssl_info.h │ ├── cef_stream.h │ ├── cef_string_visitor.h │ ├── cef_task.h │ ├── cef_trace.h │ ├── cef_urlrequest.h │ ├── cef_v8.h │ ├── cef_values.h │ ├── cef_version.h │ ├── cef_web_plugin.h │ ├── cef_xml_reader.h │ ├── cef_zip_reader.h │ ├── internal │ │ ├── cef_export.h │ │ ├── cef_logging_internal.h │ │ ├── cef_ptr.h │ │ ├── cef_string.h │ │ ├── cef_string_list.h │ │ ├── cef_string_map.h │ │ ├── cef_string_multimap.h │ │ ├── cef_string_types.h │ │ ├── cef_string_wrappers.h │ │ ├── cef_thread_internal.h │ │ ├── cef_time.h │ │ ├── cef_trace_event_internal.h │ │ ├── cef_types.h │ │ ├── cef_types_win.h │ │ ├── cef_types_wrappers.h │ │ └── cef_win.h │ └── wrapper │ │ ├── cef_byte_read_handler.h │ │ ├── cef_closure_task.h │ │ ├── cef_helpers.h │ │ ├── cef_message_router.h │ │ ├── cef_resource_manager.h │ │ ├── cef_stream_resource_handler.h │ │ ├── cef_xml_object.h │ │ └── cef_zip_archive.h ├── lib │ └── libcef.lib ├── libcef_dll │ ├── CMakeLists.txt │ ├── base │ │ ├── cef_atomicops_x86_gcc.cc │ │ ├── cef_bind_helpers.cc │ │ ├── cef_callback_helpers.cc │ │ ├── cef_callback_internal.cc │ │ ├── cef_lock.cc │ │ ├── cef_lock_impl.cc │ │ ├── cef_logging.cc │ │ ├── cef_ref_counted.cc │ │ ├── cef_string16.cc │ │ ├── cef_thread_checker_impl.cc │ │ ├── cef_thread_collision_warner.cc │ │ └── cef_weak_ptr.cc │ ├── cpptoc │ │ ├── app_cpptoc.cc │ │ ├── app_cpptoc.h │ │ ├── base_cpptoc.cc │ │ ├── base_cpptoc.h │ │ ├── browser_process_handler_cpptoc.cc │ │ ├── browser_process_handler_cpptoc.h │ │ ├── client_cpptoc.cc │ │ ├── client_cpptoc.h │ │ ├── completion_callback_cpptoc.cc │ │ ├── completion_callback_cpptoc.h │ │ ├── context_menu_handler_cpptoc.cc │ │ ├── context_menu_handler_cpptoc.h │ │ ├── cookie_visitor_cpptoc.cc │ │ ├── cookie_visitor_cpptoc.h │ │ ├── cpptoc.h │ │ ├── delete_cookies_callback_cpptoc.cc │ │ ├── delete_cookies_callback_cpptoc.h │ │ ├── dialog_handler_cpptoc.cc │ │ ├── dialog_handler_cpptoc.h │ │ ├── display_handler_cpptoc.cc │ │ ├── display_handler_cpptoc.h │ │ ├── domvisitor_cpptoc.cc │ │ ├── domvisitor_cpptoc.h │ │ ├── download_handler_cpptoc.cc │ │ ├── download_handler_cpptoc.h │ │ ├── drag_handler_cpptoc.cc │ │ ├── drag_handler_cpptoc.h │ │ ├── end_tracing_callback_cpptoc.cc │ │ ├── end_tracing_callback_cpptoc.h │ │ ├── find_handler_cpptoc.cc │ │ ├── find_handler_cpptoc.h │ │ ├── focus_handler_cpptoc.cc │ │ ├── focus_handler_cpptoc.h │ │ ├── geolocation_handler_cpptoc.cc │ │ ├── geolocation_handler_cpptoc.h │ │ ├── get_geolocation_callback_cpptoc.cc │ │ ├── get_geolocation_callback_cpptoc.h │ │ ├── jsdialog_handler_cpptoc.cc │ │ ├── jsdialog_handler_cpptoc.h │ │ ├── keyboard_handler_cpptoc.cc │ │ ├── keyboard_handler_cpptoc.h │ │ ├── life_span_handler_cpptoc.cc │ │ ├── life_span_handler_cpptoc.h │ │ ├── load_handler_cpptoc.cc │ │ ├── load_handler_cpptoc.h │ │ ├── navigation_entry_visitor_cpptoc.cc │ │ ├── navigation_entry_visitor_cpptoc.h │ │ ├── pdf_print_callback_cpptoc.cc │ │ ├── pdf_print_callback_cpptoc.h │ │ ├── print_handler_cpptoc.cc │ │ ├── print_handler_cpptoc.h │ │ ├── read_handler_cpptoc.cc │ │ ├── read_handler_cpptoc.h │ │ ├── render_handler_cpptoc.cc │ │ ├── render_handler_cpptoc.h │ │ ├── render_process_handler_cpptoc.cc │ │ ├── render_process_handler_cpptoc.h │ │ ├── request_context_handler_cpptoc.cc │ │ ├── request_context_handler_cpptoc.h │ │ ├── request_handler_cpptoc.cc │ │ ├── request_handler_cpptoc.h │ │ ├── resolve_callback_cpptoc.cc │ │ ├── resolve_callback_cpptoc.h │ │ ├── resource_bundle_handler_cpptoc.cc │ │ ├── resource_bundle_handler_cpptoc.h │ │ ├── resource_handler_cpptoc.cc │ │ ├── resource_handler_cpptoc.h │ │ ├── response_filter_cpptoc.cc │ │ ├── response_filter_cpptoc.h │ │ ├── run_file_dialog_callback_cpptoc.cc │ │ ├── run_file_dialog_callback_cpptoc.h │ │ ├── scheme_handler_factory_cpptoc.cc │ │ ├── scheme_handler_factory_cpptoc.h │ │ ├── set_cookie_callback_cpptoc.cc │ │ ├── set_cookie_callback_cpptoc.h │ │ ├── string_visitor_cpptoc.cc │ │ ├── string_visitor_cpptoc.h │ │ ├── task_cpptoc.cc │ │ ├── task_cpptoc.h │ │ ├── urlrequest_client_cpptoc.cc │ │ ├── urlrequest_client_cpptoc.h │ │ ├── v8accessor_cpptoc.cc │ │ ├── v8accessor_cpptoc.h │ │ ├── v8handler_cpptoc.cc │ │ ├── v8handler_cpptoc.h │ │ ├── web_plugin_info_visitor_cpptoc.cc │ │ ├── web_plugin_info_visitor_cpptoc.h │ │ ├── web_plugin_unstable_callback_cpptoc.cc │ │ ├── web_plugin_unstable_callback_cpptoc.h │ │ ├── write_handler_cpptoc.cc │ │ └── write_handler_cpptoc.h │ ├── ctocpp │ │ ├── auth_callback_ctocpp.cc │ │ ├── auth_callback_ctocpp.h │ │ ├── before_download_callback_ctocpp.cc │ │ ├── before_download_callback_ctocpp.h │ │ ├── binary_value_ctocpp.cc │ │ ├── binary_value_ctocpp.h │ │ ├── browser_ctocpp.cc │ │ ├── browser_ctocpp.h │ │ ├── browser_host_ctocpp.cc │ │ ├── browser_host_ctocpp.h │ │ ├── callback_ctocpp.cc │ │ ├── callback_ctocpp.h │ │ ├── command_line_ctocpp.cc │ │ ├── command_line_ctocpp.h │ │ ├── context_menu_params_ctocpp.cc │ │ ├── context_menu_params_ctocpp.h │ │ ├── cookie_manager_ctocpp.cc │ │ ├── cookie_manager_ctocpp.h │ │ ├── ctocpp.h │ │ ├── dictionary_value_ctocpp.cc │ │ ├── dictionary_value_ctocpp.h │ │ ├── domdocument_ctocpp.cc │ │ ├── domdocument_ctocpp.h │ │ ├── domnode_ctocpp.cc │ │ ├── domnode_ctocpp.h │ │ ├── download_item_callback_ctocpp.cc │ │ ├── download_item_callback_ctocpp.h │ │ ├── download_item_ctocpp.cc │ │ ├── download_item_ctocpp.h │ │ ├── drag_data_ctocpp.cc │ │ ├── drag_data_ctocpp.h │ │ ├── file_dialog_callback_ctocpp.cc │ │ ├── file_dialog_callback_ctocpp.h │ │ ├── frame_ctocpp.cc │ │ ├── frame_ctocpp.h │ │ ├── geolocation_callback_ctocpp.cc │ │ ├── geolocation_callback_ctocpp.h │ │ ├── jsdialog_callback_ctocpp.cc │ │ ├── jsdialog_callback_ctocpp.h │ │ ├── list_value_ctocpp.cc │ │ ├── list_value_ctocpp.h │ │ ├── menu_model_ctocpp.cc │ │ ├── menu_model_ctocpp.h │ │ ├── navigation_entry_ctocpp.cc │ │ ├── navigation_entry_ctocpp.h │ │ ├── post_data_ctocpp.cc │ │ ├── post_data_ctocpp.h │ │ ├── post_data_element_ctocpp.cc │ │ ├── post_data_element_ctocpp.h │ │ ├── print_dialog_callback_ctocpp.cc │ │ ├── print_dialog_callback_ctocpp.h │ │ ├── print_job_callback_ctocpp.cc │ │ ├── print_job_callback_ctocpp.h │ │ ├── print_settings_ctocpp.cc │ │ ├── print_settings_ctocpp.h │ │ ├── process_message_ctocpp.cc │ │ ├── process_message_ctocpp.h │ │ ├── request_callback_ctocpp.cc │ │ ├── request_callback_ctocpp.h │ │ ├── request_context_ctocpp.cc │ │ ├── request_context_ctocpp.h │ │ ├── request_ctocpp.cc │ │ ├── request_ctocpp.h │ │ ├── resource_bundle_ctocpp.cc │ │ ├── resource_bundle_ctocpp.h │ │ ├── response_ctocpp.cc │ │ ├── response_ctocpp.h │ │ ├── run_context_menu_callback_ctocpp.cc │ │ ├── run_context_menu_callback_ctocpp.h │ │ ├── scheme_registrar_ctocpp.cc │ │ ├── scheme_registrar_ctocpp.h │ │ ├── sslcert_principal_ctocpp.cc │ │ ├── sslcert_principal_ctocpp.h │ │ ├── sslinfo_ctocpp.cc │ │ ├── sslinfo_ctocpp.h │ │ ├── stream_reader_ctocpp.cc │ │ ├── stream_reader_ctocpp.h │ │ ├── stream_writer_ctocpp.cc │ │ ├── stream_writer_ctocpp.h │ │ ├── task_runner_ctocpp.cc │ │ ├── task_runner_ctocpp.h │ │ ├── urlrequest_ctocpp.cc │ │ ├── urlrequest_ctocpp.h │ │ ├── v8context_ctocpp.cc │ │ ├── v8context_ctocpp.h │ │ ├── v8exception_ctocpp.cc │ │ ├── v8exception_ctocpp.h │ │ ├── v8stack_frame_ctocpp.cc │ │ ├── v8stack_frame_ctocpp.h │ │ ├── v8stack_trace_ctocpp.cc │ │ ├── v8stack_trace_ctocpp.h │ │ ├── v8value_ctocpp.cc │ │ ├── v8value_ctocpp.h │ │ ├── value_ctocpp.cc │ │ ├── value_ctocpp.h │ │ ├── web_plugin_info_ctocpp.cc │ │ ├── web_plugin_info_ctocpp.h │ │ ├── xml_reader_ctocpp.cc │ │ ├── xml_reader_ctocpp.h │ │ ├── zip_reader_ctocpp.cc │ │ └── zip_reader_ctocpp.h │ ├── transfer_util.cc │ ├── transfer_util.h │ ├── wrapper │ │ ├── cef_browser_info_map.h │ │ ├── cef_byte_read_handler.cc │ │ ├── cef_closure_task.cc │ │ ├── cef_message_router.cc │ │ ├── cef_resource_manager.cc │ │ ├── cef_stream_resource_handler.cc │ │ ├── cef_xml_object.cc │ │ ├── cef_zip_archive.cc │ │ ├── libcef_dll_wrapper.cc │ │ └── libcef_dll_wrapper2.cc │ └── wrapper_types.h └── libcef_dll_wrapper │ ├── ALL_BUILD.vcxproj │ ├── ALL_BUILD.vcxproj.filters │ ├── CMakeCache.txt │ ├── CMakeFiles │ ├── 3.9.0 │ │ ├── CMakeCCompiler.cmake │ │ ├── CMakeCXXCompiler.cmake │ │ ├── CMakeDetermineCompilerABI_C.bin │ │ ├── CMakeDetermineCompilerABI_CXX.bin │ │ ├── CMakeRCCompiler.cmake │ │ ├── CMakeSystem.cmake │ │ ├── CompilerIdC │ │ │ ├── CMakeCCompilerId.c │ │ │ ├── CompilerIdC.exe │ │ │ └── CompilerIdC.vcxproj │ │ ├── CompilerIdCXX │ │ │ ├── CMakeCXXCompilerId.cpp │ │ │ ├── CompilerIdCXX.exe │ │ │ └── CompilerIdCXX.vcxproj │ │ ├── VCTargetsPath.txt │ │ └── VCTargetsPath.vcxproj │ ├── 846baea37f8f402297f043c9b2187413 │ │ └── generate.stamp.rule │ ├── TargetDirectories.txt │ ├── cmake.check_cache │ ├── feature_tests.bin │ ├── feature_tests.cxx │ ├── generate.stamp │ ├── generate.stamp.depend │ └── generate.stamp.list │ ├── Project.sln │ ├── ZERO_CHECK.vcxproj │ ├── ZERO_CHECK.vcxproj.filters │ ├── cmake_install.cmake │ ├── libcef_dll_wrapper.vcxproj │ └── libcef_dll_wrapper.vcxproj.filters ├── Cef3 Soui Demo.sln └── Cef3 Soui Demo ├── Cef3 Soui Demo.cpp ├── Cef3 Soui Demo.rc ├── Cef3 Soui Demo.vcxproj ├── Cef3 Soui Demo.vcxproj.filters ├── CefWebView ├── BrowserHandler.cpp ├── BrowserHandler.h ├── Cef3WebView.cpp ├── Cef3WebView.h ├── CefClientApp.cpp ├── CefClientApp.h ├── CefUtil.cpp ├── CefUtil.h └── ExtendEvents.h ├── MainDlg.cpp ├── MainDlg.h ├── TestHTML └── test.htm ├── WebProcess ├── HTMLEventHandler.cpp ├── HTMLEventHandler.h ├── SubProcessClientApp.cpp ├── SubProcessClientApp.h ├── WebProcess.vcxproj ├── WebProcess.vcxproj.filters └── main.cpp ├── license.txt ├── readme.txt ├── res ├── resource.h └── soui_res.rc2 ├── resource.h ├── stdafx.cpp ├── stdafx.h └── uires ├── image └── soui.ico ├── uidef └── init.xml ├── uires.idx ├── values ├── color.xml ├── skin.xml └── string.xml └── xml └── dlg_main.xml /Cef2623/include/internal/cef_export.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights 2 | // reserved. 3 | // 4 | // Redistribution and use in source and binary forms, with or without 5 | // modification, are permitted provided that the following conditions are 6 | // met: 7 | // 8 | // * Redistributions of source code must retain the above copyright 9 | // notice, this list of conditions and the following disclaimer. 10 | // * Redistributions in binary form must reproduce the above 11 | // copyright notice, this list of conditions and the following disclaimer 12 | // in the documentation and/or other materials provided with the 13 | // distribution. 14 | // * Neither the name of Google Inc. nor the name Chromium Embedded 15 | // Framework nor the names of its contributors may be used to endorse 16 | // or promote products derived from this software without specific prior 17 | // written permission. 18 | // 19 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | 31 | #ifndef CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_ 32 | #define CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_ 33 | #pragma once 34 | 35 | #include "include/base/cef_build.h" 36 | 37 | #if defined(COMPILER_MSVC) 38 | 39 | #ifdef BUILDING_CEF_SHARED 40 | #define CEF_EXPORT __declspec(dllexport) 41 | #elif USING_CEF_SHARED 42 | #define CEF_EXPORT __declspec(dllimport) 43 | #else 44 | #define CEF_EXPORT 45 | #endif 46 | #define CEF_CALLBACK __stdcall 47 | 48 | #elif defined(COMPILER_GCC) 49 | 50 | #define CEF_EXPORT __attribute__ ((visibility("default"))) 51 | #define CEF_CALLBACK 52 | 53 | #endif // COMPILER_GCC 54 | 55 | #endif // CEF_INCLUDE_INTERNAL_CEF_EXPORT_H_ 56 | -------------------------------------------------------------------------------- /Cef2623/lib/libcef.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef2623/lib/libcef.lib -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_bind_helpers.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | #include "include/base/cef_bind_helpers.h" 6 | 7 | #include "include/base/cef_callback.h" 8 | 9 | namespace base { 10 | 11 | void DoNothing() { 12 | } 13 | 14 | } // namespace base 15 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_callback_helpers.cc: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | #include "include/base/cef_callback_helpers.h" 6 | 7 | #include "include/base/cef_callback.h" 8 | 9 | namespace base { 10 | 11 | ScopedClosureRunner::ScopedClosureRunner() { 12 | } 13 | 14 | ScopedClosureRunner::ScopedClosureRunner(const Closure& closure) 15 | : closure_(closure) { 16 | } 17 | 18 | ScopedClosureRunner::~ScopedClosureRunner() { 19 | if (!closure_.is_null()) 20 | closure_.Run(); 21 | } 22 | 23 | void ScopedClosureRunner::Reset() { 24 | Closure old_closure = Release(); 25 | if (!old_closure.is_null()) 26 | old_closure.Run(); 27 | } 28 | 29 | void ScopedClosureRunner::Reset(const Closure& closure) { 30 | Closure old_closure = Release(); 31 | closure_ = closure; 32 | if (!old_closure.is_null()) 33 | old_closure.Run(); 34 | } 35 | 36 | Closure ScopedClosureRunner::Release() { 37 | Closure result = closure_; 38 | closure_.Reset(); 39 | return result; 40 | } 41 | 42 | } // namespace base 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_callback_internal.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | #include "include/base/internal/cef_callback_internal.h" 6 | 7 | #include "include/base/cef_logging.h" 8 | 9 | namespace base { 10 | namespace cef_internal { 11 | 12 | void BindStateBase::AddRef() { 13 | AtomicRefCountInc(&ref_count_); 14 | } 15 | 16 | void BindStateBase::Release() { 17 | if (!AtomicRefCountDec(&ref_count_)) 18 | destructor_(this); 19 | } 20 | 21 | void CallbackBase::Reset() { 22 | polymorphic_invoke_ = NULL; 23 | // NULL the bind_state_ last, since it may be holding the last ref to whatever 24 | // object owns us, and we may be deleted after that. 25 | bind_state_ = NULL; 26 | } 27 | 28 | bool CallbackBase::Equals(const CallbackBase& other) const { 29 | return bind_state_.get() == other.bind_state_.get() && 30 | polymorphic_invoke_ == other.polymorphic_invoke_; 31 | } 32 | 33 | CallbackBase::CallbackBase(BindStateBase* bind_state) 34 | : bind_state_(bind_state), 35 | polymorphic_invoke_(NULL) { 36 | DCHECK(!bind_state_.get() || bind_state_->ref_count_ == 1); 37 | } 38 | 39 | CallbackBase::~CallbackBase() { 40 | } 41 | 42 | } // namespace cef_internal 43 | } // namespace base 44 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_lock.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | // This file is used for debugging assertion support. The Lock class 6 | // is functionally a wrapper around the LockImpl class, so the only 7 | // real intelligence in the class is in the debugging logic. 8 | 9 | #if !defined(NDEBUG) 10 | 11 | #include "include/base/cef_lock.h" 12 | #include "include/base/cef_logging.h" 13 | 14 | namespace base { 15 | 16 | Lock::Lock() : lock_() { 17 | } 18 | 19 | Lock::~Lock() { 20 | DCHECK(owning_thread_ref_.is_null()); 21 | } 22 | 23 | void Lock::AssertAcquired() const { 24 | DCHECK(owning_thread_ref_ == PlatformThread::CurrentRef()); 25 | } 26 | 27 | void Lock::CheckHeldAndUnmark() { 28 | DCHECK(owning_thread_ref_ == PlatformThread::CurrentRef()); 29 | owning_thread_ref_ = PlatformThreadRef(); 30 | } 31 | 32 | void Lock::CheckUnheldAndMark() { 33 | // Hitting this DCHECK means that your code is trying to re-enter a lock that 34 | // is already held. The Chromium Lock implementation is not reentrant. 35 | // See "Why can the holder of a Lock not reacquire it?" at 36 | // http://www.chromium.org/developers/lock-and-condition-variable for more 37 | // information. 38 | DCHECK(owning_thread_ref_.is_null()); 39 | owning_thread_ref_ = PlatformThread::CurrentRef(); 40 | } 41 | 42 | } // namespace base 43 | 44 | #endif // NDEBUG 45 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_ref_counted.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | #include "include/base/cef_ref_counted.h" 6 | #include "include/base/cef_thread_collision_warner.h" 7 | 8 | namespace base { 9 | 10 | namespace cef_subtle { 11 | 12 | bool RefCountedThreadSafeBase::HasOneRef() const { 13 | return AtomicRefCountIsOne( 14 | &const_cast(this)->ref_count_); 15 | } 16 | 17 | RefCountedThreadSafeBase::RefCountedThreadSafeBase() : ref_count_(0) { 18 | #ifndef NDEBUG 19 | in_dtor_ = false; 20 | #endif 21 | } 22 | 23 | RefCountedThreadSafeBase::~RefCountedThreadSafeBase() { 24 | #ifndef NDEBUG 25 | DCHECK(in_dtor_) << "RefCountedThreadSafe object deleted without " 26 | "calling Release()"; 27 | #endif 28 | } 29 | 30 | void RefCountedThreadSafeBase::AddRef() const { 31 | #ifndef NDEBUG 32 | DCHECK(!in_dtor_); 33 | #endif 34 | AtomicRefCountInc(&ref_count_); 35 | } 36 | 37 | bool RefCountedThreadSafeBase::Release() const { 38 | #ifndef NDEBUG 39 | DCHECK(!in_dtor_); 40 | DCHECK(!AtomicRefCountIsZero(&ref_count_)); 41 | #endif 42 | if (!AtomicRefCountDec(&ref_count_)) { 43 | #ifndef NDEBUG 44 | in_dtor_ = true; 45 | #endif 46 | return true; 47 | } 48 | return false; 49 | } 50 | 51 | } // namespace cef_subtle 52 | 53 | } // namespace base 54 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_thread_checker_impl.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | #include "include/base/internal/cef_thread_checker_impl.h" 6 | 7 | namespace base { 8 | namespace cef_internal { 9 | 10 | ThreadCheckerImpl::ThreadCheckerImpl() 11 | : valid_thread_id_() { 12 | EnsureThreadIdAssigned(); 13 | } 14 | 15 | ThreadCheckerImpl::~ThreadCheckerImpl() {} 16 | 17 | bool ThreadCheckerImpl::CalledOnValidThread() const { 18 | EnsureThreadIdAssigned(); 19 | AutoLock auto_lock(lock_); 20 | return valid_thread_id_ == PlatformThread::CurrentRef(); 21 | } 22 | 23 | void ThreadCheckerImpl::DetachFromThread() { 24 | AutoLock auto_lock(lock_); 25 | valid_thread_id_ = PlatformThreadRef(); 26 | } 27 | 28 | void ThreadCheckerImpl::EnsureThreadIdAssigned() const { 29 | AutoLock auto_lock(lock_); 30 | if (valid_thread_id_.is_null()) { 31 | valid_thread_id_ = PlatformThread::CurrentRef(); 32 | } 33 | } 34 | 35 | } // namespace cef_internal 36 | } // namespace base 37 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/base/cef_weak_ptr.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | #include "include/base/cef_weak_ptr.h" 6 | 7 | namespace base { 8 | namespace cef_internal { 9 | 10 | WeakReference::Flag::Flag() : is_valid_(true) { 11 | // Flags only become bound when checked for validity, or invalidated, 12 | // so that we can check that later validity/invalidation operations on 13 | // the same Flag take place on the same thread. 14 | thread_checker_.DetachFromThread(); 15 | } 16 | 17 | void WeakReference::Flag::Invalidate() { 18 | // The flag being invalidated with a single ref implies that there are no 19 | // weak pointers in existence. Allow deletion on other thread in this case. 20 | DCHECK(thread_checker_.CalledOnValidThread() || HasOneRef()) 21 | << "WeakPtrs must be invalidated on the same thread."; 22 | is_valid_ = false; 23 | } 24 | 25 | bool WeakReference::Flag::IsValid() const { 26 | DCHECK(thread_checker_.CalledOnValidThread()) 27 | << "WeakPtrs must be checked on the same thread."; 28 | return is_valid_; 29 | } 30 | 31 | WeakReference::Flag::~Flag() { 32 | } 33 | 34 | WeakReference::WeakReference() { 35 | } 36 | 37 | WeakReference::WeakReference(const Flag* flag) : flag_(flag) { 38 | } 39 | 40 | WeakReference::~WeakReference() { 41 | } 42 | 43 | bool WeakReference::is_valid() const { return flag_.get() && flag_->IsValid(); } 44 | 45 | WeakReferenceOwner::WeakReferenceOwner() { 46 | } 47 | 48 | WeakReferenceOwner::~WeakReferenceOwner() { 49 | Invalidate(); 50 | } 51 | 52 | WeakReference WeakReferenceOwner::GetRef() const { 53 | // If we hold the last reference to the Flag then create a new one. 54 | if (!HasRefs()) 55 | flag_ = new WeakReference::Flag(); 56 | 57 | return WeakReference(flag_.get()); 58 | } 59 | 60 | void WeakReferenceOwner::Invalidate() { 61 | if (flag_.get()) { 62 | flag_->Invalidate(); 63 | flag_ = NULL; 64 | } 65 | } 66 | 67 | WeakPtrBase::WeakPtrBase() { 68 | } 69 | 70 | WeakPtrBase::~WeakPtrBase() { 71 | } 72 | 73 | WeakPtrBase::WeakPtrBase(const WeakReference& ref) : ref_(ref) { 74 | } 75 | 76 | } // namespace cef_internal 77 | } // namespace base 78 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/app_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_APP_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_APP_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_app.h" 22 | #include "include/capi/cef_app_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefAppCppToC 28 | : public CefCppToC { 29 | public: 30 | CefAppCppToC(); 31 | }; 32 | 33 | #endif // USING_CEF_SHARED 34 | #endif // CEF_LIBCEF_DLL_CPPTOC_APP_CPPTOC_H_ 35 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/base_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #include "libcef_dll/cpptoc/base_cpptoc.h" 6 | 7 | CefBaseCppToC::CefBaseCppToC() { 8 | } 9 | 10 | template<> CefRefPtr CefCppToC:: 11 | UnwrapDerived(CefWrapperType type, cef_base_t* s) { 12 | NOTREACHED(); 13 | return NULL; 14 | } 15 | 16 | #ifndef NDEBUG 17 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 19 | #endif 20 | 21 | template<> CefWrapperType CefCppToC:: 22 | kWrapperType = WT_BASE; 23 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/base_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #ifndef CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_ 6 | #define CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_ 7 | #pragma once 8 | 9 | #include "include/cef_base.h" 10 | #include "include/capi/cef_base_capi.h" 11 | #include "libcef_dll/cpptoc/cpptoc.h" 12 | 13 | #ifndef USING_CEF_SHARED 14 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 15 | #else // USING_CEF_SHARED 16 | 17 | // Wrap a C++ class with a C structure. 18 | class CefBaseCppToC 19 | : public CefCppToC { 20 | public: 21 | CefBaseCppToC(); 22 | }; 23 | 24 | #endif // USING_CEF_SHARED 25 | #endif // CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_ 26 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/browser_process_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_BROWSER_PROCESS_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_BROWSER_PROCESS_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_browser_process_handler.h" 22 | #include "include/capi/cef_browser_process_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefBrowserProcessHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefBrowserProcessHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_BROWSER_PROCESS_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/client_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_CLIENT_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_CLIENT_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_client.h" 22 | #include "include/capi/cef_client_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefClientCppToC 28 | : public CefCppToC { 29 | public: 30 | CefClientCppToC(); 31 | }; 32 | 33 | #endif // USING_CEF_SHARED 34 | #endif // CEF_LIBCEF_DLL_CPPTOC_CLIENT_CPPTOC_H_ 35 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/completion_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/completion_callback_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK completion_callback_on_complete( 21 | struct _cef_completion_callback_t* self) { 22 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 23 | 24 | DCHECK(self); 25 | if (!self) 26 | return; 27 | 28 | // Execute 29 | CefCompletionCallbackCppToC::Get(self)->OnComplete(); 30 | } 31 | 32 | } // namespace 33 | 34 | 35 | // CONSTRUCTOR - Do not edit by hand. 36 | 37 | CefCompletionCallbackCppToC::CefCompletionCallbackCppToC() { 38 | GetStruct()->on_complete = completion_callback_on_complete; 39 | } 40 | 41 | template<> CefRefPtr CefCppToC::UnwrapDerived( 43 | CefWrapperType type, cef_completion_callback_t* s) { 44 | NOTREACHED() << "Unexpected class type: " << type; 45 | return NULL; 46 | } 47 | 48 | #ifndef NDEBUG 49 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 51 | #endif 52 | 53 | template<> CefWrapperType CefCppToC::kWrapperType = 55 | WT_COMPLETION_CALLBACK; 56 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/completion_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_COMPLETION_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_COMPLETION_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_callback.h" 22 | #include "include/capi/cef_callback_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefCompletionCallbackCppToC 28 | : public CefCppToC { 30 | public: 31 | CefCompletionCallbackCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_COMPLETION_CALLBACK_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/context_menu_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_CONTEXT_MENU_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_CONTEXT_MENU_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_context_menu_handler.h" 22 | #include "include/capi/cef_context_menu_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefContextMenuHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefContextMenuHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_CONTEXT_MENU_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/cookie_visitor_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_COOKIE_VISITOR_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_COOKIE_VISITOR_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_cookie.h" 22 | #include "include/capi/cef_cookie_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefCookieVisitorCppToC 28 | : public CefCppToC { 30 | public: 31 | CefCookieVisitorCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_COOKIE_VISITOR_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/delete_cookies_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/delete_cookies_callback_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK delete_cookies_callback_on_complete( 21 | struct _cef_delete_cookies_callback_t* self, int num_deleted) { 22 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 23 | 24 | DCHECK(self); 25 | if (!self) 26 | return; 27 | 28 | // Execute 29 | CefDeleteCookiesCallbackCppToC::Get(self)->OnComplete( 30 | num_deleted); 31 | } 32 | 33 | } // namespace 34 | 35 | 36 | // CONSTRUCTOR - Do not edit by hand. 37 | 38 | CefDeleteCookiesCallbackCppToC::CefDeleteCookiesCallbackCppToC() { 39 | GetStruct()->on_complete = delete_cookies_callback_on_complete; 40 | } 41 | 42 | template<> CefRefPtr CefCppToC::UnwrapDerived( 44 | CefWrapperType type, cef_delete_cookies_callback_t* s) { 45 | NOTREACHED() << "Unexpected class type: " << type; 46 | return NULL; 47 | } 48 | 49 | #ifndef NDEBUG 50 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 52 | #endif 53 | 54 | template<> CefWrapperType CefCppToC::kWrapperType = 56 | WT_DELETE_COOKIES_CALLBACK; 57 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/delete_cookies_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_DELETE_COOKIES_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_DELETE_COOKIES_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_cookie.h" 22 | #include "include/capi/cef_cookie_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDeleteCookiesCallbackCppToC 28 | : public CefCppToC { 30 | public: 31 | CefDeleteCookiesCallbackCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_DELETE_COOKIES_CALLBACK_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/dialog_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_DIALOG_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_DIALOG_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_dialog_handler.h" 22 | #include "include/capi/cef_dialog_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDialogHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefDialogHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_DIALOG_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/display_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_DISPLAY_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_DISPLAY_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_display_handler.h" 22 | #include "include/capi/cef_display_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDisplayHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefDisplayHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_DISPLAY_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/domvisitor_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/domvisitor_cpptoc.h" 14 | #include "libcef_dll/ctocpp/domdocument_ctocpp.h" 15 | 16 | 17 | namespace { 18 | 19 | // MEMBER FUNCTIONS - Body may be edited by hand. 20 | 21 | void CEF_CALLBACK domvisitor_visit(struct _cef_domvisitor_t* self, 22 | struct _cef_domdocument_t* document) { 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | DCHECK(self); 26 | if (!self) 27 | return; 28 | // Verify param: document; type: refptr_diff 29 | DCHECK(document); 30 | if (!document) 31 | return; 32 | 33 | // Execute 34 | CefDOMVisitorCppToC::Get(self)->Visit( 35 | CefDOMDocumentCToCpp::Wrap(document)); 36 | } 37 | 38 | } // namespace 39 | 40 | 41 | // CONSTRUCTOR - Do not edit by hand. 42 | 43 | CefDOMVisitorCppToC::CefDOMVisitorCppToC() { 44 | GetStruct()->visit = domvisitor_visit; 45 | } 46 | 47 | template<> CefRefPtr CefCppToC::UnwrapDerived(CefWrapperType type, 49 | cef_domvisitor_t* s) { 50 | NOTREACHED() << "Unexpected class type: " << type; 51 | return NULL; 52 | } 53 | 54 | #ifndef NDEBUG 55 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 57 | #endif 58 | 59 | template<> CefWrapperType CefCppToC::kWrapperType = WT_DOMVISITOR; 61 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/domvisitor_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_DOMVISITOR_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_DOMVISITOR_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_dom.h" 22 | #include "include/capi/cef_dom_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDOMVisitorCppToC 28 | : public CefCppToC { 29 | public: 30 | CefDOMVisitorCppToC(); 31 | }; 32 | 33 | #endif // USING_CEF_SHARED 34 | #endif // CEF_LIBCEF_DLL_CPPTOC_DOMVISITOR_CPPTOC_H_ 35 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/download_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_DOWNLOAD_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_DOWNLOAD_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_download_handler.h" 22 | #include "include/capi/cef_download_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDownloadHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefDownloadHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_DOWNLOAD_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/drag_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_DRAG_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_DRAG_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_drag_handler.h" 22 | #include "include/capi/cef_drag_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDragHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefDragHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_DRAG_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/end_tracing_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/end_tracing_callback_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK end_tracing_callback_on_end_tracing_complete( 21 | struct _cef_end_tracing_callback_t* self, 22 | const cef_string_t* tracing_file) { 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | DCHECK(self); 26 | if (!self) 27 | return; 28 | // Verify param: tracing_file; type: string_byref_const 29 | DCHECK(tracing_file); 30 | if (!tracing_file) 31 | return; 32 | 33 | // Execute 34 | CefEndTracingCallbackCppToC::Get(self)->OnEndTracingComplete( 35 | CefString(tracing_file)); 36 | } 37 | 38 | } // namespace 39 | 40 | 41 | // CONSTRUCTOR - Do not edit by hand. 42 | 43 | CefEndTracingCallbackCppToC::CefEndTracingCallbackCppToC() { 44 | GetStruct()->on_end_tracing_complete = 45 | end_tracing_callback_on_end_tracing_complete; 46 | } 47 | 48 | template<> CefRefPtr CefCppToC::UnwrapDerived( 50 | CefWrapperType type, cef_end_tracing_callback_t* s) { 51 | NOTREACHED() << "Unexpected class type: " << type; 52 | return NULL; 53 | } 54 | 55 | #ifndef NDEBUG 56 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 58 | #endif 59 | 60 | template<> CefWrapperType CefCppToC::kWrapperType = 62 | WT_END_TRACING_CALLBACK; 63 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/end_tracing_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_END_TRACING_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_END_TRACING_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_trace.h" 22 | #include "include/capi/cef_trace_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefEndTracingCallbackCppToC 28 | : public CefCppToC { 30 | public: 31 | CefEndTracingCallbackCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_END_TRACING_CALLBACK_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/find_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_FIND_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_FIND_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_find_handler.h" 22 | #include "include/capi/cef_find_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefFindHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefFindHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_FIND_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/focus_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_FOCUS_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_FOCUS_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_focus_handler.h" 22 | #include "include/capi/cef_focus_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefFocusHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefFocusHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_FOCUS_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/geolocation_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_GEOLOCATION_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_GEOLOCATION_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_geolocation_handler.h" 22 | #include "include/capi/cef_geolocation_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefGeolocationHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefGeolocationHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_GEOLOCATION_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_geolocation.h" 22 | #include "include/capi/cef_geolocation_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefGetGeolocationCallbackCppToC 28 | : public CefCppToC { 30 | public: 31 | CefGetGeolocationCallbackCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/jsdialog_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_JSDIALOG_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_JSDIALOG_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_jsdialog_handler.h" 22 | #include "include/capi/cef_jsdialog_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefJSDialogHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefJSDialogHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_JSDIALOG_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/keyboard_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_KEYBOARD_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_KEYBOARD_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_keyboard_handler.h" 22 | #include "include/capi/cef_keyboard_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefKeyboardHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefKeyboardHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_KEYBOARD_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/life_span_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_LIFE_SPAN_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_LIFE_SPAN_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_life_span_handler.h" 22 | #include "include/capi/cef_life_span_handler_capi.h" 23 | #include "include/cef_client.h" 24 | #include "include/capi/cef_client_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefLifeSpanHandlerCppToC 30 | : public CefCppToC { 32 | public: 33 | CefLifeSpanHandlerCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_LIFE_SPAN_HANDLER_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/load_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_LOAD_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_LOAD_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_load_handler.h" 22 | #include "include/capi/cef_load_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefLoadHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefLoadHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_LOAD_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_NAVIGATION_ENTRY_VISITOR_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_NAVIGATION_ENTRY_VISITOR_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_browser.h" 22 | #include "include/capi/cef_browser_capi.h" 23 | #include "include/cef_client.h" 24 | #include "include/capi/cef_client_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefNavigationEntryVisitorCppToC 30 | : public CefCppToC { 32 | public: 33 | CefNavigationEntryVisitorCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_NAVIGATION_ENTRY_VISITOR_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/pdf_print_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/pdf_print_callback_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK pdf_print_callback_on_pdf_print_finished( 21 | struct _cef_pdf_print_callback_t* self, const cef_string_t* path, int ok) { 22 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 23 | 24 | DCHECK(self); 25 | if (!self) 26 | return; 27 | // Verify param: path; type: string_byref_const 28 | DCHECK(path); 29 | if (!path) 30 | return; 31 | 32 | // Execute 33 | CefPdfPrintCallbackCppToC::Get(self)->OnPdfPrintFinished( 34 | CefString(path), 35 | ok?true:false); 36 | } 37 | 38 | } // namespace 39 | 40 | 41 | // CONSTRUCTOR - Do not edit by hand. 42 | 43 | CefPdfPrintCallbackCppToC::CefPdfPrintCallbackCppToC() { 44 | GetStruct()->on_pdf_print_finished = pdf_print_callback_on_pdf_print_finished; 45 | } 46 | 47 | template<> CefRefPtr CefCppToC::UnwrapDerived( 49 | CefWrapperType type, cef_pdf_print_callback_t* s) { 50 | NOTREACHED() << "Unexpected class type: " << type; 51 | return NULL; 52 | } 53 | 54 | #ifndef NDEBUG 55 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 57 | #endif 58 | 59 | template<> CefWrapperType CefCppToC::kWrapperType = 61 | WT_PDF_PRINT_CALLBACK; 62 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/pdf_print_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_PDF_PRINT_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_PDF_PRINT_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_browser.h" 22 | #include "include/capi/cef_browser_capi.h" 23 | #include "include/cef_client.h" 24 | #include "include/capi/cef_client_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefPdfPrintCallbackCppToC 30 | : public CefCppToC { 32 | public: 33 | CefPdfPrintCallbackCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_PDF_PRINT_CALLBACK_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/print_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_PRINT_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_PRINT_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_print_handler.h" 22 | #include "include/capi/cef_print_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefPrintHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefPrintHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_PRINT_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/read_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_READ_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_READ_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_stream.h" 22 | #include "include/capi/cef_stream_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefReadHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefReadHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_READ_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/render_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RENDER_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RENDER_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_render_handler.h" 22 | #include "include/capi/cef_render_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefRenderHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefRenderHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_RENDER_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/render_process_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RENDER_PROCESS_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RENDER_PROCESS_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_render_process_handler.h" 22 | #include "include/capi/cef_render_process_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefRenderProcessHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefRenderProcessHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_RENDER_PROCESS_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/request_context_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_REQUEST_CONTEXT_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_REQUEST_CONTEXT_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_request_context_handler.h" 22 | #include "include/capi/cef_request_context_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefRequestContextHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefRequestContextHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_REQUEST_CONTEXT_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/request_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_REQUEST_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_REQUEST_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_request_handler.h" 22 | #include "include/capi/cef_request_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefRequestHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefRequestHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_REQUEST_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/resolve_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/resolve_callback_cpptoc.h" 14 | #include "libcef_dll/transfer_util.h" 15 | 16 | 17 | namespace { 18 | 19 | // MEMBER FUNCTIONS - Body may be edited by hand. 20 | 21 | void CEF_CALLBACK resolve_callback_on_resolve_completed( 22 | struct _cef_resolve_callback_t* self, cef_errorcode_t result, 23 | cef_string_list_t resolved_ips) { 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | DCHECK(self); 27 | if (!self) 28 | return; 29 | // Unverified params: resolved_ips 30 | 31 | // Translate param: resolved_ips; type: string_vec_byref_const 32 | std::vector resolved_ipsList; 33 | transfer_string_list_contents(resolved_ips, resolved_ipsList); 34 | 35 | // Execute 36 | CefResolveCallbackCppToC::Get(self)->OnResolveCompleted( 37 | result, 38 | resolved_ipsList); 39 | } 40 | 41 | } // namespace 42 | 43 | 44 | // CONSTRUCTOR - Do not edit by hand. 45 | 46 | CefResolveCallbackCppToC::CefResolveCallbackCppToC() { 47 | GetStruct()->on_resolve_completed = resolve_callback_on_resolve_completed; 48 | } 49 | 50 | template<> CefRefPtr CefCppToC::UnwrapDerived( 52 | CefWrapperType type, cef_resolve_callback_t* s) { 53 | NOTREACHED() << "Unexpected class type: " << type; 54 | return NULL; 55 | } 56 | 57 | #ifndef NDEBUG 58 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 60 | #endif 61 | 62 | template<> CefWrapperType CefCppToC::kWrapperType = 64 | WT_RESOLVE_CALLBACK; 65 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/resolve_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RESOLVE_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RESOLVE_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_request_context.h" 22 | #include "include/capi/cef_request_context_capi.h" 23 | #include "include/cef_scheme.h" 24 | #include "include/capi/cef_scheme_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefResolveCallbackCppToC 30 | : public CefCppToC { 32 | public: 33 | CefResolveCallbackCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_RESOLVE_CALLBACK_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RESOURCE_BUNDLE_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RESOURCE_BUNDLE_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_resource_bundle_handler.h" 22 | #include "include/capi/cef_resource_bundle_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefResourceBundleHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefResourceBundleHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_RESOURCE_BUNDLE_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/resource_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RESOURCE_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RESOURCE_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_resource_handler.h" 22 | #include "include/capi/cef_resource_handler_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefResourceHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefResourceHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_RESOURCE_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/response_filter_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RESPONSE_FILTER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RESPONSE_FILTER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_response_filter.h" 22 | #include "include/capi/cef_response_filter_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefResponseFilterCppToC 28 | : public CefCppToC { 30 | public: 31 | CefResponseFilterCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_RESPONSE_FILTER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/run_file_dialog_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_RUN_FILE_DIALOG_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_RUN_FILE_DIALOG_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_browser.h" 22 | #include "include/capi/cef_browser_capi.h" 23 | #include "include/cef_client.h" 24 | #include "include/capi/cef_client_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefRunFileDialogCallbackCppToC 30 | : public CefCppToC { 32 | public: 33 | CefRunFileDialogCallbackCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_RUN_FILE_DIALOG_CALLBACK_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/scheme_handler_factory_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_SCHEME_HANDLER_FACTORY_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_SCHEME_HANDLER_FACTORY_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_scheme.h" 22 | #include "include/capi/cef_scheme_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefSchemeHandlerFactoryCppToC 28 | : public CefCppToC { 30 | public: 31 | CefSchemeHandlerFactoryCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_SCHEME_HANDLER_FACTORY_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/set_cookie_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/set_cookie_callback_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK set_cookie_callback_on_complete( 21 | struct _cef_set_cookie_callback_t* self, int success) { 22 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 23 | 24 | DCHECK(self); 25 | if (!self) 26 | return; 27 | 28 | // Execute 29 | CefSetCookieCallbackCppToC::Get(self)->OnComplete( 30 | success?true:false); 31 | } 32 | 33 | } // namespace 34 | 35 | 36 | // CONSTRUCTOR - Do not edit by hand. 37 | 38 | CefSetCookieCallbackCppToC::CefSetCookieCallbackCppToC() { 39 | GetStruct()->on_complete = set_cookie_callback_on_complete; 40 | } 41 | 42 | template<> CefRefPtr CefCppToC::UnwrapDerived( 44 | CefWrapperType type, cef_set_cookie_callback_t* s) { 45 | NOTREACHED() << "Unexpected class type: " << type; 46 | return NULL; 47 | } 48 | 49 | #ifndef NDEBUG 50 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 52 | #endif 53 | 54 | template<> CefWrapperType CefCppToC::kWrapperType = 56 | WT_SET_COOKIE_CALLBACK; 57 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/set_cookie_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_SET_COOKIE_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_SET_COOKIE_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_cookie.h" 22 | #include "include/capi/cef_cookie_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefSetCookieCallbackCppToC 28 | : public CefCppToC { 30 | public: 31 | CefSetCookieCallbackCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_SET_COOKIE_CALLBACK_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/string_visitor_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/string_visitor_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK string_visitor_visit(struct _cef_string_visitor_t* self, 21 | const cef_string_t* string) { 22 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 23 | 24 | DCHECK(self); 25 | if (!self) 26 | return; 27 | // Unverified params: string 28 | 29 | // Execute 30 | CefStringVisitorCppToC::Get(self)->Visit( 31 | CefString(string)); 32 | } 33 | 34 | } // namespace 35 | 36 | 37 | // CONSTRUCTOR - Do not edit by hand. 38 | 39 | CefStringVisitorCppToC::CefStringVisitorCppToC() { 40 | GetStruct()->visit = string_visitor_visit; 41 | } 42 | 43 | template<> CefRefPtr CefCppToC::UnwrapDerived(CefWrapperType type, 45 | cef_string_visitor_t* s) { 46 | NOTREACHED() << "Unexpected class type: " << type; 47 | return NULL; 48 | } 49 | 50 | #ifndef NDEBUG 51 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 53 | #endif 54 | 55 | template<> CefWrapperType CefCppToC::kWrapperType = WT_STRING_VISITOR; 57 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/string_visitor_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_STRING_VISITOR_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_STRING_VISITOR_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_string_visitor.h" 22 | #include "include/capi/cef_string_visitor_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefStringVisitorCppToC 28 | : public CefCppToC { 30 | public: 31 | CefStringVisitorCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_STRING_VISITOR_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/task_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/task_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK task_execute(struct _cef_task_t* self) { 21 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 22 | 23 | DCHECK(self); 24 | if (!self) 25 | return; 26 | 27 | // Execute 28 | CefTaskCppToC::Get(self)->Execute(); 29 | } 30 | 31 | } // namespace 32 | 33 | 34 | // CONSTRUCTOR - Do not edit by hand. 35 | 36 | CefTaskCppToC::CefTaskCppToC() { 37 | GetStruct()->execute = task_execute; 38 | } 39 | 40 | template<> CefRefPtr CefCppToC::UnwrapDerived(CefWrapperType type, cef_task_t* s) { 42 | NOTREACHED() << "Unexpected class type: " << type; 43 | return NULL; 44 | } 45 | 46 | #ifndef NDEBUG 47 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 49 | #endif 50 | 51 | template<> CefWrapperType CefCppToC::kWrapperType = WT_TASK; 53 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/task_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_TASK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_TASK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_task.h" 22 | #include "include/capi/cef_task_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefTaskCppToC 28 | : public CefCppToC { 29 | public: 30 | CefTaskCppToC(); 31 | }; 32 | 33 | #endif // USING_CEF_SHARED 34 | #endif // CEF_LIBCEF_DLL_CPPTOC_TASK_CPPTOC_H_ 35 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/urlrequest_client_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_URLREQUEST_CLIENT_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_URLREQUEST_CLIENT_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_urlrequest.h" 22 | #include "include/capi/cef_urlrequest_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefURLRequestClientCppToC 28 | : public CefCppToC { 30 | public: 31 | CefURLRequestClientCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_URLREQUEST_CLIENT_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/v8accessor_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_V8ACCESSOR_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_V8ACCESSOR_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_v8.h" 22 | #include "include/capi/cef_v8_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefV8AccessorCppToC 28 | : public CefCppToC { 29 | public: 30 | CefV8AccessorCppToC(); 31 | }; 32 | 33 | #endif // USING_CEF_SHARED 34 | #endif // CEF_LIBCEF_DLL_CPPTOC_V8ACCESSOR_CPPTOC_H_ 35 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/v8handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_V8HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_V8HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_v8.h" 22 | #include "include/capi/cef_v8_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefV8HandlerCppToC 28 | : public CefCppToC { 29 | public: 30 | CefV8HandlerCppToC(); 31 | }; 32 | 33 | #endif // USING_CEF_SHARED 34 | #endif // CEF_LIBCEF_DLL_CPPTOC_V8HANDLER_CPPTOC_H_ 35 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/web_plugin_info_visitor_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/web_plugin_info_visitor_cpptoc.h" 14 | #include "libcef_dll/ctocpp/web_plugin_info_ctocpp.h" 15 | 16 | 17 | namespace { 18 | 19 | // MEMBER FUNCTIONS - Body may be edited by hand. 20 | 21 | int CEF_CALLBACK web_plugin_info_visitor_visit( 22 | struct _cef_web_plugin_info_visitor_t* self, cef_web_plugin_info_t* info, 23 | int count, int total) { 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | DCHECK(self); 27 | if (!self) 28 | return 0; 29 | // Verify param: info; type: refptr_diff 30 | DCHECK(info); 31 | if (!info) 32 | return 0; 33 | 34 | // Execute 35 | bool _retval = CefWebPluginInfoVisitorCppToC::Get(self)->Visit( 36 | CefWebPluginInfoCToCpp::Wrap(info), 37 | count, 38 | total); 39 | 40 | // Return type: bool 41 | return _retval; 42 | } 43 | 44 | } // namespace 45 | 46 | 47 | // CONSTRUCTOR - Do not edit by hand. 48 | 49 | CefWebPluginInfoVisitorCppToC::CefWebPluginInfoVisitorCppToC() { 50 | GetStruct()->visit = web_plugin_info_visitor_visit; 51 | } 52 | 53 | template<> CefRefPtr CefCppToC::UnwrapDerived( 55 | CefWrapperType type, cef_web_plugin_info_visitor_t* s) { 56 | NOTREACHED() << "Unexpected class type: " << type; 57 | return NULL; 58 | } 59 | 60 | #ifndef NDEBUG 61 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 63 | #endif 64 | 65 | template<> CefWrapperType CefCppToC::kWrapperType = 67 | WT_WEB_PLUGIN_INFO_VISITOR; 68 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/web_plugin_info_visitor_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_WEB_PLUGIN_INFO_VISITOR_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_WEB_PLUGIN_INFO_VISITOR_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_web_plugin.h" 22 | #include "include/capi/cef_web_plugin_capi.h" 23 | #include "include/cef_browser.h" 24 | #include "include/capi/cef_browser_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefWebPluginInfoVisitorCppToC 30 | : public CefCppToC { 32 | public: 33 | CefWebPluginInfoVisitorCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_WEB_PLUGIN_INFO_VISITOR_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/web_plugin_unstable_callback_cpptoc.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/cpptoc/web_plugin_unstable_callback_cpptoc.h" 14 | 15 | 16 | namespace { 17 | 18 | // MEMBER FUNCTIONS - Body may be edited by hand. 19 | 20 | void CEF_CALLBACK web_plugin_unstable_callback_is_unstable( 21 | struct _cef_web_plugin_unstable_callback_t* self, const cef_string_t* path, 22 | int unstable) { 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | DCHECK(self); 26 | if (!self) 27 | return; 28 | // Verify param: path; type: string_byref_const 29 | DCHECK(path); 30 | if (!path) 31 | return; 32 | 33 | // Execute 34 | CefWebPluginUnstableCallbackCppToC::Get(self)->IsUnstable( 35 | CefString(path), 36 | unstable?true:false); 37 | } 38 | 39 | } // namespace 40 | 41 | 42 | // CONSTRUCTOR - Do not edit by hand. 43 | 44 | CefWebPluginUnstableCallbackCppToC::CefWebPluginUnstableCallbackCppToC() { 45 | GetStruct()->is_unstable = web_plugin_unstable_callback_is_unstable; 46 | } 47 | 48 | template<> CefRefPtr CefCppToC::UnwrapDerived(CefWrapperType type, 51 | cef_web_plugin_unstable_callback_t* s) { 52 | NOTREACHED() << "Unexpected class type: " << type; 53 | return NULL; 54 | } 55 | 56 | #ifndef NDEBUG 57 | template<> base::AtomicRefCount CefCppToC::DebugObjCt = 0; 60 | #endif 61 | 62 | template<> CefWrapperType CefCppToC::kWrapperType = 65 | WT_WEB_PLUGIN_UNSTABLE_CALLBACK; 66 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/web_plugin_unstable_callback_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_WEB_PLUGIN_UNSTABLE_CALLBACK_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_WEB_PLUGIN_UNSTABLE_CALLBACK_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_web_plugin.h" 22 | #include "include/capi/cef_web_plugin_capi.h" 23 | #include "include/cef_browser.h" 24 | #include "include/capi/cef_browser_capi.h" 25 | #include "libcef_dll/cpptoc/cpptoc.h" 26 | 27 | // Wrap a C++ class with a C structure. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefWebPluginUnstableCallbackCppToC 30 | : public CefCppToC { 32 | public: 33 | CefWebPluginUnstableCallbackCppToC(); 34 | }; 35 | 36 | #endif // USING_CEF_SHARED 37 | #endif // CEF_LIBCEF_DLL_CPPTOC_WEB_PLUGIN_UNSTABLE_CALLBACK_CPPTOC_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/cpptoc/write_handler_cpptoc.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CPPTOC_WRITE_HANDLER_CPPTOC_H_ 14 | #define CEF_LIBCEF_DLL_CPPTOC_WRITE_HANDLER_CPPTOC_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_stream.h" 22 | #include "include/capi/cef_stream_capi.h" 23 | #include "libcef_dll/cpptoc/cpptoc.h" 24 | 25 | // Wrap a C++ class with a C structure. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefWriteHandlerCppToC 28 | : public CefCppToC { 30 | public: 31 | CefWriteHandlerCppToC(); 32 | }; 33 | 34 | #endif // USING_CEF_SHARED 35 | #endif // CEF_LIBCEF_DLL_CPPTOC_WRITE_HANDLER_CPPTOC_H_ 36 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/auth_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/auth_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefAuthCallbackCToCpp::Continue(const CefString& username, 19 | const CefString& password) { 20 | cef_auth_callback_t* _struct = GetStruct(); 21 | if (CEF_MEMBER_MISSING(_struct, cont)) 22 | return; 23 | 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | // Verify param: username; type: string_byref_const 27 | DCHECK(!username.empty()); 28 | if (username.empty()) 29 | return; 30 | // Verify param: password; type: string_byref_const 31 | DCHECK(!password.empty()); 32 | if (password.empty()) 33 | return; 34 | 35 | // Execute 36 | _struct->cont(_struct, 37 | username.GetStruct(), 38 | password.GetStruct()); 39 | } 40 | 41 | void CefAuthCallbackCToCpp::Cancel() { 42 | cef_auth_callback_t* _struct = GetStruct(); 43 | if (CEF_MEMBER_MISSING(_struct, cancel)) 44 | return; 45 | 46 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 47 | 48 | // Execute 49 | _struct->cancel(_struct); 50 | } 51 | 52 | 53 | // CONSTRUCTOR - Do not edit by hand. 54 | 55 | CefAuthCallbackCToCpp::CefAuthCallbackCToCpp() { 56 | } 57 | 58 | template<> cef_auth_callback_t* CefCToCpp::UnwrapDerived(CefWrapperType type, 60 | CefAuthCallback* c) { 61 | NOTREACHED() << "Unexpected class type: " << type; 62 | return NULL; 63 | } 64 | 65 | #ifndef NDEBUG 66 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 68 | #endif 69 | 70 | template<> CefWrapperType CefCToCpp::kWrapperType = WT_AUTH_CALLBACK; 72 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/auth_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_AUTH_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_AUTH_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_auth_callback.h" 22 | #include "include/capi/cef_auth_callback_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefAuthCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefAuthCallbackCToCpp(); 32 | 33 | // CefAuthCallback methods. 34 | void Continue(const CefString& username, const CefString& password) OVERRIDE; 35 | void Cancel() OVERRIDE; 36 | }; 37 | 38 | #endif // USING_CEF_SHARED 39 | #endif // CEF_LIBCEF_DLL_CTOCPP_AUTH_CALLBACK_CTOCPP_H_ 40 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/before_download_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/before_download_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefBeforeDownloadCallbackCToCpp::Continue(const CefString& download_path, 19 | bool show_dialog) { 20 | cef_before_download_callback_t* _struct = GetStruct(); 21 | if (CEF_MEMBER_MISSING(_struct, cont)) 22 | return; 23 | 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | // Unverified params: download_path 27 | 28 | // Execute 29 | _struct->cont(_struct, 30 | download_path.GetStruct(), 31 | show_dialog); 32 | } 33 | 34 | 35 | // CONSTRUCTOR - Do not edit by hand. 36 | 37 | CefBeforeDownloadCallbackCToCpp::CefBeforeDownloadCallbackCToCpp() { 38 | } 39 | 40 | template<> cef_before_download_callback_t* CefCToCpp::UnwrapDerived( 42 | CefWrapperType type, CefBeforeDownloadCallback* c) { 43 | NOTREACHED() << "Unexpected class type: " << type; 44 | return NULL; 45 | } 46 | 47 | #ifndef NDEBUG 48 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 50 | 0; 51 | #endif 52 | 53 | template<> CefWrapperType CefCToCpp::kWrapperType = 55 | WT_BEFORE_DOWNLOAD_CALLBACK; 56 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/before_download_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_BEFORE_DOWNLOAD_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_BEFORE_DOWNLOAD_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_download_handler.h" 22 | #include "include/capi/cef_download_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefBeforeDownloadCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefBeforeDownloadCallbackCToCpp(); 32 | 33 | // CefBeforeDownloadCallback methods. 34 | void Continue(const CefString& download_path, bool show_dialog) OVERRIDE; 35 | }; 36 | 37 | #endif // USING_CEF_SHARED 38 | #endif // CEF_LIBCEF_DLL_CTOCPP_BEFORE_DOWNLOAD_CALLBACK_CTOCPP_H_ 39 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/binary_value_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_BINARY_VALUE_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_BINARY_VALUE_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_values.h" 22 | #include "include/capi/cef_values_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefBinaryValueCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefBinaryValueCToCpp(); 32 | 33 | // CefBinaryValue methods. 34 | bool IsValid() OVERRIDE; 35 | bool IsOwned() OVERRIDE; 36 | bool IsSame(CefRefPtr that) OVERRIDE; 37 | bool IsEqual(CefRefPtr that) OVERRIDE; 38 | CefRefPtr Copy() OVERRIDE; 39 | size_t GetSize() OVERRIDE; 40 | size_t GetData(void* buffer, size_t buffer_size, size_t data_offset) OVERRIDE; 41 | }; 42 | 43 | #endif // USING_CEF_SHARED 44 | #endif // CEF_LIBCEF_DLL_CTOCPP_BINARY_VALUE_CTOCPP_H_ 45 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefCallbackCToCpp::Continue() { 19 | cef_callback_t* _struct = GetStruct(); 20 | if (CEF_MEMBER_MISSING(_struct, cont)) 21 | return; 22 | 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | // Execute 26 | _struct->cont(_struct); 27 | } 28 | 29 | void CefCallbackCToCpp::Cancel() { 30 | cef_callback_t* _struct = GetStruct(); 31 | if (CEF_MEMBER_MISSING(_struct, cancel)) 32 | return; 33 | 34 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 35 | 36 | // Execute 37 | _struct->cancel(_struct); 38 | } 39 | 40 | 41 | // CONSTRUCTOR - Do not edit by hand. 42 | 43 | CefCallbackCToCpp::CefCallbackCToCpp() { 44 | } 45 | 46 | template<> cef_callback_t* CefCToCpp::UnwrapDerived(CefWrapperType type, CefCallback* c) { 48 | NOTREACHED() << "Unexpected class type: " << type; 49 | return NULL; 50 | } 51 | 52 | #ifndef NDEBUG 53 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 55 | #endif 56 | 57 | template<> CefWrapperType CefCToCpp::kWrapperType = WT_CALLBACK; 59 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_callback.h" 22 | #include "include/capi/cef_callback_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefCallbackCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefCallbackCToCpp(); 31 | 32 | // CefCallback methods. 33 | void Continue() OVERRIDE; 34 | void Cancel() OVERRIDE; 35 | }; 36 | 37 | #endif // USING_CEF_SHARED 38 | #endif // CEF_LIBCEF_DLL_CTOCPP_CALLBACK_CTOCPP_H_ 39 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/context_menu_params_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_CONTEXT_MENU_PARAMS_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_CONTEXT_MENU_PARAMS_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include 22 | #include "include/cef_context_menu_handler.h" 23 | #include "include/capi/cef_context_menu_handler_capi.h" 24 | #include "libcef_dll/ctocpp/ctocpp.h" 25 | 26 | // Wrap a C structure with a C++ class. 27 | // This class may be instantiated and accessed wrapper-side only. 28 | class CefContextMenuParamsCToCpp 29 | : public CefCToCpp { 31 | public: 32 | CefContextMenuParamsCToCpp(); 33 | 34 | // CefContextMenuParams methods. 35 | int GetXCoord() OVERRIDE; 36 | int GetYCoord() OVERRIDE; 37 | TypeFlags GetTypeFlags() OVERRIDE; 38 | CefString GetLinkUrl() OVERRIDE; 39 | CefString GetUnfilteredLinkUrl() OVERRIDE; 40 | CefString GetSourceUrl() OVERRIDE; 41 | bool HasImageContents() OVERRIDE; 42 | CefString GetPageUrl() OVERRIDE; 43 | CefString GetFrameUrl() OVERRIDE; 44 | CefString GetFrameCharset() OVERRIDE; 45 | MediaType GetMediaType() OVERRIDE; 46 | MediaStateFlags GetMediaStateFlags() OVERRIDE; 47 | CefString GetSelectionText() OVERRIDE; 48 | CefString GetMisspelledWord() OVERRIDE; 49 | bool GetDictionarySuggestions(std::vector& suggestions) OVERRIDE; 50 | bool IsEditable() OVERRIDE; 51 | bool IsSpellCheckEnabled() OVERRIDE; 52 | EditStateFlags GetEditStateFlags() OVERRIDE; 53 | bool IsCustomMenu() OVERRIDE; 54 | bool IsPepperMenu() OVERRIDE; 55 | }; 56 | 57 | #endif // USING_CEF_SHARED 58 | #endif // CEF_LIBCEF_DLL_CTOCPP_CONTEXT_MENU_PARAMS_CTOCPP_H_ 59 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/cookie_manager_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include 22 | #include "include/cef_cookie.h" 23 | #include "include/capi/cef_cookie_capi.h" 24 | #include "libcef_dll/ctocpp/ctocpp.h" 25 | 26 | // Wrap a C structure with a C++ class. 27 | // This class may be instantiated and accessed wrapper-side only. 28 | class CefCookieManagerCToCpp 29 | : public CefCToCpp { 31 | public: 32 | CefCookieManagerCToCpp(); 33 | 34 | // CefCookieManager methods. 35 | void SetSupportedSchemes(const std::vector& schemes, 36 | CefRefPtr callback) OVERRIDE; 37 | bool VisitAllCookies(CefRefPtr visitor) OVERRIDE; 38 | bool VisitUrlCookies(const CefString& url, bool includeHttpOnly, 39 | CefRefPtr visitor) OVERRIDE; 40 | bool SetCookie(const CefString& url, const CefCookie& cookie, 41 | CefRefPtr callback) OVERRIDE; 42 | bool DeleteCookies(const CefString& url, const CefString& cookie_name, 43 | CefRefPtr callback) OVERRIDE; 44 | bool SetStoragePath(const CefString& path, bool persist_session_cookies, 45 | CefRefPtr callback) OVERRIDE; 46 | bool FlushStore(CefRefPtr callback) OVERRIDE; 47 | }; 48 | 49 | #endif // USING_CEF_SHARED 50 | #endif // CEF_LIBCEF_DLL_CTOCPP_COOKIE_MANAGER_CTOCPP_H_ 51 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/domdocument_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_DOMDOCUMENT_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_DOMDOCUMENT_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_dom.h" 22 | #include "include/capi/cef_dom_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDOMDocumentCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefDOMDocumentCToCpp(); 32 | 33 | // CefDOMDocument methods. 34 | Type GetType() OVERRIDE; 35 | CefRefPtr GetDocument() OVERRIDE; 36 | CefRefPtr GetBody() OVERRIDE; 37 | CefRefPtr GetHead() OVERRIDE; 38 | CefString GetTitle() OVERRIDE; 39 | CefRefPtr GetElementById(const CefString& id) OVERRIDE; 40 | CefRefPtr GetFocusedNode() OVERRIDE; 41 | bool HasSelection() OVERRIDE; 42 | int GetSelectionStartOffset() OVERRIDE; 43 | int GetSelectionEndOffset() OVERRIDE; 44 | CefString GetSelectionAsMarkup() OVERRIDE; 45 | CefString GetSelectionAsText() OVERRIDE; 46 | CefString GetBaseURL() OVERRIDE; 47 | CefString GetCompleteURL(const CefString& partialURL) OVERRIDE; 48 | }; 49 | 50 | #endif // USING_CEF_SHARED 51 | #endif // CEF_LIBCEF_DLL_CTOCPP_DOMDOCUMENT_CTOCPP_H_ 52 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/download_item_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_DOWNLOAD_ITEM_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_DOWNLOAD_ITEM_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_download_handler.h" 22 | #include "include/capi/cef_download_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDownloadItemCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefDownloadItemCallbackCToCpp(); 32 | 33 | // CefDownloadItemCallback methods. 34 | void Cancel() OVERRIDE; 35 | void Pause() OVERRIDE; 36 | void Resume() OVERRIDE; 37 | }; 38 | 39 | #endif // USING_CEF_SHARED 40 | #endif // CEF_LIBCEF_DLL_CTOCPP_DOWNLOAD_ITEM_CALLBACK_CTOCPP_H_ 41 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/download_item_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_DOWNLOAD_ITEM_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_DOWNLOAD_ITEM_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_download_item.h" 22 | #include "include/capi/cef_download_item_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefDownloadItemCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefDownloadItemCToCpp(); 32 | 33 | // CefDownloadItem methods. 34 | bool IsValid() OVERRIDE; 35 | bool IsInProgress() OVERRIDE; 36 | bool IsComplete() OVERRIDE; 37 | bool IsCanceled() OVERRIDE; 38 | int64 GetCurrentSpeed() OVERRIDE; 39 | int GetPercentComplete() OVERRIDE; 40 | int64 GetTotalBytes() OVERRIDE; 41 | int64 GetReceivedBytes() OVERRIDE; 42 | CefTime GetStartTime() OVERRIDE; 43 | CefTime GetEndTime() OVERRIDE; 44 | CefString GetFullPath() OVERRIDE; 45 | uint32 GetId() OVERRIDE; 46 | CefString GetURL() OVERRIDE; 47 | CefString GetOriginalUrl() OVERRIDE; 48 | CefString GetSuggestedFileName() OVERRIDE; 49 | CefString GetContentDisposition() OVERRIDE; 50 | CefString GetMimeType() OVERRIDE; 51 | }; 52 | 53 | #endif // USING_CEF_SHARED 54 | #endif // CEF_LIBCEF_DLL_CTOCPP_DOWNLOAD_ITEM_CTOCPP_H_ 55 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/file_dialog_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_FILE_DIALOG_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_FILE_DIALOG_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include 22 | #include "include/cef_dialog_handler.h" 23 | #include "include/capi/cef_dialog_handler_capi.h" 24 | #include "libcef_dll/ctocpp/ctocpp.h" 25 | 26 | // Wrap a C structure with a C++ class. 27 | // This class may be instantiated and accessed wrapper-side only. 28 | class CefFileDialogCallbackCToCpp 29 | : public CefCToCpp { 31 | public: 32 | CefFileDialogCallbackCToCpp(); 33 | 34 | // CefFileDialogCallback methods. 35 | void Continue(int selected_accept_filter, 36 | const std::vector& file_paths) OVERRIDE; 37 | void Cancel() OVERRIDE; 38 | }; 39 | 40 | #endif // USING_CEF_SHARED 41 | #endif // CEF_LIBCEF_DLL_CTOCPP_FILE_DIALOG_CALLBACK_CTOCPP_H_ 42 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/geolocation_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/geolocation_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefGeolocationCallbackCToCpp::Continue(bool allow) { 19 | cef_geolocation_callback_t* _struct = GetStruct(); 20 | if (CEF_MEMBER_MISSING(_struct, cont)) 21 | return; 22 | 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | // Execute 26 | _struct->cont(_struct, 27 | allow); 28 | } 29 | 30 | 31 | // CONSTRUCTOR - Do not edit by hand. 32 | 33 | CefGeolocationCallbackCToCpp::CefGeolocationCallbackCToCpp() { 34 | } 35 | 36 | template<> cef_geolocation_callback_t* CefCToCpp::UnwrapDerived( 38 | CefWrapperType type, CefGeolocationCallback* c) { 39 | NOTREACHED() << "Unexpected class type: " << type; 40 | return NULL; 41 | } 42 | 43 | #ifndef NDEBUG 44 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 46 | #endif 47 | 48 | template<> CefWrapperType CefCToCpp::kWrapperType = 50 | WT_GEOLOCATION_CALLBACK; 51 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/geolocation_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_GEOLOCATION_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_GEOLOCATION_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_geolocation_handler.h" 22 | #include "include/capi/cef_geolocation_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefGeolocationCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefGeolocationCallbackCToCpp(); 32 | 33 | // CefGeolocationCallback methods. 34 | void Continue(bool allow) OVERRIDE; 35 | }; 36 | 37 | #endif // USING_CEF_SHARED 38 | #endif // CEF_LIBCEF_DLL_CTOCPP_GEOLOCATION_CALLBACK_CTOCPP_H_ 39 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/jsdialog_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/jsdialog_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefJSDialogCallbackCToCpp::Continue(bool success, 19 | const CefString& user_input) { 20 | cef_jsdialog_callback_t* _struct = GetStruct(); 21 | if (CEF_MEMBER_MISSING(_struct, cont)) 22 | return; 23 | 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | // Unverified params: user_input 27 | 28 | // Execute 29 | _struct->cont(_struct, 30 | success, 31 | user_input.GetStruct()); 32 | } 33 | 34 | 35 | // CONSTRUCTOR - Do not edit by hand. 36 | 37 | CefJSDialogCallbackCToCpp::CefJSDialogCallbackCToCpp() { 38 | } 39 | 40 | template<> cef_jsdialog_callback_t* CefCToCpp::UnwrapDerived( 42 | CefWrapperType type, CefJSDialogCallback* c) { 43 | NOTREACHED() << "Unexpected class type: " << type; 44 | return NULL; 45 | } 46 | 47 | #ifndef NDEBUG 48 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 50 | #endif 51 | 52 | template<> CefWrapperType CefCToCpp::kWrapperType = 54 | WT_JSDIALOG_CALLBACK; 55 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/jsdialog_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_JSDIALOG_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_JSDIALOG_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_jsdialog_handler.h" 22 | #include "include/capi/cef_jsdialog_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefJSDialogCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefJSDialogCallbackCToCpp(); 32 | 33 | // CefJSDialogCallback methods. 34 | void Continue(bool success, const CefString& user_input) OVERRIDE; 35 | }; 36 | 37 | #endif // USING_CEF_SHARED 38 | #endif // CEF_LIBCEF_DLL_CTOCPP_JSDIALOG_CALLBACK_CTOCPP_H_ 39 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/navigation_entry_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_NAVIGATION_ENTRY_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_NAVIGATION_ENTRY_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_navigation_entry.h" 22 | #include "include/capi/cef_navigation_entry_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefNavigationEntryCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefNavigationEntryCToCpp(); 32 | 33 | // CefNavigationEntry methods. 34 | bool IsValid() OVERRIDE; 35 | CefString GetURL() OVERRIDE; 36 | CefString GetDisplayURL() OVERRIDE; 37 | CefString GetOriginalURL() OVERRIDE; 38 | CefString GetTitle() OVERRIDE; 39 | TransitionType GetTransitionType() OVERRIDE; 40 | bool HasPostData() OVERRIDE; 41 | CefTime GetCompletionTime() OVERRIDE; 42 | int GetHttpStatusCode() OVERRIDE; 43 | }; 44 | 45 | #endif // USING_CEF_SHARED 46 | #endif // CEF_LIBCEF_DLL_CTOCPP_NAVIGATION_ENTRY_CTOCPP_H_ 47 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/post_data_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_POST_DATA_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_POST_DATA_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_request.h" 22 | #include "include/capi/cef_request_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefPostDataCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefPostDataCToCpp(); 31 | 32 | // CefPostData methods. 33 | bool IsReadOnly() OVERRIDE; 34 | bool HasExcludedElements() OVERRIDE; 35 | size_t GetElementCount() OVERRIDE; 36 | void GetElements(ElementVector& elements) OVERRIDE; 37 | bool RemoveElement(CefRefPtr element) OVERRIDE; 38 | bool AddElement(CefRefPtr element) OVERRIDE; 39 | void RemoveElements() OVERRIDE; 40 | }; 41 | 42 | #endif // USING_CEF_SHARED 43 | #endif // CEF_LIBCEF_DLL_CTOCPP_POST_DATA_CTOCPP_H_ 44 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/post_data_element_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_POST_DATA_ELEMENT_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_POST_DATA_ELEMENT_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_request.h" 22 | #include "include/capi/cef_request_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefPostDataElementCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefPostDataElementCToCpp(); 32 | 33 | // CefPostDataElement methods. 34 | bool IsReadOnly() OVERRIDE; 35 | void SetToEmpty() OVERRIDE; 36 | void SetToFile(const CefString& fileName) OVERRIDE; 37 | void SetToBytes(size_t size, const void* bytes) OVERRIDE; 38 | Type GetType() OVERRIDE; 39 | CefString GetFile() OVERRIDE; 40 | size_t GetBytesCount() OVERRIDE; 41 | size_t GetBytes(size_t size, void* bytes) OVERRIDE; 42 | }; 43 | 44 | #endif // USING_CEF_SHARED 45 | #endif // CEF_LIBCEF_DLL_CTOCPP_POST_DATA_ELEMENT_CTOCPP_H_ 46 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/print_dialog_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_PRINT_DIALOG_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_PRINT_DIALOG_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_print_handler.h" 22 | #include "include/capi/cef_print_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefPrintDialogCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefPrintDialogCallbackCToCpp(); 32 | 33 | // CefPrintDialogCallback methods. 34 | void Continue(CefRefPtr settings) OVERRIDE; 35 | void Cancel() OVERRIDE; 36 | }; 37 | 38 | #endif // USING_CEF_SHARED 39 | #endif // CEF_LIBCEF_DLL_CTOCPP_PRINT_DIALOG_CALLBACK_CTOCPP_H_ 40 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/print_job_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/print_job_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefPrintJobCallbackCToCpp::Continue() { 19 | cef_print_job_callback_t* _struct = GetStruct(); 20 | if (CEF_MEMBER_MISSING(_struct, cont)) 21 | return; 22 | 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | // Execute 26 | _struct->cont(_struct); 27 | } 28 | 29 | 30 | // CONSTRUCTOR - Do not edit by hand. 31 | 32 | CefPrintJobCallbackCToCpp::CefPrintJobCallbackCToCpp() { 33 | } 34 | 35 | template<> cef_print_job_callback_t* CefCToCpp::UnwrapDerived( 37 | CefWrapperType type, CefPrintJobCallback* c) { 38 | NOTREACHED() << "Unexpected class type: " << type; 39 | return NULL; 40 | } 41 | 42 | #ifndef NDEBUG 43 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 45 | #endif 46 | 47 | template<> CefWrapperType CefCToCpp::kWrapperType = 49 | WT_PRINT_JOB_CALLBACK; 50 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/print_job_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_PRINT_JOB_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_PRINT_JOB_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_print_handler.h" 22 | #include "include/capi/cef_print_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefPrintJobCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefPrintJobCallbackCToCpp(); 32 | 33 | // CefPrintJobCallback methods. 34 | void Continue() OVERRIDE; 35 | }; 36 | 37 | #endif // USING_CEF_SHARED 38 | #endif // CEF_LIBCEF_DLL_CTOCPP_PRINT_JOB_CALLBACK_CTOCPP_H_ 39 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/process_message_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_PROCESS_MESSAGE_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_PROCESS_MESSAGE_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_process_message.h" 22 | #include "include/capi/cef_process_message_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefProcessMessageCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefProcessMessageCToCpp(); 32 | 33 | // CefProcessMessage methods. 34 | bool IsValid() OVERRIDE; 35 | bool IsReadOnly() OVERRIDE; 36 | CefRefPtr Copy() OVERRIDE; 37 | CefString GetName() OVERRIDE; 38 | CefRefPtr GetArgumentList() OVERRIDE; 39 | }; 40 | 41 | #endif // USING_CEF_SHARED 42 | #endif // CEF_LIBCEF_DLL_CTOCPP_PROCESS_MESSAGE_CTOCPP_H_ 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/request_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/request_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefRequestCallbackCToCpp::Continue(bool allow) { 19 | cef_request_callback_t* _struct = GetStruct(); 20 | if (CEF_MEMBER_MISSING(_struct, cont)) 21 | return; 22 | 23 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 24 | 25 | // Execute 26 | _struct->cont(_struct, 27 | allow); 28 | } 29 | 30 | void CefRequestCallbackCToCpp::Cancel() { 31 | cef_request_callback_t* _struct = GetStruct(); 32 | if (CEF_MEMBER_MISSING(_struct, cancel)) 33 | return; 34 | 35 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 36 | 37 | // Execute 38 | _struct->cancel(_struct); 39 | } 40 | 41 | 42 | // CONSTRUCTOR - Do not edit by hand. 43 | 44 | CefRequestCallbackCToCpp::CefRequestCallbackCToCpp() { 45 | } 46 | 47 | template<> cef_request_callback_t* CefCToCpp::UnwrapDerived( 49 | CefWrapperType type, CefRequestCallback* c) { 50 | NOTREACHED() << "Unexpected class type: " << type; 51 | return NULL; 52 | } 53 | 54 | #ifndef NDEBUG 55 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 57 | #endif 58 | 59 | template<> CefWrapperType CefCToCpp::kWrapperType = 61 | WT_REQUEST_CALLBACK; 62 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/request_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_REQUEST_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_REQUEST_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_request_handler.h" 22 | #include "include/capi/cef_request_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefRequestCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefRequestCallbackCToCpp(); 32 | 33 | // CefRequestCallback methods. 34 | void Continue(bool allow) OVERRIDE; 35 | void Cancel() OVERRIDE; 36 | }; 37 | 38 | #endif // USING_CEF_SHARED 39 | #endif // CEF_LIBCEF_DLL_CTOCPP_REQUEST_CALLBACK_CTOCPP_H_ 40 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/resource_bundle_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_RESOURCE_BUNDLE_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_RESOURCE_BUNDLE_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_resource_bundle.h" 22 | #include "include/capi/cef_resource_bundle_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefResourceBundleCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefResourceBundleCToCpp(); 32 | 33 | // CefResourceBundle methods. 34 | CefString GetLocalizedString(int string_id) OVERRIDE; 35 | bool GetDataResource(int resource_id, void*& data, 36 | size_t& data_size) OVERRIDE; 37 | bool GetDataResourceForScale(int resource_id, ScaleFactor scale_factor, 38 | void*& data, size_t& data_size) OVERRIDE; 39 | }; 40 | 41 | #endif // USING_CEF_SHARED 42 | #endif // CEF_LIBCEF_DLL_CTOCPP_RESOURCE_BUNDLE_CTOCPP_H_ 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/response_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_RESPONSE_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_RESPONSE_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_response.h" 22 | #include "include/capi/cef_response_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefResponseCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefResponseCToCpp(); 31 | 32 | // CefResponse methods. 33 | bool IsReadOnly() OVERRIDE; 34 | int GetStatus() OVERRIDE; 35 | void SetStatus(int status) OVERRIDE; 36 | CefString GetStatusText() OVERRIDE; 37 | void SetStatusText(const CefString& statusText) OVERRIDE; 38 | CefString GetMimeType() OVERRIDE; 39 | void SetMimeType(const CefString& mimeType) OVERRIDE; 40 | CefString GetHeader(const CefString& name) OVERRIDE; 41 | void GetHeaderMap(HeaderMap& headerMap) OVERRIDE; 42 | void SetHeaderMap(const HeaderMap& headerMap) OVERRIDE; 43 | }; 44 | 45 | #endif // USING_CEF_SHARED 46 | #endif // CEF_LIBCEF_DLL_CTOCPP_RESPONSE_CTOCPP_H_ 47 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/run_context_menu_callback_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/run_context_menu_callback_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | void CefRunContextMenuCallbackCToCpp::Continue(int command_id, 19 | EventFlags event_flags) { 20 | cef_run_context_menu_callback_t* _struct = GetStruct(); 21 | if (CEF_MEMBER_MISSING(_struct, cont)) 22 | return; 23 | 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | // Execute 27 | _struct->cont(_struct, 28 | command_id, 29 | event_flags); 30 | } 31 | 32 | void CefRunContextMenuCallbackCToCpp::Cancel() { 33 | cef_run_context_menu_callback_t* _struct = GetStruct(); 34 | if (CEF_MEMBER_MISSING(_struct, cancel)) 35 | return; 36 | 37 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 38 | 39 | // Execute 40 | _struct->cancel(_struct); 41 | } 42 | 43 | 44 | // CONSTRUCTOR - Do not edit by hand. 45 | 46 | CefRunContextMenuCallbackCToCpp::CefRunContextMenuCallbackCToCpp() { 47 | } 48 | 49 | template<> cef_run_context_menu_callback_t* CefCToCpp::UnwrapDerived( 51 | CefWrapperType type, CefRunContextMenuCallback* c) { 52 | NOTREACHED() << "Unexpected class type: " << type; 53 | return NULL; 54 | } 55 | 56 | #ifndef NDEBUG 57 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 59 | 0; 60 | #endif 61 | 62 | template<> CefWrapperType CefCToCpp::kWrapperType = 64 | WT_RUN_CONTEXT_MENU_CALLBACK; 65 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/run_context_menu_callback_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_RUN_CONTEXT_MENU_CALLBACK_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_RUN_CONTEXT_MENU_CALLBACK_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_context_menu_handler.h" 22 | #include "include/capi/cef_context_menu_handler_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefRunContextMenuCallbackCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefRunContextMenuCallbackCToCpp(); 32 | 33 | // CefRunContextMenuCallback methods. 34 | void Continue(int command_id, EventFlags event_flags) OVERRIDE; 35 | void Cancel() OVERRIDE; 36 | }; 37 | 38 | #endif // USING_CEF_SHARED 39 | #endif // CEF_LIBCEF_DLL_CTOCPP_RUN_CONTEXT_MENU_CALLBACK_CTOCPP_H_ 40 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/scheme_registrar_ctocpp.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #include "libcef_dll/ctocpp/scheme_registrar_ctocpp.h" 14 | 15 | 16 | // VIRTUAL METHODS - Body may be edited by hand. 17 | 18 | bool CefSchemeRegistrarCToCpp::AddCustomScheme(const CefString& scheme_name, 19 | bool is_standard, bool is_local, bool is_display_isolated) { 20 | cef_scheme_registrar_t* _struct = GetStruct(); 21 | if (CEF_MEMBER_MISSING(_struct, add_custom_scheme)) 22 | return false; 23 | 24 | // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING 25 | 26 | // Verify param: scheme_name; type: string_byref_const 27 | DCHECK(!scheme_name.empty()); 28 | if (scheme_name.empty()) 29 | return false; 30 | 31 | // Execute 32 | int _retval = _struct->add_custom_scheme(_struct, 33 | scheme_name.GetStruct(), 34 | is_standard, 35 | is_local, 36 | is_display_isolated); 37 | 38 | // Return type: bool 39 | return _retval?true:false; 40 | } 41 | 42 | 43 | // CONSTRUCTOR - Do not edit by hand. 44 | 45 | CefSchemeRegistrarCToCpp::CefSchemeRegistrarCToCpp() { 46 | } 47 | 48 | template<> cef_scheme_registrar_t* CefCToCpp::UnwrapDerived( 50 | CefWrapperType type, CefSchemeRegistrar* c) { 51 | NOTREACHED() << "Unexpected class type: " << type; 52 | return NULL; 53 | } 54 | 55 | #ifndef NDEBUG 56 | template<> base::AtomicRefCount CefCToCpp::DebugObjCt = 0; 58 | #endif 59 | 60 | template<> CefWrapperType CefCToCpp::kWrapperType = 62 | WT_SCHEME_REGISTRAR; 63 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/scheme_registrar_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_SCHEME_REGISTRAR_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_SCHEME_REGISTRAR_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_scheme.h" 22 | #include "include/capi/cef_scheme_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefSchemeRegistrarCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefSchemeRegistrarCToCpp(); 32 | 33 | // CefSchemeRegistrar methods. 34 | bool AddCustomScheme(const CefString& scheme_name, bool is_standard, 35 | bool is_local, bool is_display_isolated) OVERRIDE; 36 | }; 37 | 38 | #endif // USING_CEF_SHARED 39 | #endif // CEF_LIBCEF_DLL_CTOCPP_SCHEME_REGISTRAR_CTOCPP_H_ 40 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/sslcert_principal_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_SSLCERT_PRINCIPAL_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_SSLCERT_PRINCIPAL_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include 22 | #include "include/cef_ssl_info.h" 23 | #include "include/capi/cef_ssl_info_capi.h" 24 | #include "libcef_dll/ctocpp/ctocpp.h" 25 | 26 | // Wrap a C structure with a C++ class. 27 | // This class may be instantiated and accessed wrapper-side only. 28 | class CefSSLCertPrincipalCToCpp 29 | : public CefCToCpp { 31 | public: 32 | CefSSLCertPrincipalCToCpp(); 33 | 34 | // CefSSLCertPrincipal methods. 35 | CefString GetDisplayName() OVERRIDE; 36 | CefString GetCommonName() OVERRIDE; 37 | CefString GetLocalityName() OVERRIDE; 38 | CefString GetStateOrProvinceName() OVERRIDE; 39 | CefString GetCountryName() OVERRIDE; 40 | void GetStreetAddresses(std::vector& addresses) OVERRIDE; 41 | void GetOrganizationNames(std::vector& names) OVERRIDE; 42 | void GetOrganizationUnitNames(std::vector& names) OVERRIDE; 43 | void GetDomainComponents(std::vector& components) OVERRIDE; 44 | }; 45 | 46 | #endif // USING_CEF_SHARED 47 | #endif // CEF_LIBCEF_DLL_CTOCPP_SSLCERT_PRINCIPAL_CTOCPP_H_ 48 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/sslinfo_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_SSLINFO_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_SSLINFO_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_ssl_info.h" 22 | #include "include/capi/cef_ssl_info_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefSSLInfoCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefSSLInfoCToCpp(); 31 | 32 | // CefSSLInfo methods. 33 | cef_cert_status_t GetCertStatus() OVERRIDE; 34 | bool IsCertStatusError() OVERRIDE; 35 | bool IsCertStatusMinorError() OVERRIDE; 36 | CefRefPtr GetSubject() OVERRIDE; 37 | CefRefPtr GetIssuer() OVERRIDE; 38 | CefRefPtr GetSerialNumber() OVERRIDE; 39 | CefTime GetValidStart() OVERRIDE; 40 | CefTime GetValidExpiry() OVERRIDE; 41 | CefRefPtr GetDEREncoded() OVERRIDE; 42 | CefRefPtr GetPEMEncoded() OVERRIDE; 43 | size_t GetIssuerChainSize() OVERRIDE; 44 | void GetDEREncodedIssuerChain(IssuerChainBinaryList& chain) OVERRIDE; 45 | void GetPEMEncodedIssuerChain(IssuerChainBinaryList& chain) OVERRIDE; 46 | }; 47 | 48 | #endif // USING_CEF_SHARED 49 | #endif // CEF_LIBCEF_DLL_CTOCPP_SSLINFO_CTOCPP_H_ 50 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/stream_reader_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_STREAM_READER_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_STREAM_READER_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_stream.h" 22 | #include "include/capi/cef_stream_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefStreamReaderCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefStreamReaderCToCpp(); 32 | 33 | // CefStreamReader methods. 34 | size_t Read(void* ptr, size_t size, size_t n) OVERRIDE; 35 | int Seek(int64 offset, int whence) OVERRIDE; 36 | int64 Tell() OVERRIDE; 37 | int Eof() OVERRIDE; 38 | bool MayBlock() OVERRIDE; 39 | }; 40 | 41 | #endif // USING_CEF_SHARED 42 | #endif // CEF_LIBCEF_DLL_CTOCPP_STREAM_READER_CTOCPP_H_ 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/stream_writer_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_STREAM_WRITER_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_STREAM_WRITER_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_stream.h" 22 | #include "include/capi/cef_stream_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefStreamWriterCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefStreamWriterCToCpp(); 32 | 33 | // CefStreamWriter methods. 34 | size_t Write(const void* ptr, size_t size, size_t n) OVERRIDE; 35 | int Seek(int64 offset, int whence) OVERRIDE; 36 | int64 Tell() OVERRIDE; 37 | int Flush() OVERRIDE; 38 | bool MayBlock() OVERRIDE; 39 | }; 40 | 41 | #endif // USING_CEF_SHARED 42 | #endif // CEF_LIBCEF_DLL_CTOCPP_STREAM_WRITER_CTOCPP_H_ 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/task_runner_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_TASK_RUNNER_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_TASK_RUNNER_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_task.h" 22 | #include "include/capi/cef_task_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefTaskRunnerCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefTaskRunnerCToCpp(); 31 | 32 | // CefTaskRunner methods. 33 | bool IsSame(CefRefPtr that) OVERRIDE; 34 | bool BelongsToCurrentThread() OVERRIDE; 35 | bool BelongsToThread(CefThreadId threadId) OVERRIDE; 36 | bool PostTask(CefRefPtr task) OVERRIDE; 37 | bool PostDelayedTask(CefRefPtr task, int64 delay_ms) OVERRIDE; 38 | }; 39 | 40 | #endif // USING_CEF_SHARED 41 | #endif // CEF_LIBCEF_DLL_CTOCPP_TASK_RUNNER_CTOCPP_H_ 42 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/urlrequest_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_URLREQUEST_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_URLREQUEST_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_urlrequest.h" 22 | #include "include/capi/cef_urlrequest_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefURLRequestCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefURLRequestCToCpp(); 31 | 32 | // CefURLRequest methods. 33 | CefRefPtr GetRequest() OVERRIDE; 34 | CefRefPtr GetClient() OVERRIDE; 35 | Status GetRequestStatus() OVERRIDE; 36 | ErrorCode GetRequestError() OVERRIDE; 37 | CefRefPtr GetResponse() OVERRIDE; 38 | void Cancel() OVERRIDE; 39 | }; 40 | 41 | #endif // USING_CEF_SHARED 42 | #endif // CEF_LIBCEF_DLL_CTOCPP_URLREQUEST_CTOCPP_H_ 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/v8context_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_V8CONTEXT_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_V8CONTEXT_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_v8.h" 22 | #include "include/capi/cef_v8_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefV8ContextCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefV8ContextCToCpp(); 31 | 32 | // CefV8Context methods. 33 | CefRefPtr GetTaskRunner() OVERRIDE; 34 | bool IsValid() OVERRIDE; 35 | CefRefPtr GetBrowser() OVERRIDE; 36 | CefRefPtr GetFrame() OVERRIDE; 37 | CefRefPtr GetGlobal() OVERRIDE; 38 | bool Enter() OVERRIDE; 39 | bool Exit() OVERRIDE; 40 | bool IsSame(CefRefPtr that) OVERRIDE; 41 | bool Eval(const CefString& code, CefRefPtr& retval, 42 | CefRefPtr& exception) OVERRIDE; 43 | }; 44 | 45 | #endif // USING_CEF_SHARED 46 | #endif // CEF_LIBCEF_DLL_CTOCPP_V8CONTEXT_CTOCPP_H_ 47 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/v8exception_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_V8EXCEPTION_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_V8EXCEPTION_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_v8.h" 22 | #include "include/capi/cef_v8_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefV8ExceptionCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefV8ExceptionCToCpp(); 32 | 33 | // CefV8Exception methods. 34 | CefString GetMessage() OVERRIDE; 35 | CefString GetSourceLine() OVERRIDE; 36 | CefString GetScriptResourceName() OVERRIDE; 37 | int GetLineNumber() OVERRIDE; 38 | int GetStartPosition() OVERRIDE; 39 | int GetEndPosition() OVERRIDE; 40 | int GetStartColumn() OVERRIDE; 41 | int GetEndColumn() OVERRIDE; 42 | }; 43 | 44 | #endif // USING_CEF_SHARED 45 | #endif // CEF_LIBCEF_DLL_CTOCPP_V8EXCEPTION_CTOCPP_H_ 46 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/v8stack_frame_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_V8STACK_FRAME_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_V8STACK_FRAME_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_v8.h" 22 | #include "include/capi/cef_v8_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefV8StackFrameCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefV8StackFrameCToCpp(); 32 | 33 | // CefV8StackFrame methods. 34 | bool IsValid() OVERRIDE; 35 | CefString GetScriptName() OVERRIDE; 36 | CefString GetScriptNameOrSourceURL() OVERRIDE; 37 | CefString GetFunctionName() OVERRIDE; 38 | int GetLineNumber() OVERRIDE; 39 | int GetColumn() OVERRIDE; 40 | bool IsEval() OVERRIDE; 41 | bool IsConstructor() OVERRIDE; 42 | }; 43 | 44 | #endif // USING_CEF_SHARED 45 | #endif // CEF_LIBCEF_DLL_CTOCPP_V8STACK_FRAME_CTOCPP_H_ 46 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/v8stack_trace_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_V8STACK_TRACE_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_V8STACK_TRACE_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_v8.h" 22 | #include "include/capi/cef_v8_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefV8StackTraceCToCpp 28 | : public CefCToCpp { 30 | public: 31 | CefV8StackTraceCToCpp(); 32 | 33 | // CefV8StackTrace methods. 34 | bool IsValid() OVERRIDE; 35 | int GetFrameCount() OVERRIDE; 36 | CefRefPtr GetFrame(int index) OVERRIDE; 37 | }; 38 | 39 | #endif // USING_CEF_SHARED 40 | #endif // CEF_LIBCEF_DLL_CTOCPP_V8STACK_TRACE_CTOCPP_H_ 41 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/value_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_VALUE_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_VALUE_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_values.h" 22 | #include "include/capi/cef_values_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefValueCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefValueCToCpp(); 31 | 32 | // CefValue methods. 33 | bool IsValid() OVERRIDE; 34 | bool IsOwned() OVERRIDE; 35 | bool IsReadOnly() OVERRIDE; 36 | bool IsSame(CefRefPtr that) OVERRIDE; 37 | bool IsEqual(CefRefPtr that) OVERRIDE; 38 | CefRefPtr Copy() OVERRIDE; 39 | CefValueType GetType() OVERRIDE; 40 | bool GetBool() OVERRIDE; 41 | int GetInt() OVERRIDE; 42 | double GetDouble() OVERRIDE; 43 | CefString GetString() OVERRIDE; 44 | CefRefPtr GetBinary() OVERRIDE; 45 | CefRefPtr GetDictionary() OVERRIDE; 46 | CefRefPtr GetList() OVERRIDE; 47 | bool SetNull() OVERRIDE; 48 | bool SetBool(bool value) OVERRIDE; 49 | bool SetInt(int value) OVERRIDE; 50 | bool SetDouble(double value) OVERRIDE; 51 | bool SetString(const CefString& value) OVERRIDE; 52 | bool SetBinary(CefRefPtr value) OVERRIDE; 53 | bool SetDictionary(CefRefPtr value) OVERRIDE; 54 | bool SetList(CefRefPtr value) OVERRIDE; 55 | }; 56 | 57 | #endif // USING_CEF_SHARED 58 | #endif // CEF_LIBCEF_DLL_CTOCPP_VALUE_CTOCPP_H_ 59 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/web_plugin_info_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_WEB_PLUGIN_INFO_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_WEB_PLUGIN_INFO_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_web_plugin.h" 22 | #include "include/capi/cef_web_plugin_capi.h" 23 | #include "include/cef_browser.h" 24 | #include "include/capi/cef_browser_capi.h" 25 | #include "libcef_dll/ctocpp/ctocpp.h" 26 | 27 | // Wrap a C structure with a C++ class. 28 | // This class may be instantiated and accessed wrapper-side only. 29 | class CefWebPluginInfoCToCpp 30 | : public CefCToCpp { 32 | public: 33 | CefWebPluginInfoCToCpp(); 34 | 35 | // CefWebPluginInfo methods. 36 | CefString GetName() OVERRIDE; 37 | CefString GetPath() OVERRIDE; 38 | CefString GetVersion() OVERRIDE; 39 | CefString GetDescription() OVERRIDE; 40 | }; 41 | 42 | #endif // USING_CEF_SHARED 43 | #endif // CEF_LIBCEF_DLL_CTOCPP_WEB_PLUGIN_INFO_CTOCPP_H_ 44 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/ctocpp/zip_reader_ctocpp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | // 5 | // --------------------------------------------------------------------------- 6 | // 7 | // This file was generated by the CEF translator tool. If making changes by 8 | // hand only do so within the body of existing method and function 9 | // implementations. See the translator.README.txt file in the tools directory 10 | // for more information. 11 | // 12 | 13 | #ifndef CEF_LIBCEF_DLL_CTOCPP_ZIP_READER_CTOCPP_H_ 14 | #define CEF_LIBCEF_DLL_CTOCPP_ZIP_READER_CTOCPP_H_ 15 | #pragma once 16 | 17 | #ifndef USING_CEF_SHARED 18 | #pragma message("Warning: "__FILE__" may be accessed wrapper-side only") 19 | #else // USING_CEF_SHARED 20 | 21 | #include "include/cef_zip_reader.h" 22 | #include "include/capi/cef_zip_reader_capi.h" 23 | #include "libcef_dll/ctocpp/ctocpp.h" 24 | 25 | // Wrap a C structure with a C++ class. 26 | // This class may be instantiated and accessed wrapper-side only. 27 | class CefZipReaderCToCpp 28 | : public CefCToCpp { 29 | public: 30 | CefZipReaderCToCpp(); 31 | 32 | // CefZipReader methods. 33 | bool MoveToFirstFile() OVERRIDE; 34 | bool MoveToNextFile() OVERRIDE; 35 | bool MoveToFile(const CefString& fileName, bool caseSensitive) OVERRIDE; 36 | bool Close() OVERRIDE; 37 | CefString GetFileName() OVERRIDE; 38 | int64 GetFileSize() OVERRIDE; 39 | CefTime GetFileLastModified() OVERRIDE; 40 | bool OpenFile(const CefString& password) OVERRIDE; 41 | bool CloseFile() OVERRIDE; 42 | int ReadFile(void* buffer, size_t bufferSize) OVERRIDE; 43 | int64 Tell() OVERRIDE; 44 | bool Eof() OVERRIDE; 45 | }; 46 | 47 | #endif // USING_CEF_SHARED 48 | #endif // CEF_LIBCEF_DLL_CTOCPP_ZIP_READER_CTOCPP_H_ 49 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/transfer_util.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2009 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #ifndef CEF_LIBCEF_DLL_TRANSFER_UTIL_H_ 6 | #define CEF_LIBCEF_DLL_TRANSFER_UTIL_H_ 7 | #pragma once 8 | 9 | #include 10 | #include 11 | 12 | #include "include/internal/cef_string_list.h" 13 | #include "include/internal/cef_string_map.h" 14 | #include "include/internal/cef_string_multimap.h" 15 | 16 | // Copy contents from one list type to another. 17 | typedef std::vector StringList; 18 | void transfer_string_list_contents(cef_string_list_t fromList, 19 | StringList& toList); 20 | void transfer_string_list_contents(const StringList& fromList, 21 | cef_string_list_t toList); 22 | 23 | // Copy contents from one map type to another. 24 | typedef std::map StringMap; 25 | void transfer_string_map_contents(cef_string_map_t fromMap, 26 | StringMap& toMap); 27 | void transfer_string_map_contents(const StringMap& fromMap, 28 | cef_string_map_t toMap); 29 | 30 | // Copy contents from one map type to another. 31 | typedef std::multimap StringMultimap; 32 | void transfer_string_multimap_contents(cef_string_multimap_t fromMap, 33 | StringMultimap& toMap); 34 | void transfer_string_multimap_contents(const StringMultimap& fromMap, 35 | cef_string_multimap_t toMap); 36 | 37 | #endif // CEF_LIBCEF_DLL_TRANSFER_UTIL_H_ 38 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/wrapper/cef_byte_read_handler.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2010 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #include "include/wrapper/cef_byte_read_handler.h" 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | CefByteReadHandler::CefByteReadHandler(const unsigned char* bytes, size_t size, 12 | CefRefPtr source) 13 | : bytes_(bytes), size_(size), offset_(0), source_(source) { 14 | } 15 | 16 | size_t CefByteReadHandler::Read(void* ptr, size_t size, size_t n) { 17 | base::AutoLock lock_scope(lock_); 18 | size_t s = static_cast(size_ - offset_) / size; 19 | size_t ret = std::min(n, s); 20 | memcpy(ptr, bytes_ + offset_, ret * size); 21 | offset_ += ret * size; 22 | return ret; 23 | } 24 | 25 | int CefByteReadHandler::Seek(int64 offset, int whence) { 26 | int rv = -1L; 27 | base::AutoLock lock_scope(lock_); 28 | switch (whence) { 29 | case SEEK_CUR: 30 | if (offset_ + offset > size_ || offset_ + offset < 0) 31 | break; 32 | offset_ += offset; 33 | rv = 0; 34 | break; 35 | case SEEK_END: { 36 | #if defined(OS_WIN) 37 | int64 offset_abs = _abs64(offset); 38 | #else 39 | int64 offset_abs = std::abs(offset); 40 | #endif 41 | if (offset_abs > size_) 42 | break; 43 | offset_ = size_ - offset_abs; 44 | rv = 0; 45 | break; 46 | } 47 | case SEEK_SET: 48 | if (offset > size_ || offset < 0) 49 | break; 50 | offset_ = offset; 51 | rv = 0; 52 | break; 53 | } 54 | 55 | return rv; 56 | } 57 | 58 | int64 CefByteReadHandler::Tell() { 59 | base::AutoLock lock_scope(lock_); 60 | return offset_; 61 | } 62 | 63 | int CefByteReadHandler::Eof() { 64 | base::AutoLock lock_scope(lock_); 65 | return (offset_ >= size_); 66 | } 67 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/wrapper/cef_closure_task.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2014 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #include "include/wrapper/cef_closure_task.h" 6 | #include "include/base/cef_callback.h" 7 | 8 | namespace { 9 | 10 | class CefClosureTask : public CefTask { 11 | public: 12 | explicit CefClosureTask(const base::Closure& closure) 13 | : closure_(closure) { 14 | } 15 | 16 | // CefTask method 17 | virtual void Execute() OVERRIDE { 18 | closure_.Run(); 19 | closure_.Reset(); 20 | } 21 | 22 | private: 23 | base::Closure closure_; 24 | 25 | IMPLEMENT_REFCOUNTING(CefClosureTask); 26 | DISALLOW_COPY_AND_ASSIGN(CefClosureTask); 27 | }; 28 | 29 | } // namespace 30 | 31 | CefRefPtr CefCreateClosureTask(const base::Closure& closure) { 32 | return new CefClosureTask(closure); 33 | } 34 | 35 | bool CefPostTask(CefThreadId threadId, const base::Closure& closure) { 36 | return CefPostTask(threadId, new CefClosureTask(closure)); 37 | } 38 | 39 | bool CefPostDelayedTask(CefThreadId threadId, const base::Closure& closure, 40 | int64 delay_ms) { 41 | return CefPostDelayedTask(threadId, new CefClosureTask(closure), delay_ms); 42 | } 43 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll/wrapper/libcef_dll_wrapper2.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/ALL_BUILD.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeCCompiler.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_C_COMPILER "D:/Visual Studio 2017/VC/Tools/MSVC/14.10.25017/bin/HostX86/x86/cl.exe") 2 | set(CMAKE_C_COMPILER_ARG1 "") 3 | set(CMAKE_C_COMPILER_ID "MSVC") 4 | set(CMAKE_C_COMPILER_VERSION "19.10.25019.0") 5 | set(CMAKE_C_COMPILER_WRAPPER "") 6 | set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "90") 7 | set(CMAKE_C_COMPILE_FEATURES "") 8 | set(CMAKE_C90_COMPILE_FEATURES "") 9 | set(CMAKE_C99_COMPILE_FEATURES "") 10 | set(CMAKE_C11_COMPILE_FEATURES "") 11 | 12 | set(CMAKE_C_PLATFORM_ID "Windows") 13 | set(CMAKE_C_SIMULATE_ID "") 14 | set(CMAKE_C_SIMULATE_VERSION "") 15 | set(MSVC_C_ARCHITECTURE_ID X86) 16 | 17 | set(CMAKE_AR "") 18 | set(CMAKE_C_COMPILER_AR "") 19 | set(CMAKE_RANLIB "") 20 | set(CMAKE_C_COMPILER_RANLIB "") 21 | set(CMAKE_LINKER "D:/Visual Studio 2017/VC/Tools/MSVC/14.10.25017/bin/HostX86/x86/link.exe") 22 | set(CMAKE_COMPILER_IS_GNUCC ) 23 | set(CMAKE_C_COMPILER_LOADED 1) 24 | set(CMAKE_C_COMPILER_WORKS TRUE) 25 | set(CMAKE_C_ABI_COMPILED TRUE) 26 | set(CMAKE_COMPILER_IS_MINGW ) 27 | set(CMAKE_COMPILER_IS_CYGWIN ) 28 | if(CMAKE_COMPILER_IS_CYGWIN) 29 | set(CYGWIN 1) 30 | set(UNIX 1) 31 | endif() 32 | 33 | set(CMAKE_C_COMPILER_ENV_VAR "CC") 34 | 35 | if(CMAKE_COMPILER_IS_MINGW) 36 | set(MINGW 1) 37 | endif() 38 | set(CMAKE_C_COMPILER_ID_RUN 1) 39 | set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) 40 | set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) 41 | set(CMAKE_C_LINKER_PREFERENCE 10) 42 | 43 | # Save compiler ABI information. 44 | set(CMAKE_C_SIZEOF_DATA_PTR "4") 45 | set(CMAKE_C_COMPILER_ABI "") 46 | set(CMAKE_C_LIBRARY_ARCHITECTURE "") 47 | 48 | if(CMAKE_C_SIZEOF_DATA_PTR) 49 | set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") 50 | endif() 51 | 52 | if(CMAKE_C_COMPILER_ABI) 53 | set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") 54 | endif() 55 | 56 | if(CMAKE_C_LIBRARY_ARCHITECTURE) 57 | set(CMAKE_LIBRARY_ARCHITECTURE "") 58 | endif() 59 | 60 | set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "") 61 | if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) 62 | set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") 63 | endif() 64 | 65 | 66 | 67 | 68 | 69 | set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "") 70 | set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "") 71 | set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") 72 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeDetermineCompilerABI_C.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeDetermineCompilerABI_C.bin -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeDetermineCompilerABI_CXX.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeDetermineCompilerABI_CXX.bin -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeRCCompiler.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_RC_COMPILER "rc") 2 | set(CMAKE_RC_COMPILER_ARG1 "") 3 | set(CMAKE_RC_COMPILER_LOADED 1) 4 | set(CMAKE_RC_SOURCE_FILE_EXTENSIONS rc;RC) 5 | set(CMAKE_RC_OUTPUT_EXTENSION .res) 6 | set(CMAKE_RC_COMPILER_ENV_VAR "RC") 7 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CMakeSystem.cmake: -------------------------------------------------------------------------------- 1 | set(CMAKE_HOST_SYSTEM "Windows-10.0.14393") 2 | set(CMAKE_HOST_SYSTEM_NAME "Windows") 3 | set(CMAKE_HOST_SYSTEM_VERSION "10.0.14393") 4 | set(CMAKE_HOST_SYSTEM_PROCESSOR "AMD64") 5 | 6 | 7 | 8 | set(CMAKE_SYSTEM "Windows-10.0.14393") 9 | set(CMAKE_SYSTEM_NAME "Windows") 10 | set(CMAKE_SYSTEM_VERSION "10.0.14393") 11 | set(CMAKE_SYSTEM_PROCESSOR "AMD64") 12 | 13 | set(CMAKE_CROSSCOMPILING "FALSE") 14 | 15 | set(CMAKE_SYSTEM_LOADED 1) 16 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CompilerIdC/CompilerIdC.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CompilerIdC/CompilerIdC.exe -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CompilerIdCXX/CompilerIdCXX.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/CompilerIdCXX/CompilerIdCXX.exe -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/VCTargetsPath.txt: -------------------------------------------------------------------------------- 1 | D:/Visual Studio 2017/Common7/IDE/VC/VCTargets 2 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/3.9.0/VCTargetsPath.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | 10 | {F3FC6D86-508D-3FB1-96D2-995F08B142EC} 11 | Win32Proj 12 | Win32 13 | 10.0.15063.0 14 | 15 | 16 | 17 | Utility 18 | MultiByte 19 | v141 20 | 21 | 22 | 23 | 24 | echo VCTargetsPath=$(VCTargetsPath) 25 | 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/846baea37f8f402297f043c9b2187413/generate.stamp.rule: -------------------------------------------------------------------------------- 1 | # generated from CMake 2 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/TargetDirectories.txt: -------------------------------------------------------------------------------- 1 | E:/myproject/[Collection] cef/Cef3 Soui Demo/Cef2623/libcef_dll_wrapper/CMakeFiles/libcef_dll_wrapper.dir 2 | E:/myproject/[Collection] cef/Cef3 Soui Demo/Cef2623/libcef_dll_wrapper/CMakeFiles/ALL_BUILD.dir 3 | E:/myproject/[Collection] cef/Cef3 Soui Demo/Cef2623/libcef_dll_wrapper/CMakeFiles/ZERO_CHECK.dir 4 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/cmake.check_cache: -------------------------------------------------------------------------------- 1 | # This file is generated by cmake for dependency checking of the CMakeCache.txt file 2 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/feature_tests.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef2623/libcef_dll_wrapper/CMakeFiles/feature_tests.bin -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/generate.stamp: -------------------------------------------------------------------------------- 1 | # CMake generation timestamp file for this directory. 2 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/CMakeFiles/generate.stamp.list: -------------------------------------------------------------------------------- 1 | E:/myproject/[Collection] cef/Cef3 Soui Demo/Cef2623/libcef_dll_wrapper/CMakeFiles/generate.stamp 2 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/ZERO_CHECK.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | CMake Rules 6 | 7 | 8 | 9 | 10 | {ACE743A0-CED3-365A-9606-7E71E1AAC18E} 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /Cef2623/libcef_dll_wrapper/cmake_install.cmake: -------------------------------------------------------------------------------- 1 | # Install script for directory: E:/myproject/[Collection] cef/Cef3 Soui Demo/Cef2623/libcef_dll 2 | 3 | # Set the install prefix 4 | if(NOT DEFINED CMAKE_INSTALL_PREFIX) 5 | set(CMAKE_INSTALL_PREFIX "C:/Program Files (x86)/Project") 6 | endif() 7 | string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") 8 | 9 | # Set the install configuration name. 10 | if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) 11 | if(BUILD_TYPE) 12 | string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" 13 | CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") 14 | else() 15 | set(CMAKE_INSTALL_CONFIG_NAME "Release") 16 | endif() 17 | message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") 18 | endif() 19 | 20 | # Set the component getting installed. 21 | if(NOT CMAKE_INSTALL_COMPONENT) 22 | if(COMPONENT) 23 | message(STATUS "Install component: \"${COMPONENT}\"") 24 | set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") 25 | else() 26 | set(CMAKE_INSTALL_COMPONENT) 27 | endif() 28 | endif() 29 | 30 | if(CMAKE_INSTALL_COMPONENT) 31 | set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") 32 | else() 33 | set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") 34 | endif() 35 | 36 | string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT 37 | "${CMAKE_INSTALL_MANIFEST_FILES}") 38 | file(WRITE "E:/myproject/[Collection] cef/Cef3 Soui Demo/Cef2623/libcef_dll_wrapper/${CMAKE_INSTALL_MANIFEST}" 39 | "${CMAKE_INSTALL_MANIFEST_CONTENT}") 40 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/Cef3 Soui Demo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/Cef3 Soui Demo.cpp -------------------------------------------------------------------------------- /Cef3 Soui Demo/Cef3 Soui Demo.rc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/Cef3 Soui Demo.rc -------------------------------------------------------------------------------- /Cef3 Soui Demo/CefWebView/BrowserHandler.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/CefWebView/BrowserHandler.cpp -------------------------------------------------------------------------------- /Cef3 Soui Demo/CefWebView/Cef3WebView.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/CefWebView/Cef3WebView.cpp -------------------------------------------------------------------------------- /Cef3 Soui Demo/CefWebView/Cef3WebView.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/CefWebView/Cef3WebView.h -------------------------------------------------------------------------------- /Cef3 Soui Demo/CefWebView/CefClientApp.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #ifndef CEF_TESTS_CEFCLIENT_CLIENT_APP_H_ 6 | #define CEF_TESTS_CEFCLIENT_CLIENT_APP_H_ 7 | 8 | #pragma once 9 | #include "include/cef_app.h" 10 | 11 | class CefClientApp : public CefApp 12 | { 13 | public: 14 | CefClientApp(); 15 | 16 | // 17 | // CefApp methods 18 | // 19 | virtual void OnBeforeCommandLineProcessing( 20 | const CefString& process_type, 21 | CefRefPtr command_line) OVERRIDE; 22 | 23 | // ------------------------------------------------------------------------------ 24 | // 25 | // methods for user 26 | // 27 | // ------------------------------------------------------------------------------ 28 | 29 | public: 30 | static BOOL Initialize(); 31 | static void UnInitialize(); 32 | static void RunMessageLoop(); 33 | static void DoMessageLoopWork(); 34 | static int GetOpenedBrowserCount(); 35 | static int AddOpenedBrowserCount(); 36 | static int DelOpenedBrowserCount(); 37 | 38 | IMPLEMENT_REFCOUNTING(CefClientApp); 39 | 40 | private: 41 | static int m_nBrowserOpened; 42 | }; 43 | 44 | #endif // CEF_TESTS_CEFCLIENT_CLIENT_APP_H_ 45 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/CefWebView/CefUtil.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights 2 | // reserved. Use of this source code is governed by a BSD-style license that 3 | // can be found in the LICENSE file. 4 | 5 | #ifndef CEF_TESTS_CEFCLIENT_UTIL_H_ 6 | #define CEF_TESTS_CEFCLIENT_UTIL_H_ 7 | 8 | #pragma once 9 | #include "include/cef_task.h" 10 | #include // NOLINT(build/include_order) 11 | 12 | #ifndef ASSERT 13 | #ifndef NDEBUG 14 | #define ASSERT(condition) if (!(condition)) { DebugBreak(); } 15 | #else 16 | #define ASSERT(condition) ((void)0) 17 | #endif 18 | #endif 19 | 20 | #define REQUIRE_UI_THREAD() ASSERT(CefCurrentlyOn(TID_UI)); 21 | #define REQUIRE_IO_THREAD() ASSERT(CefCurrentlyOn(TID_IO)); 22 | #define REQUIRE_FILE_THREAD() ASSERT(CefCurrentlyOn(TID_FILE)); 23 | 24 | int GetCefMouseModifiers(WPARAM wparam); 25 | int GetCefKeyboardModifiers(WPARAM wparam, LPARAM lparam); 26 | BOOL IsKeyDown(WPARAM wparam); 27 | CefKeyEvent ToCefKeyEvent(UINT message, WPARAM wParam, LPARAM lParam); 28 | 29 | #endif // CEF_TESTS_CEFCLIENT_UTIL_H_ 30 | #pragma once 31 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/CefWebView/ExtendEvents.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/CefWebView/ExtendEvents.h -------------------------------------------------------------------------------- /Cef3 Soui Demo/MainDlg.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/MainDlg.cpp -------------------------------------------------------------------------------- /Cef3 Soui Demo/MainDlg.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/MainDlg.h -------------------------------------------------------------------------------- /Cef3 Soui Demo/TestHTML/test.htm: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/WebProcess/HTMLEventHandler.cpp: -------------------------------------------------------------------------------- 1 | #include "HtmlEventHandler.h" 2 | 3 | bool HtmlEventHandler::Execute(const CefString& name, 4 | CefRefPtr object, 5 | const CefV8ValueList& arguments, 6 | CefRefPtr& retval, 7 | CefString& exception) 8 | { 9 | if (name != "HandleEvent" || arguments.size() == 0) 10 | { 11 | return true; 12 | } 13 | 14 | CefRefPtr browser = 15 | CefV8Context::GetCurrentContext()->GetBrowser(); 16 | 17 | CefRefPtr message = 18 | CefProcessMessage::Create(arguments[0]->GetStringValue()); 19 | 20 | message->GetArgumentList()->SetSize(arguments.size() - 1); 21 | for (size_t i = 1; i < arguments.size(); ++i) 22 | { 23 | message->GetArgumentList()->SetString(i - 1, arguments[i]->GetStringValue()); 24 | } 25 | 26 | browser->SendProcessMessage(PID_BROWSER, message); 27 | 28 | return false; 29 | } -------------------------------------------------------------------------------- /Cef3 Soui Demo/WebProcess/HTMLEventHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "include/cef_app.h" 4 | #include "include/cef_v8.h" 5 | 6 | class HtmlEventHandler : public CefV8Handler { 7 | public: 8 | HtmlEventHandler() {} 9 | 10 | virtual bool Execute(const CefString& name, 11 | CefRefPtr object, 12 | const CefV8ValueList& arguments, 13 | CefRefPtr& retval, 14 | CefString& exception) OVERRIDE; 15 | 16 | // Provide the reference counting implementation for this class. 17 | IMPLEMENT_REFCOUNTING(HtmlEventHandler); 18 | }; 19 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/WebProcess/SubProcessClientApp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "include/cef_app.h" 4 | 5 | class CefClient; 6 | 7 | class SubProcessClientApp : public CefApp 8 | , public CefRenderProcessHandler 9 | { 10 | public: 11 | 12 | SubProcessClientApp() {} 13 | ~SubProcessClientApp() {} 14 | 15 | static CefRefPtr& Instance(); 16 | static int CefAppInitialize(); 17 | static void CefAppDeInitialize(); 18 | 19 | virtual void OnBeforeCommandLineProcessing( 20 | const CefString& process_type, 21 | CefRefPtr command_line) OVERRIDE; 22 | 23 | // CefApp methods: 24 | //virtual CefRefPtr GetBrowserProcessHandler() OVERRIDE { return this; } 25 | virtual CefRefPtr GetRenderProcessHandler() OVERRIDE { return this; } 26 | 27 | // 28 | // CefRenderProcessHandler methods: 29 | // 30 | 31 | virtual void OnContextCreated(CefRefPtr browser, 32 | CefRefPtr frame, 33 | CefRefPtr context) OVERRIDE; 34 | 35 | virtual void OnUncaughtException(CefRefPtr browser, 36 | CefRefPtr frame, 37 | CefRefPtr context, 38 | CefRefPtr exception, 39 | CefRefPtr stackTrace) OVERRIDE; 40 | 41 | virtual bool OnProcessMessageReceived( 42 | CefRefPtr browser, 43 | CefProcessId source_process, 44 | CefRefPtr message) OVERRIDE; 45 | 46 | private: 47 | IMPLEMENT_REFCOUNTING(SubProcessClientApp); 48 | }; 49 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/WebProcess/WebProcess.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | 头文件 20 | 21 | 22 | 头文件 23 | 24 | 25 | 26 | 27 | 源文件 28 | 29 | 30 | 源文件 31 | 32 | 33 | 源文件 34 | 35 | 36 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/WebProcess/main.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/WebProcess/main.cpp -------------------------------------------------------------------------------- /Cef3 Soui Demo/license.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/license.txt -------------------------------------------------------------------------------- /Cef3 Soui Demo/readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/readme.txt -------------------------------------------------------------------------------- /Cef3 Soui Demo/res/resource.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/res/resource.h -------------------------------------------------------------------------------- /Cef3 Soui Demo/res/soui_res.rc2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/res/soui_res.rc2 -------------------------------------------------------------------------------- /Cef3 Soui Demo/resource.h: -------------------------------------------------------------------------------- 1 | //{{NO_DEPENDENCIES}} 2 | // Microsoft Visual C++ generated include file. 3 | // Used by Cef3 Soui Demo.rc 4 | // 5 | 6 | // Next default values for new objects 7 | // 8 | #ifdef APSTUDIO_INVOKED 9 | #ifndef APSTUDIO_READONLY_SYMBOLS 10 | #define _APS_NEXT_RESOURCE_VALUE 114 11 | #define _APS_NEXT_COMMAND_VALUE 40037 12 | #define _APS_NEXT_CONTROL_VALUE 1000 13 | #define _APS_NEXT_SYMED_VALUE 101 14 | #endif 15 | #endif 16 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // stdafx.cpp : source file that includes just the standard includes 2 | // SkinTest.pch will be the pre-compiled header 3 | // stdafx.obj will contain the pre-compiled type information 4 | 5 | #include "stdafx.h" 6 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/stdafx.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/stdafx.h -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/image/soui.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangying2016/Cef3-Soui-Demo/b0da3cf34869bc7d5e8fc669fa4efbf00c419473/Cef3 Soui Demo/uires/image/soui.ico -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/uidef/init.xml: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/uires.idx: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/values/color.xml: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/values/skin.xml: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/values/string.xml: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | <ver value="1.0"/> 5 | </string> 6 | -------------------------------------------------------------------------------- /Cef3 Soui Demo/uires/xml/dlg_main.xml: -------------------------------------------------------------------------------- 1 | <SOUI name="mainWindow" title="@string/title" bigIcon="ICON_LOGO:32" smallIcon="ICON_LOGO:16" width="600" height="400" margin="20,5,5,5" resizable="1" wndType="appMain" 2 | appWnd="1" 3 | translucent="1" 4 | > 5 | <root skin="_skin.sys.wnd.bkgnd" cache="1"> 6 | <caption pos="0,0,-0,30" show="1" font="adding:0"> 7 | <icon pos="10,8" src="ICON_LOGO:16"/> 8 | <text pos="29,9">@string/title</text> 9 | <imgbtn name="btn_close" skin="_skin.sys.btn.close" pos="-45,0" tip="close" animate="1"/> 10 | <imgbtn name="btn_max" skin="_skin.sys.btn.maximize" pos="-83,0" animate="1" /> 11 | <imgbtn name="btn_restore" skin="_skin.sys.btn.restore" pos="-83,0" show="0" animate="1" /> 12 | <imgbtn name="btn_min" skin="_skin.sys.btn.minimize" pos="-121,0" animate="1" /> 13 | </caption> 14 | 15 | <window pos="5,[2,-5,-5"> 16 | <edit pos="2,2,-120,@30" name="edit_input_url" inset="5,0,5,-0" colorBkgnd="#aaaaaa">file:///TestHTML/test.htm</edit> 17 | <button pos="[5,{,@50,@25" name="btn_go" focusable="0">Go</button> 18 | <button pos="[5,{,@50,@25" name="btn_run_js" focusable="0">Run Js</button> 19 | <cef pos="0,[,-0,-0" name="cef_browser" url="file:///TestHTML/test.htm" colorBkgnd="#eeeeee"/> 20 | </window> 21 | </root> 22 | </SOUI> 23 | --------------------------------------------------------------------------------