bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-03-30 03:40:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Improve inheritance support in the CEF API (issue #1623).

Browse Source 
- Support single parent inheritance in CEF API classes.
- Support non-virtual inheritance in CEF API classes.
- Support translation of CEF API sub-directories.
- Add test sub-directories for testing-only functionality that will be
  available to unit tests but not exposed via the binary distribution.
- Add unit tests for the translator tool.
- Fix parsing of template parameter types that include commas.
This commit is contained in:
Marshall Greenblatt 2015-04-26 21:40:01 +03:00
parent 4715a1644e
commit 616fdbf3ff
408 changed files with 13269 additions and 4680 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cef.gyp
View File

@ -444,6 +444,7 @@
'tests/unittests/test_util.cc',
'tests/unittests/test_util.h',
'tests/unittests/tracing_unittest.cc',
'tests/unittests/translator_unittest.cc',
'tests/unittests/urlrequest_unittest.cc',
'tests/unittests/v8_unittest.cc',
'tests/unittests/values_unittest.cc',
@ -1088,6 +1089,7 @@
'libcef/common/task_impl.cc',
'libcef/common/task_runner_impl.cc',
'libcef/common/task_runner_impl.h',
'libcef/common/test/translator_test_impl.cc',
'libcef/common/time_impl.cc',
'libcef/common/time_util.h',
'libcef/common/tracker.cc',

26
cef_paths.gypi
View File

@ -67,6 +67,7 @@
'include/cef_web_plugin.h',
'include/cef_xml_reader.h',
'include/cef_zip_reader.h',
'include/test/cef_translator_test.h',
],
'autogen_capi_includes': [
'include/capi/cef_app_capi.h',
@ -124,6 +125,7 @@
'include/capi/cef_web_plugin_capi.h',
'include/capi/cef_xml_reader_capi.h',
'include/capi/cef_zip_reader_capi.h',
'include/capi/test/cef_translator_test_capi.h',
],
'autogen_library_side': [
'libcef_dll/ctocpp/app_ctocpp.cc',
@ -272,6 +274,18 @@
'libcef_dll/ctocpp/task_ctocpp.h',
'libcef_dll/cpptoc/task_runner_cpptoc.cc',
'libcef_dll/cpptoc/task_runner_cpptoc.h',
'libcef_dll/cpptoc/test/translator_test_cpptoc.cc',
'libcef_dll/cpptoc/test/translator_test_cpptoc.h',
'libcef_dll/ctocpp/test/translator_test_handler_ctocpp.cc',
'libcef_dll/ctocpp/test/translator_test_handler_ctocpp.h',
'libcef_dll/ctocpp/test/translator_test_handler_child_ctocpp.cc',
'libcef_dll/ctocpp/test/translator_test_handler_child_ctocpp.h',
'libcef_dll/cpptoc/test/translator_test_object_cpptoc.cc',
'libcef_dll/cpptoc/test/translator_test_object_cpptoc.h',
'libcef_dll/cpptoc/test/translator_test_object_child_cpptoc.cc',
'libcef_dll/cpptoc/test/translator_test_object_child_cpptoc.h',
'libcef_dll/cpptoc/test/translator_test_object_child_child_cpptoc.cc',
'libcef_dll/cpptoc/test/translator_test_object_child_child_cpptoc.h',
'libcef_dll/cpptoc/urlrequest_cpptoc.cc',
'libcef_dll/cpptoc/urlrequest_cpptoc.h',
'libcef_dll/ctocpp/urlrequest_client_ctocpp.cc',
@ -452,6 +466,18 @@
'libcef_dll/cpptoc/task_cpptoc.h',
'libcef_dll/ctocpp/task_runner_ctocpp.cc',
'libcef_dll/ctocpp/task_runner_ctocpp.h',
'libcef_dll/ctocpp/test/translator_test_ctocpp.cc',
'libcef_dll/ctocpp/test/translator_test_ctocpp.h',
'libcef_dll/cpptoc/test/translator_test_handler_cpptoc.cc',
'libcef_dll/cpptoc/test/translator_test_handler_cpptoc.h',
'libcef_dll/cpptoc/test/translator_test_handler_child_cpptoc.cc',
'libcef_dll/cpptoc/test/translator_test_handler_child_cpptoc.h',
'libcef_dll/ctocpp/test/translator_test_object_ctocpp.cc',
'libcef_dll/ctocpp/test/translator_test_object_ctocpp.h',
'libcef_dll/ctocpp/test/translator_test_object_child_ctocpp.cc',
'libcef_dll/ctocpp/test/translator_test_object_child_ctocpp.h',
'libcef_dll/ctocpp/test/translator_test_object_child_child_ctocpp.cc',
'libcef_dll/ctocpp/test/translator_test_object_child_child_ctocpp.h',
'libcef_dll/ctocpp/urlrequest_ctocpp.cc',
'libcef_dll/ctocpp/urlrequest_ctocpp.h',
'libcef_dll/cpptoc/urlrequest_client_cpptoc.cc',

6
cef_paths2.gypi
View File

@ -95,12 +95,15 @@
],
'libcef_sources_common': [
'libcef_dll/cpptoc/cpptoc.h',
'libcef_dll/ctocpp/base_ctocpp.cc',
'libcef_dll/ctocpp/base_ctocpp.h',
'libcef_dll/ctocpp/ctocpp.h',
'libcef_dll/libcef_dll.cc',
'libcef_dll/libcef_dll2.cc',
'libcef_dll/resource.h',
'libcef_dll/transfer_util.cc',
'libcef_dll/transfer_util.h',
'libcef_dll/wrapper_types.h',
'<@(autogen_library_side)',
],
'libcef_dll_wrapper_sources_common': [
@ -116,12 +119,13 @@
'libcef_dll/base/cef_thread_checker_impl.cc',
'libcef_dll/base/cef_thread_collision_warner.cc',
'libcef_dll/base/cef_weak_ptr.cc',
'libcef_dll/cpptoc/base_cpptoc.cc',
'libcef_dll/cpptoc/base_cpptoc.h',
'libcef_dll/cpptoc/cpptoc.h',
'libcef_dll/ctocpp/base_ctocpp.h',
'libcef_dll/ctocpp/ctocpp.h',
'libcef_dll/transfer_util.cc',
'libcef_dll/transfer_util.h',
'libcef_dll/wrapper_types.h',
'libcef_dll/wrapper/cef_browser_info_map.h',
'libcef_dll/wrapper/cef_byte_read_handler.cc',
'libcef_dll/wrapper/cef_closure_task.cc',

3
include/capi/cef_base_capi.h
View File

@ -77,7 +77,8 @@ typedef struct _cef_base_t {
// Check that the structure |s|, which is defined with a cef_base_t member named
// |base|, is large enough to contain the specified member |f|.
#define CEF_MEMBER_EXISTS(s, f) \
((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= (s)->base.size)
((intptr_t)&((s)->f) - (intptr_t)(s) + sizeof((s)->f) <= \
reinterpret_cast<cef_base_t*>(s)->size)
#define CEF_MEMBER_MISSING(s, f) (!CEF_MEMBER_EXISTS(s, f) || !((s)->f))

493
include/capi/test/cef_translator_test_capi.h Normal file
View File

@ -0,0 +1,493 @@
// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the name Chromium Embedded
// Framework nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool and should not edited
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
#ifndef CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_
#define CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_
#pragma once
#include "include/capi/cef_base_capi.h"
#ifdef __cplusplus
extern "C" {
#endif
struct _cef_translator_test_handler_child_t;
struct _cef_translator_test_handler_t;
struct _cef_translator_test_object_child_t;
struct _cef_translator_test_object_t;
///
// Structure for testing all of the possible data transfer types.
///
typedef struct _cef_translator_test_t {
///
// Base structure.
///
cef_base_t base;
// PRIMITIVE VALUES
///
// Return a void value.
///
void (CEF_CALLBACK *get_void)(struct _cef_translator_test_t* self);
///
// Return a bool value.
///
int (CEF_CALLBACK *get_bool)(struct _cef_translator_test_t* self);
///
// Return an int value.
///
int (CEF_CALLBACK *get_int)(struct _cef_translator_test_t* self);
///
// Return a double value.
///
double (CEF_CALLBACK *get_double)(struct _cef_translator_test_t* self);
///
// Return a long value.
///
long (CEF_CALLBACK *get_long)(struct _cef_translator_test_t* self);
///
// Return a size_t value.
///
size_t (CEF_CALLBACK *get_sizet)(struct _cef_translator_test_t* self);
///
// Set a void value.
///
int (CEF_CALLBACK *set_void)(struct _cef_translator_test_t* self);
///
// Set a bool value.
///
int (CEF_CALLBACK *set_bool)(struct _cef_translator_test_t* self, int val);
///
// Set an int value.
///
int (CEF_CALLBACK *set_int)(struct _cef_translator_test_t* self, int val);
///
// Set a double value.
///
int (CEF_CALLBACK *set_double)(struct _cef_translator_test_t* self,
double val);
///
// Set a long value.
///
int (CEF_CALLBACK *set_long)(struct _cef_translator_test_t* self, long val);
///
// Set a size_t value.
///
int (CEF_CALLBACK *set_sizet)(struct _cef_translator_test_t* self,
size_t val);
///
// Set a int list value.
///
int (CEF_CALLBACK *set_int_list)(struct _cef_translator_test_t* self,
size_t valCount, int const* val);
///
// Return an int list value by out-param.
///
int (CEF_CALLBACK *get_int_list_by_ref)(struct _cef_translator_test_t* self,
size_t* valCount, int* val);
///
// Return the number of points that will be output above.
///
size_t (CEF_CALLBACK *get_int_list_size)(struct _cef_translator_test_t* self);
// STRING VALUES
///
// Return a string value.
///
// The resulting string must be freed by calling cef_string_userfree_free().
cef_string_userfree_t (CEF_CALLBACK *get_string)(
struct _cef_translator_test_t* self);
///
// Set a string value.
///
int (CEF_CALLBACK *set_string)(struct _cef_translator_test_t* self,
const cef_string_t* val);
///
// Return a string value by out-param.
///
void (CEF_CALLBACK *get_string_by_ref)(struct _cef_translator_test_t* self,
cef_string_t* val);
///
// Set a string list value.
///
int (CEF_CALLBACK *set_string_list)(struct _cef_translator_test_t* self,
cef_string_list_t val);
///
// Return a string list value by out-param.
///
int (CEF_CALLBACK *get_string_list_by_ref)(
struct _cef_translator_test_t* self, cef_string_list_t val);
///
// Set a string map value.
///
int (CEF_CALLBACK *set_string_map)(struct _cef_translator_test_t* self,
cef_string_map_t val);
///
// Return a string map value by out-param.
///
int (CEF_CALLBACK *get_string_map_by_ref)(struct _cef_translator_test_t* self,
cef_string_map_t val);
///
// Set a string multimap value.
///
int (CEF_CALLBACK *set_string_multimap)(struct _cef_translator_test_t* self,
cef_string_multimap_t val);
///
// Return a string multimap value by out-param.
///
int (CEF_CALLBACK *get_string_multimap_by_ref)(
struct _cef_translator_test_t* self, cef_string_multimap_t val);
// STRUCT VALUES
///
// Return a point value.
///
cef_point_t (CEF_CALLBACK *get_point)(struct _cef_translator_test_t* self);
///
// Set a point value.
///
int (CEF_CALLBACK *set_point)(struct _cef_translator_test_t* self,
const cef_point_t* val);
///
// Return a point value by out-param.
///
void (CEF_CALLBACK *get_point_by_ref)(struct _cef_translator_test_t* self,
cef_point_t* val);
///
// Set a point list vlaue.
///
int (CEF_CALLBACK *set_point_list)(struct _cef_translator_test_t* self,
size_t valCount, cef_point_t const* val);
///
// Return a point list value by out-param.
///
int (CEF_CALLBACK *get_point_list_by_ref)(struct _cef_translator_test_t* self,
size_t* valCount, cef_point_t* val);
///
// Return the number of points that will be output above.
///
size_t (CEF_CALLBACK *get_point_list_size)(
struct _cef_translator_test_t* self);
// LIBRARY-SIDE OBJECT VALUES
///
// Return an new library-side object.
///
struct _cef_translator_test_object_t* (CEF_CALLBACK *get_object)(
struct _cef_translator_test_t* self, int val);
///
// Set an object. Returns the value from
// cef_translator_test_object_t::get_value(). This tests input and execution
// of a library-side object type.
///
int (CEF_CALLBACK *set_object)(struct _cef_translator_test_t* self,
struct _cef_translator_test_object_t* val);
///
// Set an object. Returns the object passed in. This tests input and output of
// a library-side object type.
///
struct _cef_translator_test_object_t* (CEF_CALLBACK *set_object_and_return)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_object_t* val);
///
// Set a child object. Returns the value from
// cef_translator_test_object_t::get_value(). This tests input of a library-
// side child object type and execution as the parent type.
///
int (CEF_CALLBACK *set_child_object)(struct _cef_translator_test_t* self,
struct _cef_translator_test_object_child_t* val);
///
// Set a child object. Returns the object as the parent type. This tests input
// of a library-side child object type and return as the parent type.
///
struct _cef_translator_test_object_t* (
CEF_CALLBACK *set_child_object_and_return_parent)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_object_child_t* val);
///
// Set an object list vlaue.
///
int (CEF_CALLBACK *set_object_list)(struct _cef_translator_test_t* self,
size_t valCount, struct _cef_translator_test_object_t* const* val,
int val1, int val2);
///
// Return an object list value by out-param.
///
int (CEF_CALLBACK *get_object_list_by_ref)(
struct _cef_translator_test_t* self, size_t* valCount,
struct _cef_translator_test_object_t** val, int val1, int val2);
///
// Return the number of object that will be output above.
///
size_t (CEF_CALLBACK *get_object_list_size)(
struct _cef_translator_test_t* self);
// CLIENT-SIDE OBJECT VALUES
///
// Set an object. Returns the value from
// cef_translator_test_handler_t::get_value(). This tests input and execution
// of a client-side object type.
///
int (CEF_CALLBACK *set_handler)(struct _cef_translator_test_t* self,
struct _cef_translator_test_handler_t* val);
///
// Set an object. Returns the handler passed in. This tests input and output
// of a client-side object type.
///
struct _cef_translator_test_handler_t* (CEF_CALLBACK *set_handler_and_return)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_handler_t* val);
///
// Set a child object. Returns the value from
// cef_translator_test_handler_t::get_value(). This tests input of a client-
// side child object type and execution as the parent type.
///
int (CEF_CALLBACK *set_child_handler)(struct _cef_translator_test_t* self,
struct _cef_translator_test_handler_child_t* val);
///
// Set a child object. Returns the object as the parent type. This tests input
// of a client-side child object type and return as the parent type.
///
struct _cef_translator_test_handler_t* (
CEF_CALLBACK *set_child_handler_and_return_parent)(
struct _cef_translator_test_t* self,
struct _cef_translator_test_handler_child_t* val);
///
// Set an object list vlaue.
///
int (CEF_CALLBACK *set_handler_list)(struct _cef_translator_test_t* self,
size_t valCount, struct _cef_translator_test_handler_t* const* val,
int val1, int val2);
///
// Return an object list value by out-param.
///
int (CEF_CALLBACK *get_handler_list_by_ref)(
struct _cef_translator_test_t* self, size_t* valCount,
struct _cef_translator_test_handler_t** val,
struct _cef_translator_test_handler_t* val1,
struct _cef_translator_test_handler_t* val2);
///
// Return the number of object that will be output above.
///
size_t (CEF_CALLBACK *get_handler_list_size)(
struct _cef_translator_test_t* self);
} cef_translator_test_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_t* cef_translator_test_create();
///
// Library-side test object.
///
typedef struct _cef_translator_test_object_t {
///
// Base structure.
///
cef_base_t base;
///
// Return a value.
///
int (CEF_CALLBACK *get_value)(struct _cef_translator_test_object_t* self);
///
// Set a value.
///
void (CEF_CALLBACK *set_value)(struct _cef_translator_test_object_t* self,
int value);
} cef_translator_test_object_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_object_t* cef_translator_test_object_create(
int value);
///
// Library-side child test object.
///
typedef struct _cef_translator_test_object_child_t {
///
// Base structure.
///
cef_translator_test_object_t base;
///
// Return a value.
///
int (CEF_CALLBACK *get_other_value)(
struct _cef_translator_test_object_child_t* self);
///
// Set a value.
///
void (CEF_CALLBACK *set_other_value)(
struct _cef_translator_test_object_child_t* self, int value);
} cef_translator_test_object_child_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_object_child_t* cef_translator_test_object_child_create(
int value, int other_value);
///
// Another library-side child test object.
///
typedef struct _cef_translator_test_object_child_child_t {
///
// Base structure.
///
cef_translator_test_object_child_t base;
///
// Return a value.
///
int (CEF_CALLBACK *get_other_other_value)(
struct _cef_translator_test_object_child_child_t* self);
///
// Set a value.
///
void (CEF_CALLBACK *set_other_other_value)(
struct _cef_translator_test_object_child_child_t* self, int value);
} cef_translator_test_object_child_child_t;
///
// Create the test object.
///
CEF_EXPORT cef_translator_test_object_child_child_t* cef_translator_test_object_child_child_create(
int value, int other_value, int other_other_value);
///
// Client-side test object.
///
typedef struct _cef_translator_test_handler_t {
///
// Base structure.
///
cef_base_t base;
///
// Return a value.
///
int (CEF_CALLBACK *get_value)(struct _cef_translator_test_handler_t* self);
} cef_translator_test_handler_t;
///
// Client-side child test object.
///
typedef struct _cef_translator_test_handler_child_t {
///
// Base structure.
///
cef_translator_test_handler_t base;
///
// Return a value.
///
int (CEF_CALLBACK *get_other_value)(
struct _cef_translator_test_handler_child_t* self);
} cef_translator_test_handler_child_t;
#ifdef __cplusplus
}
#endif
#endif // CEF_INCLUDE_CAPI_TEST_CEF_TRANSLATOR_TEST_CAPI_H_

543
include/test/cef_translator_test.h Normal file
View File

@ -0,0 +1,543 @@
// Copyright (c) 2015 Marshall A. Greenblatt. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the name Chromium Embedded
// Framework nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ---------------------------------------------------------------------------
//
// The contents of this file must follow a specific format in order to
// support the CEF translator tool. See the translator.README.txt file in the
// tools directory for more information.
//
// THIS FILE IS FOR TESTING PURPOSES ONLY.
//
// The APIs defined in this file are for testing purposes only. They will not be
// exposed via the binary distribution. All classes in this file must include
// the 'no_debugct_check' attribute to avoid problems when building the binary
// distribution.
//
#ifndef CEF_INCLUDE_TEST_CEF_TEST_H_
#define CEF_INCLUDE_TEST_CEF_TEST_H_
#pragma once
#include <map>
#include <vector>
#include "include/cef_base.h"
class CefTranslatorTestHandler;
class CefTranslatorTestHandlerChild;
class CefTranslatorTestObject;
class CefTranslatorTestObjectChild;
// Test values.
#define TEST_INT_VAL 5
#define TEST_INT_VAL2 60
#define TEST_BOOL_VAL true
#define TEST_DOUBLE_VAL 4.543
#define TEST_LONG_VAL -65
#define TEST_SIZET_VAL 3U
#define TEST_STRING_VAL "My test string"
#define TEST_STRING_VAL2 "My 2nd test string"
#define TEST_STRING_VAL3 "My 3rd test string"
#define TEST_STRING_KEY "key0"
#define TEST_STRING_KEY2 "key1"
#define TEST_STRING_KEY3 "key2"
#define TEST_X_VAL 44
#define TEST_Y_VAL 754
#define TEST_X_VAL2 900
#define TEST_Y_VAL2 300
///
// Class for testing all of the possible data transfer types.
///
/*--cef(source=library,no_debugct_check)--*/
class CefTranslatorTest : public CefBase {
public:
///
// Create the test object.
///
/*--cef()--*/
static CefRefPtr<CefTranslatorTest> Create();
// PRIMITIVE VALUES
///
// Return a void value.
///
/*--cef()--*/
virtual void GetVoid() =0;
///
// Return a bool value.
///
/*--cef()--*/
virtual bool GetBool() =0;
///
// Return an int value.
///
/*--cef()--*/
virtual int GetInt() =0;
///
// Return a double value.
///
/*--cef()--*/
virtual double GetDouble() =0;
///
// Return a long value.
///
/*--cef()--*/
virtual long GetLong() =0;
///
// Return a size_t value.
///
/*--cef()--*/
virtual size_t GetSizet() =0;
///
// Set a void value.
///
/*--cef()--*/
virtual bool SetVoid() =0;
///
// Set a bool value.
///
/*--cef()--*/
virtual bool SetBool(bool val) =0;
///
// Set an int value.
///
/*--cef()--*/
virtual bool SetInt(int val) =0;
///
// Set a double value.
///
/*--cef()--*/
virtual bool SetDouble(double val) =0;
///
// Set a long value.
///
/*--cef()--*/
virtual bool SetLong(long val) =0;
///
// Set a size_t value.
///
/*--cef()--*/
virtual bool SetSizet(size_t val) =0;
// PRIMITIVE LIST VALUES
// Test both with and without a typedef.
typedef std::vector<int> IntList;
///
// Set a int list value.
///
/*--cef()--*/
virtual bool SetIntList(const std::vector<int>& val) =0;
///
// Return an int list value by out-param.
///
/*--cef(count_func=val:GetIntListSize)--*/
virtual bool GetIntListByRef(IntList& val) =0;
///
// Return the number of points that will be output above.
///
/*--cef()--*/
virtual size_t GetIntListSize() = 0;
// STRING VALUES
///
// Return a string value.
///
/*--cef()--*/
virtual CefString GetString() =0;
///
// Set a string value.
///
/*--cef()--*/
virtual bool SetString(const CefString& val) =0;
///
// Return a string value by out-param.
///
/*--cef()--*/
virtual void GetStringByRef(CefString& val) =0;
// STRING LIST VALUES
// Test both with and without a typedef.
typedef std::vector<CefString> StringList;
///
// Set a string list value.
///
/*--cef()--*/
virtual bool SetStringList(const std::vector<CefString>& val) =0;
///
// Return a string list value by out-param.
///
/*--cef()--*/
virtual bool GetStringListByRef(StringList& val) =0;
// STRING MAP VALUES
// Test both with and without a typedef.
typedef std::map<CefString, CefString> StringMap;
///
// Set a string map value.
///
/*--cef()--*/
virtual bool SetStringMap(const StringMap& val) =0;
///
// Return a string map value by out-param.
///
/*--cef()--*/
virtual bool GetStringMapByRef(std::map<CefString, CefString>& val) =0;
// STRING MULTIMAP VALUES
// Test both with and without a typedef.
typedef std::multimap<CefString, CefString> StringMultimap;
///
// Set a string multimap value.
///
/*--cef()--*/
virtual bool SetStringMultimap(
const std::multimap<CefString, CefString>& val) =0;
///
// Return a string multimap value by out-param.
///
/*--cef()--*/
virtual bool GetStringMultimapByRef(StringMultimap& val) =0;
// STRUCT VALUES
///
// Return a point value.
///
/*--cef()--*/
virtual CefPoint GetPoint() =0;
///
// Set a point value.
///
/*--cef()--*/
virtual bool SetPoint(const CefPoint& val) =0;
///
// Return a point value by out-param.
///
/*--cef()--*/
virtual void GetPointByRef(CefPoint& val) =0;
// STRUCT LIST VALUES
// Test both with and without a typedef.
typedef std::vector<CefPoint> PointList;
///
// Set a point list vlaue.
///
/*--cef()--*/
virtual bool SetPointList(const std::vector<CefPoint>& val) =0;
///
// Return a point list value by out-param.
///
/*--cef(count_func=val:GetPointListSize)--*/
virtual bool GetPointListByRef(PointList& val) =0;
///
// Return the number of points that will be output above.
///
/*--cef()--*/
virtual size_t GetPointListSize() = 0;
// LIBRARY-SIDE OBJECT VALUES
///
// Return an new library-side object.
///
/*--cef()--*/
virtual CefRefPtr<CefTranslatorTestObject> GetObject(int val) =0;
///
// Set an object. Returns the value from CefTranslatorTestObject::GetValue().
// This tests input and execution of a library-side object type.
///
/*--cef()--*/
virtual int SetObject(CefRefPtr<CefTranslatorTestObject> val) =0;
///
// Set an object. Returns the object passed in. This tests input and output
// of a library-side object type.
///
/*--cef()--*/
virtual CefRefPtr<CefTranslatorTestObject> SetObjectAndReturn(
CefRefPtr<CefTranslatorTestObject> val) =0;
///
// Set a child object. Returns the value from
// CefTranslatorTestObject::GetValue(). This tests input of a library-side
// child object type and execution as the parent type.
///
/*--cef()--*/
virtual int SetChildObject(CefRefPtr<CefTranslatorTestObjectChild> val) =0;
///
// Set a child object. Returns the object as the parent type. This tests input
// of a library-side child object type and return as the parent type.
///
/*--cef()--*/
virtual CefRefPtr<CefTranslatorTestObject> SetChildObjectAndReturnParent(
CefRefPtr<CefTranslatorTestObjectChild> val) =0;
// LIBRARY-SIDE OBJECT LIST VALUES
// Test both with and without a typedef.
typedef std::vector<CefRefPtr<CefTranslatorTestObject> > ObjectList;
///
// Set an object list vlaue.
///
/*--cef()--*/
virtual bool SetObjectList(
const std::vector<CefRefPtr<CefTranslatorTestObject> >& val,
int val1, int val2) =0;
///
// Return an object list value by out-param.
///
/*--cef(count_func=val:GetObjectListSize)--*/
virtual bool GetObjectListByRef(ObjectList& val, int val1, int val2) =0;
///
// Return the number of object that will be output above.
///
/*--cef()--*/
virtual size_t GetObjectListSize() = 0;
// CLIENT-SIDE OBJECT VALUES
///
// Set an object. Returns the value from CefTranslatorTestHandler::GetValue().
// This tests input and execution of a client-side object type.
///
/*--cef()--*/
virtual int SetHandler(CefRefPtr<CefTranslatorTestHandler> val) =0;
///
// Set an object. Returns the handler passed in. This tests input and output
// of a client-side object type.
///
/*--cef()--*/
virtual CefRefPtr<CefTranslatorTestHandler> SetHandlerAndReturn(
CefRefPtr<CefTranslatorTestHandler> val) =0;
///
// Set a child object. Returns the value from
// CefTranslatorTestHandler::GetValue(). This tests input of a client-side
// child object type and execution as the parent type.
///
/*--cef()--*/
virtual int SetChildHandler(CefRefPtr<CefTranslatorTestHandlerChild> val) =0;
///
// Set a child object. Returns the object as the parent type. This tests
// input of a client-side child object type and return as the parent type.
///
/*--cef()--*/
virtual CefRefPtr<CefTranslatorTestHandler> SetChildHandlerAndReturnParent(
CefRefPtr<CefTranslatorTestHandlerChild> val) =0;
// CLIENT-SIDE OBJECT LIST VALUES
// Test both with and without a typedef.
typedef std::vector<CefRefPtr<CefTranslatorTestHandler> > HandlerList;
///
// Set an object list vlaue.
///
/*--cef()--*/
virtual bool SetHandlerList(
const std::vector<CefRefPtr<CefTranslatorTestHandler> >& val,
int val1, int val2) =0;
///
// Return an object list value by out-param.
///
/*--cef(count_func=val:GetObjectListSize)--*/
virtual bool GetHandlerListByRef(
HandlerList& val,
CefRefPtr<CefTranslatorTestHandler> val1,
CefRefPtr<CefTranslatorTestHandler> val2) =0;
///
// Return the number of object that will be output above.
///
/*--cef()--*/
virtual size_t GetHandlerListSize() = 0;
};
///
// Library-side test object.
///
/*--cef(source=library,no_debugct_check)--*/
class CefTranslatorTestObject : public CefBase {
public:
///
// Create the test object.
///
/*--cef()--*/
static CefRefPtr<CefTranslatorTestObject> Create(int value);
///
// Return a value.
///
/*--cef()--*/
virtual int GetValue() =0;
///
// Set a value.
///
/*--cef()--*/
virtual void SetValue(int value) =0;
};
///
// Library-side child test object.
///
/*--cef(source=library,no_debugct_check)--*/
class CefTranslatorTestObjectChild : public CefTranslatorTestObject {
public:
///
// Create the test object.
///
/*--cef()--*/
static CefRefPtr<CefTranslatorTestObjectChild> Create(int value,
int other_value);
///
// Return a value.
///
/*--cef()--*/
virtual int GetOtherValue() =0;
///
// Set a value.
///
/*--cef()--*/
virtual void SetOtherValue(int value) =0;
};
///
// Another library-side child test object.
///
/*--cef(source=library,no_debugct_check)--*/
class CefTranslatorTestObjectChildChild : public CefTranslatorTestObjectChild {
public:
///
// Create the test object.
///
/*--cef()--*/
static CefRefPtr<CefTranslatorTestObjectChildChild> Create(
int value,
int other_value,
int other_other_value);
///
// Return a value.
///
/*--cef()--*/
virtual int GetOtherOtherValue() =0;
///
// Set a value.
///
/*--cef()--*/
virtual void SetOtherOtherValue(int value) =0;
};
///
// Client-side test object.
///
/*--cef(source=client,no_debugct_check)--*/
class CefTranslatorTestHandler : public virtual CefBase {
public:
///
// Return a value.
///
/*--cef()--*/
virtual int GetValue() =0;
};
///
// Client-side child test object.
///
/*--cef(source=client,no_debugct_check)--*/
class CefTranslatorTestHandlerChild : public CefTranslatorTestHandler {
public:
///
// Return a value.
///
/*--cef()--*/
virtual int GetOtherValue() =0;
};
#endif // CEF_INCLUDE_TEST_CEF_TEST_H_

445
libcef/common/test/translator_test_impl.cc Normal file
View File

@ -0,0 +1,445 @@
// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that can
// be found in the LICENSE file.
#include "include/test/cef_translator_test.h"
class CefTranslatorTestObjectImpl : public CefTranslatorTestObject {
public:
explicit CefTranslatorTestObjectImpl(int value)
: value_(value) {
}
int GetValue() override {
return value_;
}
void SetValue(int value) override {
value_ = value;
}
protected:
int value_;
private:
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestObjectImpl);
IMPLEMENT_REFCOUNTING(CefTranslatorTestObjectImpl);
};
// static
CefRefPtr<CefTranslatorTestObject> CefTranslatorTestObject::Create(int value) {
return new CefTranslatorTestObjectImpl(value);
}
class CefTranslatorTestObjectChildImpl : public CefTranslatorTestObjectChild {
public:
CefTranslatorTestObjectChildImpl(int value, int other_value)
: value_(value),
other_value_(other_value) {
}
int GetValue() override {
return value_;
}
void SetValue(int value) override {
value_ = value;
}
int GetOtherValue() override {
return other_value_;
}
void SetOtherValue(int value) override {
other_value_ = value;
}
protected:
int value_;
int other_value_;
private:
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestObjectChildImpl);
IMPLEMENT_REFCOUNTING(CefTranslatorTestObjectChildImpl);
};
// static
CefRefPtr<CefTranslatorTestObjectChild> CefTranslatorTestObjectChild::Create(
int value,
int other_value) {
return new CefTranslatorTestObjectChildImpl(value, other_value);
}
class CefTranslatorTestObjectChildChildImpl :
public CefTranslatorTestObjectChildChild {
public:
CefTranslatorTestObjectChildChildImpl(int value,
int other_value,
int other_other_value)
: value_(value),
other_value_(other_value),
other_other_value_(other_other_value) {
}
int GetValue() override {
return value_;
}
void SetValue(int value) override {
value_ = value;
}
int GetOtherValue() override {
return other_value_;
}
void SetOtherValue(int value) override {
other_value_ = value;
}
int GetOtherOtherValue() override {
return other_other_value_;
}
void SetOtherOtherValue(int value) override {
other_other_value_ = value;
}
protected:
int value_;
int other_value_;
int other_other_value_;
private:
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestObjectChildChildImpl);
IMPLEMENT_REFCOUNTING(CefTranslatorTestObjectChildChildImpl);
};
// static
CefRefPtr<CefTranslatorTestObjectChildChild>
CefTranslatorTestObjectChildChild::Create(
int value,
int other_value,
int other_other_value) {
return new CefTranslatorTestObjectChildChildImpl(value, other_value,
other_other_value);
}
class CefTranslatorTestImpl : public CefTranslatorTest {
public:
CefTranslatorTestImpl() {
}
// PRIMITIVE VALUES
void GetVoid() override {
}
bool GetBool() override {
return TEST_BOOL_VAL;
}
int GetInt() override {
return TEST_INT_VAL;
}
double GetDouble() override {
return TEST_DOUBLE_VAL;
}
long GetLong() override {
return TEST_LONG_VAL;
}
size_t GetSizet() override {
return TEST_SIZET_VAL;
}
bool SetVoid() override {
return true;
}
bool SetBool(bool val) override {
return (val == TEST_BOOL_VAL);
}
bool SetInt(int val) override {
return (val == TEST_INT_VAL);
}
bool SetDouble(double val) override {
return (val == TEST_DOUBLE_VAL);
}
bool SetLong(long val) override {
return (val == TEST_LONG_VAL);
}
bool SetSizet(size_t val) override {
return (val == TEST_SIZET_VAL);
}
// PRIMITIVE LIST VALUES
bool SetIntList(const std::vector<int>& val) override {
if (val.size() != 2U)
return false;
return val[0] == TEST_INT_VAL && val[1] == TEST_INT_VAL2;
}
bool GetIntListByRef(IntList& val) override {
if (val.size() != GetIntListSize())
return false;
val.clear();
val.push_back(TEST_INT_VAL);
val.push_back(TEST_INT_VAL2);
return true;
}
size_t GetIntListSize() override {
return 2U;
}
// STRING VALUES
CefString GetString() override {
return TEST_STRING_VAL;
}
bool SetString(const CefString& val) override {
return (val.ToString() == TEST_STRING_VAL);
}
void GetStringByRef(CefString& val) override {
val = TEST_STRING_VAL;
}
// STRING LIST VALUES
bool SetStringList(const std::vector<CefString>& val) override {
if (val.size() != 3U)
return false;
return val[0] == TEST_STRING_VAL &&
val[1] == TEST_STRING_VAL2 &&
val[2] == TEST_STRING_VAL3;
}
bool GetStringListByRef(StringList& val) override {
if (val.size() != 0U)
return false;
val.push_back(TEST_STRING_VAL);
val.push_back(TEST_STRING_VAL2);
val.push_back(TEST_STRING_VAL3);
return true;
}
// STRING MAP VALUES
bool SetStringMap(const StringMap& val) override {
if (val.size() != 3U)
return false;
StringMap::const_iterator it;
it = val.find(TEST_STRING_KEY);
if (it == val.end() || it->second != TEST_STRING_VAL)
return false;
it = val.find(TEST_STRING_KEY2);
if (it == val.end() || it->second != TEST_STRING_VAL2)
return false;
it = val.find(TEST_STRING_KEY3);
if (it == val.end() || it->second != TEST_STRING_VAL3)
return false;
return true;
}
bool GetStringMapByRef(std::map<CefString, CefString>& val) override {
if (val.size() != 0U)
return false;
val.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
val.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
val.insert(std::make_pair(TEST_STRING_KEY3, TEST_STRING_VAL3));
return true;
}
// STRING MULTIMAP VALUES
bool SetStringMultimap(
const std::multimap<CefString, CefString>& val) override {
if (val.size() != 3U)
return false;
StringMultimap::const_iterator it;
it = val.find(TEST_STRING_KEY);
if (it == val.end() || it->second != TEST_STRING_VAL)
return false;
it = val.find(TEST_STRING_KEY2);
if (it == val.end() || it->second != TEST_STRING_VAL2)
return false;
it = val.find(TEST_STRING_KEY3);
if (it == val.end() || it->second != TEST_STRING_VAL3)
return false;
return true;
}
bool GetStringMultimapByRef(StringMultimap& val) override {
if (val.size() != 0U)
return false;
val.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
val.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
val.insert(std::make_pair(TEST_STRING_KEY3, TEST_STRING_VAL3));
return true;
}
// STRUCT VALUES
CefPoint GetPoint() override {
return CefPoint(TEST_X_VAL, TEST_Y_VAL);
}
bool SetPoint(const CefPoint& val) override {
return val.x == TEST_X_VAL && val.y == TEST_Y_VAL;
}
void GetPointByRef(CefPoint& val) override {
val = CefPoint(TEST_X_VAL, TEST_Y_VAL);
}
// STRUCT LIST VALUES
bool SetPointList(const std::vector<CefPoint>& val) override {
if (val.size() != 2U)
return false;
return val[0].x == TEST_X_VAL && val[0].y == TEST_Y_VAL &&
val[1].x == TEST_X_VAL2 && val[1].y == TEST_Y_VAL2;
}
bool GetPointListByRef(PointList& val) override {
if (val.size() != GetPointListSize())
return false;
val.clear();
val.push_back(CefPoint(TEST_X_VAL, TEST_Y_VAL));
val.push_back(CefPoint(TEST_X_VAL2, TEST_Y_VAL2));
return true;
}
size_t GetPointListSize() override {
return 2U;
}
// LIBRARY-SIDE OBJECT VALUES
CefRefPtr<CefTranslatorTestObject> GetObject(int val) override {
return new CefTranslatorTestObjectChildImpl(val, 0);
}
int SetObject(CefRefPtr<CefTranslatorTestObject> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestObject> SetObjectAndReturn(
CefRefPtr<CefTranslatorTestObject> val) override {
return val;
}
int SetChildObject(CefRefPtr<CefTranslatorTestObjectChild> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestObject> SetChildObjectAndReturnParent(
CefRefPtr<CefTranslatorTestObjectChild> val) override {
return val;
}
// LIBRARY-SIDE OBJECT LIST VALUES
bool SetObjectList(
const std::vector<CefRefPtr<CefTranslatorTestObject> >& val,
int val1, int val2) override {
if (val.size() != 2U)
return false;
return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
}
bool GetObjectListByRef(ObjectList& val, int val1, int val2) override {
if (val.size() != GetObjectListSize())
return false;
val.clear();
val.push_back(new CefTranslatorTestObjectChildImpl(val1, 0));
val.push_back(new CefTranslatorTestObjectImpl(val2));
return true;
}
size_t GetObjectListSize() override {
return 2U;
}
// CLIENT-SIDE OBJECT VALUES
int SetHandler(CefRefPtr<CefTranslatorTestHandler> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestHandler> SetHandlerAndReturn(
CefRefPtr<CefTranslatorTestHandler> val) override {
return val;
}
int SetChildHandler(CefRefPtr<CefTranslatorTestHandlerChild> val) override {
return val->GetValue();
}
CefRefPtr<CefTranslatorTestHandler> SetChildHandlerAndReturnParent(
CefRefPtr<CefTranslatorTestHandlerChild> val) override {
return val;
}
// CLIENT-SIDE OBJECT LIST VALUES
bool SetHandlerList(
const std::vector<CefRefPtr<CefTranslatorTestHandler> >& val,
int val1, int val2) override {
if (val.size() != 2U)
return false;
return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
}
bool GetHandlerListByRef(
HandlerList& val,
CefRefPtr<CefTranslatorTestHandler> val1,
CefRefPtr<CefTranslatorTestHandler> val2) override {
if (val.size() != GetHandlerListSize())
return false;
val.clear();
val.push_back(val1);
val.push_back(val2);
return true;
}
size_t GetHandlerListSize() override {
return 2U;
}
private:
IMPLEMENT_REFCOUNTING(CefTranslatorTestImpl);
DISALLOW_COPY_AND_ASSIGN(CefTranslatorTestImpl);
};
// static
CefRefPtr<CefTranslatorTest> CefTranslatorTest::Create() {
return new CefTranslatorTestImpl();
}

25
libcef_dll/cpptoc/app_cpptoc.cc
View File

@ -18,6 +18,8 @@
#include "libcef_dll/ctocpp/scheme_registrar_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK app_on_before_command_line_processing(struct _cef_app_t* self,
@ -105,17 +107,24 @@ struct _cef_render_process_handler_t* CEF_CALLBACK app_get_render_process_handle
return CefRenderProcessHandlerCppToC::Wrap(_retval);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefAppCppToC::CefAppCppToC(CefApp* cls)
: CefCppToC<CefAppCppToC, CefApp, cef_app_t>(cls) {
struct_.struct_.on_before_command_line_processing =
CefAppCppToC::CefAppCppToC() {
GetStruct()->on_before_command_line_processing =
app_on_before_command_line_processing;
struct_.struct_.on_register_custom_schemes = app_on_register_custom_schemes;
struct_.struct_.get_resource_bundle_handler = app_get_resource_bundle_handler;
struct_.struct_.get_browser_process_handler = app_get_browser_process_handler;
struct_.struct_.get_render_process_handler = app_get_render_process_handler;
GetStruct()->on_register_custom_schemes = app_on_register_custom_schemes;
GetStruct()->get_resource_bundle_handler = app_get_resource_bundle_handler;
GetStruct()->get_browser_process_handler = app_get_browser_process_handler;
GetStruct()->get_render_process_handler = app_get_render_process_handler;
}
template<> CefRefPtr<CefApp> CefCppToC<CefAppCppToC, CefApp,
cef_app_t>::UnwrapDerived(CefWrapperType type, cef_app_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -123,3 +132,5 @@ template<> base::AtomicRefCount CefCppToC<CefAppCppToC, CefApp,
cef_app_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefAppCppToC, CefApp,
cef_app_t>::kWrapperType = WT_APP;

3
libcef_dll/cpptoc/app_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefAppCppToC
: public CefCppToC<CefAppCppToC, CefApp, cef_app_t> {
public:
explicit CefAppCppToC(CefApp* cls);
CefAppCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_APP_CPPTOC_H_

21
libcef_dll/cpptoc/auth_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/auth_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK auth_callback_cont(struct _cef_auth_callback_t* self,
@ -48,14 +50,21 @@ void CEF_CALLBACK auth_callback_cancel(struct _cef_auth_callback_t* self) {
CefAuthCallbackCppToC::Get(self)->Cancel();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefAuthCallbackCppToC::CefAuthCallbackCppToC(CefAuthCallback* cls)
: CefCppToC<CefAuthCallbackCppToC, CefAuthCallback, cef_auth_callback_t>(
cls) {
struct_.struct_.cont = auth_callback_cont;
struct_.struct_.cancel = auth_callback_cancel;
CefAuthCallbackCppToC::CefAuthCallbackCppToC() {
GetStruct()->cont = auth_callback_cont;
GetStruct()->cancel = auth_callback_cancel;
}
template<> CefRefPtr<CefAuthCallback> CefCppToC<CefAuthCallbackCppToC,
CefAuthCallback, cef_auth_callback_t>::UnwrapDerived(CefWrapperType type,
cef_auth_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -63,3 +72,5 @@ template<> base::AtomicRefCount CefCppToC<CefAuthCallbackCppToC,
CefAuthCallback, cef_auth_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefAuthCallbackCppToC, CefAuthCallback,
cef_auth_callback_t>::kWrapperType = WT_AUTH_CALLBACK;

3
libcef_dll/cpptoc/auth_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefAuthCallbackCppToC
: public CefCppToC<CefAuthCallbackCppToC, CefAuthCallback,
cef_auth_callback_t> {
public:
explicit CefAuthCallbackCppToC(CefAuthCallback* cls);
CefAuthCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_AUTH_CALLBACK_CPPTOC_H_

22
libcef_dll/cpptoc/base_cpptoc.cc Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#include "libcef_dll/cpptoc/base_cpptoc.h"
CefBaseCppToC::CefBaseCppToC() {
}
template<> CefRefPtr<CefBase> CefCppToC<CefBaseCppToC, CefBase, cef_base_t>::
UnwrapDerived(CefWrapperType type, cef_base_t* s) {
NOTREACHED();
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCppToC<CefBaseCppToC, CefBase,
cef_base_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBaseCppToC, CefBase,cef_base_t>::
kWrapperType = WT_BASE;

143
libcef_dll/cpptoc/base_cpptoc.h
View File

@ -6,143 +6,20 @@
#define CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_
#pragma once
#include "include/base/cef_logging.h"
#include "include/base/cef_macros.h"
#include "include/cef_base.h"
#include "include/capi/cef_base_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
// CefCppToC implementation for CefBase.
class CefBaseCppToC : public CefBase {
#ifndef USING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_CEF_SHARED
// Wrap a C++ class with a C structure.
class CefBaseCppToC
: public CefCppToC<CefBaseCppToC, CefBase, cef_base_t> {
public:
// Use this method to retrieve the underlying class instance from our
// own structure when the structure is passed as the required first
// parameter of a C API function call. No explicit reference counting
// is done in this case.
static CefRefPtr<CefBase> Get(cef_base_t* s) {
DCHECK(s);
// Cast our structure to the wrapper structure type.
CefBaseCppToC::Struct* wrapperStruct =
reinterpret_cast<CefBaseCppToC::Struct*>(s);
// Return the underlying object instance.
return wrapperStruct->class_->GetClass();
}
// Use this method to create a wrapper structure for passing our class
// instance to the other side.
static cef_base_t* Wrap(CefRefPtr<CefBase> c) {
if (!c.get())
return NULL;
// Wrap our object with the CefCppToC class.
CefBaseCppToC* wrapper = new CefBaseCppToC(c);
// Add a reference to our wrapper object that will be released once our
// structure arrives on the other side.
wrapper->AddRef();
// Return the structure pointer that can now be passed to the other side.
return wrapper->GetStruct();
}
// Use this method to retrieve the underlying class instance when receiving
// our wrapper structure back from the other side.
static CefRefPtr<CefBase> Unwrap(cef_base_t* s) {
if (!s)
return NULL;
// Cast our structure to the wrapper structure type.
CefBaseCppToC::Struct* wrapperStruct =
reinterpret_cast<CefBaseCppToC::Struct*>(s);
// Add the underlying object instance to a smart pointer.
CefRefPtr<CefBase> objectPtr(wrapperStruct->class_->GetClass());
// Release the reference to our wrapper object that was added before the
// structure was passed back to us.
wrapperStruct->class_->Release();
// Return the underlying object instance.
return objectPtr;
}
// Structure representation with pointer to the C++ class.
struct Struct {
cef_base_t struct_;
CefBaseCppToC* class_;
};
explicit CefBaseCppToC(CefBase* cls)
: class_(cls) {
DCHECK(cls);
struct_.class_ = this;
// zero the underlying structure and set base members
memset(&struct_.struct_, 0, sizeof(cef_base_t));
struct_.struct_.size = sizeof(cef_base_t);
struct_.struct_.add_ref = struct_add_ref;
struct_.struct_.release = struct_release;
struct_.struct_.has_one_ref = struct_has_one_ref;
}
virtual ~CefBaseCppToC() {}
CefBase* GetClass() { return class_; }
// If returning the structure across the DLL boundary you should call
// AddRef() on this CefCppToC object. On the other side of the DLL boundary,
// call UnderlyingRelease() on the wrapping CefCToCpp object.
cef_base_t* GetStruct() { return &struct_.struct_; }
// CefBase methods increment/decrement reference counts on both this object
// and the underlying wrapper class.
void AddRef() const {
UnderlyingAddRef();
ref_count_.AddRef();
}
bool Release() const {
UnderlyingRelease();
if (ref_count_.Release()) {
delete this;
return true;
}
return false;
}
bool HasOneRef() const { return ref_count_.HasOneRef(); }
// Increment/decrement reference counts on only the underlying class.
void UnderlyingAddRef() const { class_->AddRef(); }
bool UnderlyingRelease() const { return class_->Release(); }
bool UnderlyingHasOneRef() const { return class_->HasOneRef(); }
private:
static void CEF_CALLBACK struct_add_ref(struct _cef_base_t* base) {
DCHECK(base);
if (!base)
return;
Struct* impl = reinterpret_cast<Struct*>(base);
impl->class_->AddRef();
}
static int CEF_CALLBACK struct_release(struct _cef_base_t* base) {
DCHECK(base);
if (!base)
return 0;
Struct* impl = reinterpret_cast<Struct*>(base);
return impl->class_->Release();
}
static int CEF_CALLBACK struct_has_one_ref(struct _cef_base_t* base) {
DCHECK(base);
if (!base)
return 0;
Struct* impl = reinterpret_cast<Struct*>(base);
return impl->class_->HasOneRef();
}
CefRefCount ref_count_;
Struct struct_;
CefBase* class_;
DISALLOW_COPY_AND_ASSIGN(CefBaseCppToC);
CefBaseCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_

21
libcef_dll/cpptoc/before_download_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/before_download_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK before_download_callback_cont(
@ -31,14 +33,20 @@ void CEF_CALLBACK before_download_callback_cont(
show_dialog?true:false);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefBeforeDownloadCallbackCppToC::CefBeforeDownloadCallbackCppToC(
CefBeforeDownloadCallback* cls)
: CefCppToC<CefBeforeDownloadCallbackCppToC, CefBeforeDownloadCallback,
cef_before_download_callback_t>(cls) {
struct_.struct_.cont = before_download_callback_cont;
CefBeforeDownloadCallbackCppToC::CefBeforeDownloadCallbackCppToC() {
GetStruct()->cont = before_download_callback_cont;
}
template<> CefRefPtr<CefBeforeDownloadCallback> CefCppToC<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t>::UnwrapDerived(
CefWrapperType type, cef_before_download_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -47,3 +55,6 @@ template<> base::AtomicRefCount CefCppToC<CefBeforeDownloadCallbackCppToC,
0;
#endif
template<> CefWrapperType CefCppToC<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t>::kWrapperType =
WT_BEFORE_DOWNLOAD_CALLBACK;

3
libcef_dll/cpptoc/before_download_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefBeforeDownloadCallbackCppToC
: public CefCppToC<CefBeforeDownloadCallbackCppToC,
CefBeforeDownloadCallback, cef_before_download_callback_t> {
public:
explicit CefBeforeDownloadCallbackCppToC(CefBeforeDownloadCallback* cls);
CefBeforeDownloadCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_BEFORE_DOWNLOAD_CALLBACK_CPPTOC_H_

30
libcef_dll/cpptoc/binary_value_cpptoc.cc
View File

@ -34,6 +34,8 @@ CEF_EXPORT cef_binary_value_t* cef_binary_value_create(const void* data,
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK binary_value_is_valid(struct _cef_binary_value_t* self) {
@ -155,18 +157,26 @@ size_t CEF_CALLBACK binary_value_get_data(struct _cef_binary_value_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefBinaryValueCppToC::CefBinaryValueCppToC(CefBinaryValue* cls)
: CefCppToC<CefBinaryValueCppToC, CefBinaryValue, cef_binary_value_t>(cls) {
struct_.struct_.is_valid = binary_value_is_valid;
struct_.struct_.is_owned = binary_value_is_owned;
struct_.struct_.is_same = binary_value_is_same;
struct_.struct_.is_equal = binary_value_is_equal;
struct_.struct_.copy = binary_value_copy;
struct_.struct_.get_size = binary_value_get_size;
struct_.struct_.get_data = binary_value_get_data;
CefBinaryValueCppToC::CefBinaryValueCppToC() {
GetStruct()->is_valid = binary_value_is_valid;
GetStruct()->is_owned = binary_value_is_owned;
GetStruct()->is_same = binary_value_is_same;
GetStruct()->is_equal = binary_value_is_equal;
GetStruct()->copy = binary_value_copy;
GetStruct()->get_size = binary_value_get_size;
GetStruct()->get_data = binary_value_get_data;
}
template<> CefRefPtr<CefBinaryValue> CefCppToC<CefBinaryValueCppToC,
CefBinaryValue, cef_binary_value_t>::UnwrapDerived(CefWrapperType type,
cef_binary_value_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -174,3 +184,5 @@ template<> base::AtomicRefCount CefCppToC<CefBinaryValueCppToC, CefBinaryValue,
cef_binary_value_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBinaryValueCppToC, CefBinaryValue,
cef_binary_value_t>::kWrapperType = WT_BINARY_VALUE;

3
libcef_dll/cpptoc/binary_value_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefBinaryValueCppToC
: public CefCppToC<CefBinaryValueCppToC, CefBinaryValue,
cef_binary_value_t> {
public:
explicit CefBinaryValueCppToC(CefBinaryValue* cls);
CefBinaryValueCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_BINARY_VALUE_CPPTOC_H_

57
libcef_dll/cpptoc/browser_cpptoc.cc
View File

@ -18,6 +18,8 @@
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
struct _cef_browser_host_t* CEF_CALLBACK browser_get_host(
@ -352,32 +354,39 @@ int CEF_CALLBACK browser_send_process_message(struct _cef_browser_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefBrowserCppToC::CefBrowserCppToC(CefBrowser* cls)
: CefCppToC<CefBrowserCppToC, CefBrowser, cef_browser_t>(cls) {
struct_.struct_.get_host = browser_get_host;
struct_.struct_.can_go_back = browser_can_go_back;
struct_.struct_.go_back = browser_go_back;
struct_.struct_.can_go_forward = browser_can_go_forward;
struct_.struct_.go_forward = browser_go_forward;
struct_.struct_.is_loading = browser_is_loading;
struct_.struct_.reload = browser_reload;
struct_.struct_.reload_ignore_cache = browser_reload_ignore_cache;
struct_.struct_.stop_load = browser_stop_load;
struct_.struct_.get_identifier = browser_get_identifier;
struct_.struct_.is_same = browser_is_same;
struct_.struct_.is_popup = browser_is_popup;
struct_.struct_.has_document = browser_has_document;
struct_.struct_.get_main_frame = browser_get_main_frame;
struct_.struct_.get_focused_frame = browser_get_focused_frame;
struct_.struct_.get_frame_byident = browser_get_frame_byident;
struct_.struct_.get_frame = browser_get_frame;
struct_.struct_.get_frame_count = browser_get_frame_count;
struct_.struct_.get_frame_identifiers = browser_get_frame_identifiers;
struct_.struct_.get_frame_names = browser_get_frame_names;
struct_.struct_.send_process_message = browser_send_process_message;
CefBrowserCppToC::CefBrowserCppToC() {
GetStruct()->get_host = browser_get_host;
GetStruct()->can_go_back = browser_can_go_back;
GetStruct()->go_back = browser_go_back;
GetStruct()->can_go_forward = browser_can_go_forward;
GetStruct()->go_forward = browser_go_forward;
GetStruct()->is_loading = browser_is_loading;
GetStruct()->reload = browser_reload;
GetStruct()->reload_ignore_cache = browser_reload_ignore_cache;
GetStruct()->stop_load = browser_stop_load;
GetStruct()->get_identifier = browser_get_identifier;
GetStruct()->is_same = browser_is_same;
GetStruct()->is_popup = browser_is_popup;
GetStruct()->has_document = browser_has_document;
GetStruct()->get_main_frame = browser_get_main_frame;
GetStruct()->get_focused_frame = browser_get_focused_frame;
GetStruct()->get_frame_byident = browser_get_frame_byident;
GetStruct()->get_frame = browser_get_frame;
GetStruct()->get_frame_count = browser_get_frame_count;
GetStruct()->get_frame_identifiers = browser_get_frame_identifiers;
GetStruct()->get_frame_names = browser_get_frame_names;
GetStruct()->send_process_message = browser_send_process_message;
}
template<> CefRefPtr<CefBrowser> CefCppToC<CefBrowserCppToC, CefBrowser,
cef_browser_t>::UnwrapDerived(CefWrapperType type, cef_browser_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -385,3 +394,5 @@ template<> base::AtomicRefCount CefCppToC<CefBrowserCppToC, CefBrowser,
cef_browser_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBrowserCppToC, CefBrowser,
cef_browser_t>::kWrapperType = WT_BROWSER;

3
libcef_dll/cpptoc/browser_cpptoc.h
View File

@ -29,9 +29,8 @@
class CefBrowserCppToC
: public CefCppToC<CefBrowserCppToC, CefBrowser, cef_browser_t> {
public:
explicit CefBrowserCppToC(CefBrowser* cls);
CefBrowserCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_BROWSER_CPPTOC_H_

105
libcef_dll/cpptoc/browser_host_cpptoc.cc
View File

@ -97,6 +97,8 @@ CEF_EXPORT cef_browser_t* cef_browser_host_create_browser_sync(
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
cef_browser_t* CEF_CALLBACK browser_host_get_browser(
@ -832,69 +834,76 @@ void CEF_CALLBACK browser_host_drag_source_system_drag_ended(
CefBrowserHostCppToC::Get(self)->DragSourceSystemDragEnded();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefBrowserHostCppToC::CefBrowserHostCppToC(CefBrowserHost* cls)
: CefCppToC<CefBrowserHostCppToC, CefBrowserHost, cef_browser_host_t>(cls) {
struct_.struct_.get_browser = browser_host_get_browser;
struct_.struct_.close_browser = browser_host_close_browser;
struct_.struct_.set_focus = browser_host_set_focus;
struct_.struct_.set_window_visibility = browser_host_set_window_visibility;
struct_.struct_.get_window_handle = browser_host_get_window_handle;
struct_.struct_.get_opener_window_handle =
browser_host_get_opener_window_handle;
struct_.struct_.get_client = browser_host_get_client;
struct_.struct_.get_request_context = browser_host_get_request_context;
struct_.struct_.get_zoom_level = browser_host_get_zoom_level;
struct_.struct_.set_zoom_level = browser_host_set_zoom_level;
struct_.struct_.run_file_dialog = browser_host_run_file_dialog;
struct_.struct_.start_download = browser_host_start_download;
struct_.struct_.print = browser_host_print;
struct_.struct_.find = browser_host_find;
struct_.struct_.stop_finding = browser_host_stop_finding;
struct_.struct_.show_dev_tools = browser_host_show_dev_tools;
struct_.struct_.close_dev_tools = browser_host_close_dev_tools;
struct_.struct_.get_navigation_entries = browser_host_get_navigation_entries;
struct_.struct_.set_mouse_cursor_change_disabled =
CefBrowserHostCppToC::CefBrowserHostCppToC() {
GetStruct()->get_browser = browser_host_get_browser;
GetStruct()->close_browser = browser_host_close_browser;
GetStruct()->set_focus = browser_host_set_focus;
GetStruct()->set_window_visibility = browser_host_set_window_visibility;
GetStruct()->get_window_handle = browser_host_get_window_handle;
GetStruct()->get_opener_window_handle = browser_host_get_opener_window_handle;
GetStruct()->get_client = browser_host_get_client;
GetStruct()->get_request_context = browser_host_get_request_context;
GetStruct()->get_zoom_level = browser_host_get_zoom_level;
GetStruct()->set_zoom_level = browser_host_set_zoom_level;
GetStruct()->run_file_dialog = browser_host_run_file_dialog;
GetStruct()->start_download = browser_host_start_download;
GetStruct()->print = browser_host_print;
GetStruct()->find = browser_host_find;
GetStruct()->stop_finding = browser_host_stop_finding;
GetStruct()->show_dev_tools = browser_host_show_dev_tools;
GetStruct()->close_dev_tools = browser_host_close_dev_tools;
GetStruct()->get_navigation_entries = browser_host_get_navigation_entries;
GetStruct()->set_mouse_cursor_change_disabled =
browser_host_set_mouse_cursor_change_disabled;
struct_.struct_.is_mouse_cursor_change_disabled =
GetStruct()->is_mouse_cursor_change_disabled =
browser_host_is_mouse_cursor_change_disabled;
struct_.struct_.replace_misspelling = browser_host_replace_misspelling;
struct_.struct_.add_word_to_dictionary = browser_host_add_word_to_dictionary;
struct_.struct_.is_window_rendering_disabled =
GetStruct()->replace_misspelling = browser_host_replace_misspelling;
GetStruct()->add_word_to_dictionary = browser_host_add_word_to_dictionary;
GetStruct()->is_window_rendering_disabled =
browser_host_is_window_rendering_disabled;
struct_.struct_.was_resized = browser_host_was_resized;
struct_.struct_.was_hidden = browser_host_was_hidden;
struct_.struct_.notify_screen_info_changed =
GetStruct()->was_resized = browser_host_was_resized;
GetStruct()->was_hidden = browser_host_was_hidden;
GetStruct()->notify_screen_info_changed =
browser_host_notify_screen_info_changed;
struct_.struct_.invalidate = browser_host_invalidate;
struct_.struct_.send_key_event = browser_host_send_key_event;
struct_.struct_.send_mouse_click_event = browser_host_send_mouse_click_event;
struct_.struct_.send_mouse_move_event = browser_host_send_mouse_move_event;
struct_.struct_.send_mouse_wheel_event = browser_host_send_mouse_wheel_event;
struct_.struct_.send_focus_event = browser_host_send_focus_event;
struct_.struct_.send_capture_lost_event =
browser_host_send_capture_lost_event;
struct_.struct_.notify_move_or_resize_started =
GetStruct()->invalidate = browser_host_invalidate;
GetStruct()->send_key_event = browser_host_send_key_event;
GetStruct()->send_mouse_click_event = browser_host_send_mouse_click_event;
GetStruct()->send_mouse_move_event = browser_host_send_mouse_move_event;
GetStruct()->send_mouse_wheel_event = browser_host_send_mouse_wheel_event;
GetStruct()->send_focus_event = browser_host_send_focus_event;
GetStruct()->send_capture_lost_event = browser_host_send_capture_lost_event;
GetStruct()->notify_move_or_resize_started =
browser_host_notify_move_or_resize_started;
struct_.struct_.get_nstext_input_context =
browser_host_get_nstext_input_context;
struct_.struct_.handle_key_event_before_text_input_client =
GetStruct()->get_nstext_input_context = browser_host_get_nstext_input_context;
GetStruct()->handle_key_event_before_text_input_client =
browser_host_handle_key_event_before_text_input_client;
struct_.struct_.handle_key_event_after_text_input_client =
GetStruct()->handle_key_event_after_text_input_client =
browser_host_handle_key_event_after_text_input_client;
struct_.struct_.drag_target_drag_enter = browser_host_drag_target_drag_enter;
struct_.struct_.drag_target_drag_over = browser_host_drag_target_drag_over;
struct_.struct_.drag_target_drag_leave = browser_host_drag_target_drag_leave;
struct_.struct_.drag_target_drop = browser_host_drag_target_drop;
struct_.struct_.drag_source_ended_at = browser_host_drag_source_ended_at;
struct_.struct_.drag_source_system_drag_ended =
GetStruct()->drag_target_drag_enter = browser_host_drag_target_drag_enter;
GetStruct()->drag_target_drag_over = browser_host_drag_target_drag_over;
GetStruct()->drag_target_drag_leave = browser_host_drag_target_drag_leave;
GetStruct()->drag_target_drop = browser_host_drag_target_drop;
GetStruct()->drag_source_ended_at = browser_host_drag_source_ended_at;
GetStruct()->drag_source_system_drag_ended =
browser_host_drag_source_system_drag_ended;
}
template<> CefRefPtr<CefBrowserHost> CefCppToC<CefBrowserHostCppToC,
CefBrowserHost, cef_browser_host_t>::UnwrapDerived(CefWrapperType type,
cef_browser_host_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCppToC<CefBrowserHostCppToC, CefBrowserHost,
cef_browser_host_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBrowserHostCppToC, CefBrowserHost,
cef_browser_host_t>::kWrapperType = WT_BROWSER_HOST;

3
libcef_dll/cpptoc/browser_host_cpptoc.h
View File

@ -30,9 +30,8 @@ class CefBrowserHostCppToC
: public CefCppToC<CefBrowserHostCppToC, CefBrowserHost,
cef_browser_host_t> {
public:
explicit CefBrowserHostCppToC(CefBrowserHost* cls);
CefBrowserHostCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_BROWSER_HOST_CPPTOC_H_

27
libcef_dll/cpptoc/browser_process_handler_cpptoc.cc
View File

@ -16,6 +16,8 @@
#include "libcef_dll/ctocpp/list_value_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK browser_process_handler_on_context_initialized(
@ -82,20 +84,26 @@ struct _cef_print_handler_t* CEF_CALLBACK browser_process_handler_get_print_hand
return CefPrintHandlerCppToC::Wrap(_retval);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefBrowserProcessHandlerCppToC::CefBrowserProcessHandlerCppToC(
CefBrowserProcessHandler* cls)
: CefCppToC<CefBrowserProcessHandlerCppToC, CefBrowserProcessHandler,
cef_browser_process_handler_t>(cls) {
struct_.struct_.on_context_initialized =
CefBrowserProcessHandlerCppToC::CefBrowserProcessHandlerCppToC() {
GetStruct()->on_context_initialized =
browser_process_handler_on_context_initialized;
struct_.struct_.on_before_child_process_launch =
GetStruct()->on_before_child_process_launch =
browser_process_handler_on_before_child_process_launch;
struct_.struct_.on_render_process_thread_created =
GetStruct()->on_render_process_thread_created =
browser_process_handler_on_render_process_thread_created;
struct_.struct_.get_print_handler = browser_process_handler_get_print_handler;
GetStruct()->get_print_handler = browser_process_handler_get_print_handler;
}
template<> CefRefPtr<CefBrowserProcessHandler> CefCppToC<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t>::UnwrapDerived(
CefWrapperType type, cef_browser_process_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -103,3 +111,6 @@ template<> base::AtomicRefCount CefCppToC<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefBrowserProcessHandlerCppToC,
CefBrowserProcessHandler, cef_browser_process_handler_t>::kWrapperType =
WT_BROWSER_PROCESS_HANDLER;

3
libcef_dll/cpptoc/browser_process_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefBrowserProcessHandlerCppToC
: public CefCppToC<CefBrowserProcessHandlerCppToC, CefBrowserProcessHandler,
cef_browser_process_handler_t> {
public:
explicit CefBrowserProcessHandlerCppToC(CefBrowserProcessHandler* cls);
CefBrowserProcessHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_BROWSER_PROCESS_HANDLER_CPPTOC_H_

19
libcef_dll/cpptoc/callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK callback_cont(struct _cef_callback_t* self) {
@ -37,13 +39,20 @@ void CEF_CALLBACK callback_cancel(struct _cef_callback_t* self) {
CefCallbackCppToC::Get(self)->Cancel();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefCallbackCppToC::CefCallbackCppToC(CefCallback* cls)
: CefCppToC<CefCallbackCppToC, CefCallback, cef_callback_t>(cls) {
struct_.struct_.cont = callback_cont;
struct_.struct_.cancel = callback_cancel;
CefCallbackCppToC::CefCallbackCppToC() {
GetStruct()->cont = callback_cont;
GetStruct()->cancel = callback_cancel;
}
template<> CefRefPtr<CefCallback> CefCppToC<CefCallbackCppToC, CefCallback,
cef_callback_t>::UnwrapDerived(CefWrapperType type, cef_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -51,3 +60,5 @@ template<> base::AtomicRefCount CefCppToC<CefCallbackCppToC, CefCallback,
cef_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCallbackCppToC, CefCallback,
cef_callback_t>::kWrapperType = WT_CALLBACK;

3
libcef_dll/cpptoc/callback_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefCallbackCppToC
: public CefCppToC<CefCallbackCppToC, CefCallback, cef_callback_t> {
public:
explicit CefCallbackCppToC(CefCallback* cls);
CefCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_CALLBACK_CPPTOC_H_

46
libcef_dll/cpptoc/client_cpptoc.cc
View File

@ -29,6 +29,8 @@
#include "libcef_dll/ctocpp/process_message_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
struct _cef_context_menu_handler_t* CEF_CALLBACK client_get_context_menu_handler(
@ -282,27 +284,33 @@ int CEF_CALLBACK client_on_process_message_received(struct _cef_client_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefClientCppToC::CefClientCppToC(CefClient* cls)
: CefCppToC<CefClientCppToC, CefClient, cef_client_t>(cls) {
struct_.struct_.get_context_menu_handler = client_get_context_menu_handler;
struct_.struct_.get_dialog_handler = client_get_dialog_handler;
struct_.struct_.get_display_handler = client_get_display_handler;
struct_.struct_.get_download_handler = client_get_download_handler;
struct_.struct_.get_drag_handler = client_get_drag_handler;
struct_.struct_.get_find_handler = client_get_find_handler;
struct_.struct_.get_focus_handler = client_get_focus_handler;
struct_.struct_.get_geolocation_handler = client_get_geolocation_handler;
struct_.struct_.get_jsdialog_handler = client_get_jsdialog_handler;
struct_.struct_.get_keyboard_handler = client_get_keyboard_handler;
struct_.struct_.get_life_span_handler = client_get_life_span_handler;
struct_.struct_.get_load_handler = client_get_load_handler;
struct_.struct_.get_render_handler = client_get_render_handler;
struct_.struct_.get_request_handler = client_get_request_handler;
struct_.struct_.on_process_message_received =
client_on_process_message_received;
CefClientCppToC::CefClientCppToC() {
GetStruct()->get_context_menu_handler = client_get_context_menu_handler;
GetStruct()->get_dialog_handler = client_get_dialog_handler;
GetStruct()->get_display_handler = client_get_display_handler;
GetStruct()->get_download_handler = client_get_download_handler;
GetStruct()->get_drag_handler = client_get_drag_handler;
GetStruct()->get_find_handler = client_get_find_handler;
GetStruct()->get_focus_handler = client_get_focus_handler;
GetStruct()->get_geolocation_handler = client_get_geolocation_handler;
GetStruct()->get_jsdialog_handler = client_get_jsdialog_handler;
GetStruct()->get_keyboard_handler = client_get_keyboard_handler;
GetStruct()->get_life_span_handler = client_get_life_span_handler;
GetStruct()->get_load_handler = client_get_load_handler;
GetStruct()->get_render_handler = client_get_render_handler;
GetStruct()->get_request_handler = client_get_request_handler;
GetStruct()->on_process_message_received = client_on_process_message_received;
}
template<> CefRefPtr<CefClient> CefCppToC<CefClientCppToC, CefClient,
cef_client_t>::UnwrapDerived(CefWrapperType type, cef_client_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -310,3 +318,5 @@ template<> base::AtomicRefCount CefCppToC<CefClientCppToC, CefClient,
cef_client_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefClientCppToC, CefClient,
cef_client_t>::kWrapperType = WT_CLIENT;

3
libcef_dll/cpptoc/client_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefClientCppToC
: public CefCppToC<CefClientCppToC, CefClient, cef_client_t> {
public:
explicit CefClientCppToC(CefClient* cls);
CefClientCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_CLIENT_CPPTOC_H_

58
libcef_dll/cpptoc/command_line_cpptoc.cc
View File

@ -37,6 +37,8 @@ CEF_EXPORT cef_command_line_t* cef_command_line_get_global() {
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK command_line_is_valid(struct _cef_command_line_t* self) {
@ -392,33 +394,39 @@ void CEF_CALLBACK command_line_prepend_wrapper(struct _cef_command_line_t* self,
CefString(wrapper));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefCommandLineCppToC::CefCommandLineCppToC(CefCommandLine* cls)
: CefCppToC<CefCommandLineCppToC, CefCommandLine, cef_command_line_t>(cls) {
struct_.struct_.is_valid = command_line_is_valid;
struct_.struct_.is_read_only = command_line_is_read_only;
struct_.struct_.copy = command_line_copy;
struct_.struct_.init_from_argv = command_line_init_from_argv;
struct_.struct_.init_from_string = command_line_init_from_string;
struct_.struct_.reset = command_line_reset;
struct_.struct_.get_argv = command_line_get_argv;
struct_.struct_.get_command_line_string =
command_line_get_command_line_string;
struct_.struct_.get_program = command_line_get_program;
struct_.struct_.set_program = command_line_set_program;
struct_.struct_.has_switches = command_line_has_switches;
struct_.struct_.has_switch = command_line_has_switch;
struct_.struct_.get_switch_value = command_line_get_switch_value;
struct_.struct_.get_switches = command_line_get_switches;
struct_.struct_.append_switch = command_line_append_switch;
struct_.struct_.append_switch_with_value =
command_line_append_switch_with_value;
struct_.struct_.has_arguments = command_line_has_arguments;
struct_.struct_.get_arguments = command_line_get_arguments;
struct_.struct_.append_argument = command_line_append_argument;
struct_.struct_.prepend_wrapper = command_line_prepend_wrapper;
CefCommandLineCppToC::CefCommandLineCppToC() {
GetStruct()->is_valid = command_line_is_valid;
GetStruct()->is_read_only = command_line_is_read_only;
GetStruct()->copy = command_line_copy;
GetStruct()->init_from_argv = command_line_init_from_argv;
GetStruct()->init_from_string = command_line_init_from_string;
GetStruct()->reset = command_line_reset;
GetStruct()->get_argv = command_line_get_argv;
GetStruct()->get_command_line_string = command_line_get_command_line_string;
GetStruct()->get_program = command_line_get_program;
GetStruct()->set_program = command_line_set_program;
GetStruct()->has_switches = command_line_has_switches;
GetStruct()->has_switch = command_line_has_switch;
GetStruct()->get_switch_value = command_line_get_switch_value;
GetStruct()->get_switches = command_line_get_switches;
GetStruct()->append_switch = command_line_append_switch;
GetStruct()->append_switch_with_value = command_line_append_switch_with_value;
GetStruct()->has_arguments = command_line_has_arguments;
GetStruct()->get_arguments = command_line_get_arguments;
GetStruct()->append_argument = command_line_append_argument;
GetStruct()->prepend_wrapper = command_line_prepend_wrapper;
}
template<> CefRefPtr<CefCommandLine> CefCppToC<CefCommandLineCppToC,
CefCommandLine, cef_command_line_t>::UnwrapDerived(CefWrapperType type,
cef_command_line_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -426,3 +434,5 @@ template<> base::AtomicRefCount CefCppToC<CefCommandLineCppToC, CefCommandLine,
cef_command_line_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCommandLineCppToC, CefCommandLine,
cef_command_line_t>::kWrapperType = WT_COMMAND_LINE;

3
libcef_dll/cpptoc/command_line_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefCommandLineCppToC
: public CefCppToC<CefCommandLineCppToC, CefCommandLine,
cef_command_line_t> {
public:
explicit CefCommandLineCppToC(CefCommandLine* cls);
CefCommandLineCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_COMMAND_LINE_CPPTOC_H_

21
libcef_dll/cpptoc/completion_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/completion_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK completion_callback_on_complete(
@ -27,14 +29,20 @@ void CEF_CALLBACK completion_callback_on_complete(
CefCompletionCallbackCppToC::Get(self)->OnComplete();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefCompletionCallbackCppToC::CefCompletionCallbackCppToC(
CefCompletionCallback* cls)
: CefCppToC<CefCompletionCallbackCppToC, CefCompletionCallback,
cef_completion_callback_t>(cls) {
struct_.struct_.on_complete = completion_callback_on_complete;
CefCompletionCallbackCppToC::CefCompletionCallbackCppToC() {
GetStruct()->on_complete = completion_callback_on_complete;
}
template<> CefRefPtr<CefCompletionCallback> CefCppToC<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t>::UnwrapDerived(
CefWrapperType type, cef_completion_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -42,3 +50,6 @@ template<> base::AtomicRefCount CefCppToC<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCompletionCallbackCppToC,
CefCompletionCallback, cef_completion_callback_t>::kWrapperType =
WT_COMPLETION_CALLBACK;

3
libcef_dll/cpptoc/completion_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefCompletionCallbackCppToC
: public CefCppToC<CefCompletionCallbackCppToC, CefCompletionCallback,
cef_completion_callback_t> {
public:
explicit CefCompletionCallbackCppToC(CefCompletionCallback* cls);
CefCompletionCallbackCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_COMPLETION_CALLBACK_CPPTOC_H_

25
libcef_dll/cpptoc/context_menu_handler_cpptoc.cc
View File

@ -17,6 +17,8 @@
#include "libcef_dll/ctocpp/menu_model_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK context_menu_handler_on_before_context_menu(
@ -110,23 +112,32 @@ void CEF_CALLBACK context_menu_handler_on_context_menu_dismissed(
CefFrameCToCpp::Wrap(frame));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefContextMenuHandlerCppToC::CefContextMenuHandlerCppToC(
CefContextMenuHandler* cls)
: CefCppToC<CefContextMenuHandlerCppToC, CefContextMenuHandler,
cef_context_menu_handler_t>(cls) {
struct_.struct_.on_before_context_menu =
CefContextMenuHandlerCppToC::CefContextMenuHandlerCppToC() {
GetStruct()->on_before_context_menu =
context_menu_handler_on_before_context_menu;
struct_.struct_.on_context_menu_command =
GetStruct()->on_context_menu_command =
context_menu_handler_on_context_menu_command;
struct_.struct_.on_context_menu_dismissed =
GetStruct()->on_context_menu_dismissed =
context_menu_handler_on_context_menu_dismissed;
}
template<> CefRefPtr<CefContextMenuHandler> CefCppToC<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t>::UnwrapDerived(
CefWrapperType type, cef_context_menu_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCppToC<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefContextMenuHandlerCppToC,
CefContextMenuHandler, cef_context_menu_handler_t>::kWrapperType =
WT_CONTEXT_MENU_HANDLER;

3
libcef_dll/cpptoc/context_menu_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefContextMenuHandlerCppToC
: public CefCppToC<CefContextMenuHandlerCppToC, CefContextMenuHandler,
cef_context_menu_handler_t> {
public:
explicit CefContextMenuHandlerCppToC(CefContextMenuHandler* cls);
CefContextMenuHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_CONTEXT_MENU_HANDLER_CPPTOC_H_

56
libcef_dll/cpptoc/context_menu_params_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK context_menu_params_get_xcoord(
@ -306,36 +308,41 @@ cef_context_menu_edit_state_flags_t CEF_CALLBACK context_menu_params_get_edit_st
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefContextMenuParamsCppToC::CefContextMenuParamsCppToC(
CefContextMenuParams* cls)
: CefCppToC<CefContextMenuParamsCppToC, CefContextMenuParams,
cef_context_menu_params_t>(cls) {
struct_.struct_.get_xcoord = context_menu_params_get_xcoord;
struct_.struct_.get_ycoord = context_menu_params_get_ycoord;
struct_.struct_.get_type_flags = context_menu_params_get_type_flags;
struct_.struct_.get_link_url = context_menu_params_get_link_url;
struct_.struct_.get_unfiltered_link_url =
CefContextMenuParamsCppToC::CefContextMenuParamsCppToC() {
GetStruct()->get_xcoord = context_menu_params_get_xcoord;
GetStruct()->get_ycoord = context_menu_params_get_ycoord;
GetStruct()->get_type_flags = context_menu_params_get_type_flags;
GetStruct()->get_link_url = context_menu_params_get_link_url;
GetStruct()->get_unfiltered_link_url =
context_menu_params_get_unfiltered_link_url;
struct_.struct_.get_source_url = context_menu_params_get_source_url;
struct_.struct_.has_image_contents = context_menu_params_has_image_contents;
struct_.struct_.get_page_url = context_menu_params_get_page_url;
struct_.struct_.get_frame_url = context_menu_params_get_frame_url;
struct_.struct_.get_frame_charset = context_menu_params_get_frame_charset;
struct_.struct_.get_media_type = context_menu_params_get_media_type;
struct_.struct_.get_media_state_flags =
GetStruct()->get_source_url = context_menu_params_get_source_url;
GetStruct()->has_image_contents = context_menu_params_has_image_contents;
GetStruct()->get_page_url = context_menu_params_get_page_url;
GetStruct()->get_frame_url = context_menu_params_get_frame_url;
GetStruct()->get_frame_charset = context_menu_params_get_frame_charset;
GetStruct()->get_media_type = context_menu_params_get_media_type;
GetStruct()->get_media_state_flags =
context_menu_params_get_media_state_flags;
struct_.struct_.get_selection_text = context_menu_params_get_selection_text;
struct_.struct_.get_misspelled_word = context_menu_params_get_misspelled_word;
struct_.struct_.get_dictionary_suggestions =
GetStruct()->get_selection_text = context_menu_params_get_selection_text;
GetStruct()->get_misspelled_word = context_menu_params_get_misspelled_word;
GetStruct()->get_dictionary_suggestions =
context_menu_params_get_dictionary_suggestions;
struct_.struct_.is_editable = context_menu_params_is_editable;
struct_.struct_.is_spell_check_enabled =
GetStruct()->is_editable = context_menu_params_is_editable;
GetStruct()->is_spell_check_enabled =
context_menu_params_is_spell_check_enabled;
struct_.struct_.get_edit_state_flags =
context_menu_params_get_edit_state_flags;
GetStruct()->get_edit_state_flags = context_menu_params_get_edit_state_flags;
}
template<> CefRefPtr<CefContextMenuParams> CefCppToC<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t>::UnwrapDerived(
CefWrapperType type, cef_context_menu_params_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -343,3 +350,6 @@ template<> base::AtomicRefCount CefCppToC<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefContextMenuParamsCppToC,
CefContextMenuParams, cef_context_menu_params_t>::kWrapperType =
WT_CONTEXT_MENU_PARAMS;

3
libcef_dll/cpptoc/context_menu_params_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefContextMenuParamsCppToC
: public CefCppToC<CefContextMenuParamsCppToC, CefContextMenuParams,
cef_context_menu_params_t> {
public:
explicit CefContextMenuParamsCppToC(CefContextMenuParams* cls);
CefContextMenuParamsCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_CONTEXT_MENU_PARAMS_CPPTOC_H_

31
libcef_dll/cpptoc/cookie_manager_cpptoc.cc
View File

@ -52,6 +52,8 @@ CEF_EXPORT cef_cookie_manager_t* cef_cookie_manager_create_manager(
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK cookie_manager_set_supported_schemes(
@ -217,19 +219,26 @@ int CEF_CALLBACK cookie_manager_flush_store(struct _cef_cookie_manager_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefCookieManagerCppToC::CefCookieManagerCppToC(CefCookieManager* cls)
: CefCppToC<CefCookieManagerCppToC, CefCookieManager, cef_cookie_manager_t>(
cls) {
struct_.struct_.set_supported_schemes = cookie_manager_set_supported_schemes;
struct_.struct_.visit_all_cookies = cookie_manager_visit_all_cookies;
struct_.struct_.visit_url_cookies = cookie_manager_visit_url_cookies;
struct_.struct_.set_cookie = cookie_manager_set_cookie;
struct_.struct_.delete_cookies = cookie_manager_delete_cookies;
struct_.struct_.set_storage_path = cookie_manager_set_storage_path;
struct_.struct_.flush_store = cookie_manager_flush_store;
CefCookieManagerCppToC::CefCookieManagerCppToC() {
GetStruct()->set_supported_schemes = cookie_manager_set_supported_schemes;
GetStruct()->visit_all_cookies = cookie_manager_visit_all_cookies;
GetStruct()->visit_url_cookies = cookie_manager_visit_url_cookies;
GetStruct()->set_cookie = cookie_manager_set_cookie;
GetStruct()->delete_cookies = cookie_manager_delete_cookies;
GetStruct()->set_storage_path = cookie_manager_set_storage_path;
GetStruct()->flush_store = cookie_manager_flush_store;
}
template<> CefRefPtr<CefCookieManager> CefCppToC<CefCookieManagerCppToC,
CefCookieManager, cef_cookie_manager_t>::UnwrapDerived(CefWrapperType type,
cef_cookie_manager_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -237,3 +246,5 @@ template<> base::AtomicRefCount CefCppToC<CefCookieManagerCppToC,
CefCookieManager, cef_cookie_manager_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCookieManagerCppToC, CefCookieManager,
cef_cookie_manager_t>::kWrapperType = WT_COOKIE_MANAGER;

3
libcef_dll/cpptoc/cookie_manager_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefCookieManagerCppToC
: public CefCppToC<CefCookieManagerCppToC, CefCookieManager,
cef_cookie_manager_t> {
public:
explicit CefCookieManagerCppToC(CefCookieManager* cls);
CefCookieManagerCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_COOKIE_MANAGER_CPPTOC_H_

19
libcef_dll/cpptoc/cookie_visitor_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/cookie_visitor_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK cookie_visitor_visit(struct _cef_cookie_visitor_t* self,
@ -54,13 +56,20 @@ int CEF_CALLBACK cookie_visitor_visit(struct _cef_cookie_visitor_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefCookieVisitorCppToC::CefCookieVisitorCppToC(CefCookieVisitor* cls)
: CefCppToC<CefCookieVisitorCppToC, CefCookieVisitor, cef_cookie_visitor_t>(
cls) {
struct_.struct_.visit = cookie_visitor_visit;
CefCookieVisitorCppToC::CefCookieVisitorCppToC() {
GetStruct()->visit = cookie_visitor_visit;
}
template<> CefRefPtr<CefCookieVisitor> CefCppToC<CefCookieVisitorCppToC,
CefCookieVisitor, cef_cookie_visitor_t>::UnwrapDerived(CefWrapperType type,
cef_cookie_visitor_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -68,3 +77,5 @@ template<> base::AtomicRefCount CefCppToC<CefCookieVisitorCppToC,
CefCookieVisitor, cef_cookie_visitor_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefCookieVisitorCppToC, CefCookieVisitor,
cef_cookie_visitor_t>::kWrapperType = WT_COOKIE_VISITOR;

3
libcef_dll/cpptoc/cookie_visitor_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefCookieVisitorCppToC
: public CefCppToC<CefCookieVisitorCppToC, CefCookieVisitor,
cef_cookie_visitor_t> {
public:
explicit CefCookieVisitorCppToC(CefCookieVisitor* cls);
CefCookieVisitorCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_COOKIE_VISITOR_CPPTOC_H_

173
libcef_dll/cpptoc/cpptoc.h
View File

@ -10,7 +10,7 @@
#include "include/base/cef_macros.h"
#include "include/cef_base.h"
#include "include/capi/cef_base_capi.h"
#include "libcef_dll/wrapper_types.h"
// Wrap a C++ class with a C structure. This is used when the class
// implementation exists on this side of the DLL boundary but will have methods
@ -18,33 +18,15 @@
template <class ClassName, class BaseName, class StructName>
class CefCppToC : public CefBase {
public:
// Structure representation with pointer to the C++ class.
struct Struct {
StructName struct_;
CefCppToC<ClassName, BaseName, StructName>* class_;
};
// Use this method to retrieve the underlying class instance from our
// own structure when the structure is passed as the required first
// parameter of a C API function call. No explicit reference counting
// is done in this case.
static CefRefPtr<BaseName> Get(StructName* s) {
DCHECK(s);
// Cast our structure to the wrapper structure type.
Struct* wrapperStruct = reinterpret_cast<Struct*>(s);
// Return the underlying object instance.
return wrapperStruct->class_->GetClass();
}
// Use this method to create a wrapper structure for passing our class
// instance to the other side.
// Create a new wrapper instance and associated structure reference for
// passing an object instance the other side.
static StructName* Wrap(CefRefPtr<BaseName> c) {
if (!c.get())
return NULL;
// Wrap our object with the CefCppToC class.
ClassName* wrapper = new ClassName(c.get());
ClassName* wrapper = new ClassName();
wrapper->wrapper_struct_.object_ = c.get();
// Add a reference to our wrapper object that will be released once our
// structure arrives on the other side.
wrapper->AddRef();
@ -52,52 +34,44 @@ class CefCppToC : public CefBase {
return wrapper->GetStruct();
}
// Use this method to retrieve the underlying class instance when receiving
// our wrapper structure back from the other side.
// Retrieve the underlying object instance for a structure reference passed
// back from the other side.
static CefRefPtr<BaseName> Unwrap(StructName* s) {
if (!s)
return NULL;
// Cast our structure to the wrapper structure type.
Struct* wrapperStruct = reinterpret_cast<Struct*>(s);
WrapperStruct* wrapperStruct = GetWrapperStruct(s);
// If the type does not match this object then we need to unwrap as the
// derived type.
if (wrapperStruct->type_ != kWrapperType)
return UnwrapDerived(wrapperStruct->type_, s);
// Add the underlying object instance to a smart pointer.
CefRefPtr<BaseName> objectPtr(wrapperStruct->class_->GetClass());
CefRefPtr<BaseName> objectPtr(wrapperStruct->object_);
// Release the reference to our wrapper object that was added before the
// structure was passed back to us.
wrapperStruct->class_->Release();
wrapperStruct->wrapper_->Release();
// Return the underlying object instance.
return objectPtr;
}
explicit CefCppToC(BaseName* cls)
: class_(cls) {
DCHECK(cls);
struct_.class_ = this;
// zero the underlying structure and set base members
memset(&struct_.struct_, 0, sizeof(StructName));
struct_.struct_.base.size = sizeof(StructName);
struct_.struct_.base.add_ref = struct_add_ref;
struct_.struct_.base.release = struct_release;
struct_.struct_.base.has_one_ref = struct_has_one_ref;
#ifndef NDEBUG
base::AtomicRefCountInc(&DebugObjCt);
#endif
// Retrieve the underlying object instance from our own structure reference
// when the reference is passed as the required first parameter of a C API
// function call. No explicit reference counting is done in this case.
static CefRefPtr<BaseName> Get(StructName* s) {
DCHECK(s);
WrapperStruct* wrapperStruct = GetWrapperStruct(s);
// Verify that the wrapper offset was calculated correctly.
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
return wrapperStruct->object_;
}
virtual ~CefCppToC() {
#ifndef NDEBUG
base::AtomicRefCountDec(&DebugObjCt);
#endif
}
BaseName* GetClass() { return class_; }
// If returning the structure across the DLL boundary you should call
// AddRef() on this CefCppToC object. On the other side of the DLL boundary,
// call UnderlyingRelease() on the wrapping CefCToCpp object.
StructName* GetStruct() { return &struct_.struct_; }
StructName* GetStruct() { return &wrapper_struct_.struct_; }
// CefBase methods increment/decrement reference counts on both this object
// and the underlying wrapper class.
@ -113,12 +87,7 @@ class CefCppToC : public CefBase {
}
return false;
}
bool HasOneRef() const { return ref_count_.HasOneRef(); }
// Increment/decrement reference counts on only the underlying class.
void UnderlyingAddRef() const { class_->AddRef(); }
bool UnderlyingRelease() const { return class_->Release(); }
bool UnderlyingHasOneRef() const { return class_->HasOneRef(); }
bool HasOneRef() const { return UnderlyingHasOneRef(); }
#ifndef NDEBUG
// Simple tracking of allocated objects.
@ -126,39 +95,105 @@ class CefCppToC : public CefBase {
#endif
protected:
Struct struct_;
BaseName* class_;
CefCppToC() {
wrapper_struct_.type_ = kWrapperType;
wrapper_struct_.wrapper_ = this;
memset(GetStruct(), 0, sizeof(StructName));
cef_base_t* base = reinterpret_cast<cef_base_t*>(GetStruct());
base->size = sizeof(StructName);
base->add_ref = struct_add_ref;
base->release = struct_release;
base->has_one_ref = struct_has_one_ref;
#ifndef NDEBUG
base::AtomicRefCountInc(&DebugObjCt);
#endif
}
virtual ~CefCppToC() {
#ifndef NDEBUG
base::AtomicRefCountDec(&DebugObjCt);
#endif
}
private:
static void CEF_CALLBACK struct_add_ref(struct _cef_base_t* base) {
// Used to associate this wrapper object, the underlying object instance and
// the structure that will be passed to the other side.
struct WrapperStruct {
CefWrapperType type_;
BaseName* object_;
CefCppToC<ClassName, BaseName, StructName>* wrapper_;
StructName struct_;
};
static WrapperStruct* GetWrapperStruct(StructName* s) {
// Offset using the WrapperStruct size instead of individual member sizes
// to avoid problems due to platform/compiler differences in structure
// padding.
return reinterpret_cast<WrapperStruct*>(
reinterpret_cast<char*>(s) -
(sizeof(WrapperStruct) - sizeof(StructName)));
}
// Unwrap as the derived type.
static CefRefPtr<BaseName> UnwrapDerived(CefWrapperType type, StructName* s);
// Increment/decrement reference counts on only the underlying class.
void UnderlyingAddRef() const {
wrapper_struct_.object_->AddRef();
}
bool UnderlyingRelease() const {
return wrapper_struct_.object_->Release();
}
bool UnderlyingHasOneRef() const {
return wrapper_struct_.object_->HasOneRef();
}
static void CEF_CALLBACK struct_add_ref(cef_base_t* base) {
DCHECK(base);
if (!base)
return;
Struct* impl = reinterpret_cast<Struct*>(base);
impl->class_->AddRef();
WrapperStruct* wrapperStruct =
GetWrapperStruct(reinterpret_cast<StructName*>(base));
// Verify that the wrapper offset was calculated correctly.
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
wrapperStruct->wrapper_->AddRef();
}
static int CEF_CALLBACK struct_release(struct _cef_base_t* base) {
static int CEF_CALLBACK struct_release(cef_base_t* base) {
DCHECK(base);
if (!base)
return 0;
Struct* impl = reinterpret_cast<Struct*>(base);
return impl->class_->Release();
WrapperStruct* wrapperStruct =
GetWrapperStruct(reinterpret_cast<StructName*>(base));
// Verify that the wrapper offset was calculated correctly.
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
return wrapperStruct->wrapper_->Release();
}
static int CEF_CALLBACK struct_has_one_ref(struct _cef_base_t* base) {
static int CEF_CALLBACK struct_has_one_ref(cef_base_t* base) {
DCHECK(base);
if (!base)
return 0;
Struct* impl = reinterpret_cast<Struct*>(base);
return impl->class_->HasOneRef();
WrapperStruct* wrapperStruct =
GetWrapperStruct(reinterpret_cast<StructName*>(base));
// Verify that the wrapper offset was calculated correctly.
DCHECK_EQ(kWrapperType, wrapperStruct->type_);
return wrapperStruct->wrapper_->HasOneRef();
}
WrapperStruct wrapper_struct_;
CefRefCount ref_count_;
static CefWrapperType kWrapperType;
DISALLOW_COPY_AND_ASSIGN(CefCppToC);
};

21
libcef_dll/cpptoc/delete_cookies_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/delete_cookies_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK delete_cookies_callback_on_complete(
@ -28,14 +30,20 @@ void CEF_CALLBACK delete_cookies_callback_on_complete(
num_deleted);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDeleteCookiesCallbackCppToC::CefDeleteCookiesCallbackCppToC(
CefDeleteCookiesCallback* cls)
: CefCppToC<CefDeleteCookiesCallbackCppToC, CefDeleteCookiesCallback,
cef_delete_cookies_callback_t>(cls) {
struct_.struct_.on_complete = delete_cookies_callback_on_complete;
CefDeleteCookiesCallbackCppToC::CefDeleteCookiesCallbackCppToC() {
GetStruct()->on_complete = delete_cookies_callback_on_complete;
}
template<> CefRefPtr<CefDeleteCookiesCallback> CefCppToC<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t>::UnwrapDerived(
CefWrapperType type, cef_delete_cookies_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -43,3 +51,6 @@ template<> base::AtomicRefCount CefCppToC<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDeleteCookiesCallbackCppToC,
CefDeleteCookiesCallback, cef_delete_cookies_callback_t>::kWrapperType =
WT_DELETE_COOKIES_CALLBACK;

3
libcef_dll/cpptoc/delete_cookies_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDeleteCookiesCallbackCppToC
: public CefCppToC<CefDeleteCookiesCallbackCppToC, CefDeleteCookiesCallback,
cef_delete_cookies_callback_t> {
public:
explicit CefDeleteCookiesCallbackCppToC(CefDeleteCookiesCallback* cls);
CefDeleteCookiesCallbackCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DELETE_COOKIES_CALLBACK_CPPTOC_H_

19
libcef_dll/cpptoc/dialog_handler_cpptoc.cc
View File

@ -16,6 +16,8 @@
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK dialog_handler_on_file_dialog(
@ -60,13 +62,20 @@ int CEF_CALLBACK dialog_handler_on_file_dialog(
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDialogHandlerCppToC::CefDialogHandlerCppToC(CefDialogHandler* cls)
: CefCppToC<CefDialogHandlerCppToC, CefDialogHandler, cef_dialog_handler_t>(
cls) {
struct_.struct_.on_file_dialog = dialog_handler_on_file_dialog;
CefDialogHandlerCppToC::CefDialogHandlerCppToC() {
GetStruct()->on_file_dialog = dialog_handler_on_file_dialog;
}
template<> CefRefPtr<CefDialogHandler> CefCppToC<CefDialogHandlerCppToC,
CefDialogHandler, cef_dialog_handler_t>::UnwrapDerived(CefWrapperType type,
cef_dialog_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -74,3 +83,5 @@ template<> base::AtomicRefCount CefCppToC<CefDialogHandlerCppToC,
CefDialogHandler, cef_dialog_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDialogHandlerCppToC, CefDialogHandler,
cef_dialog_handler_t>::kWrapperType = WT_DIALOG_HANDLER;

3
libcef_dll/cpptoc/dialog_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDialogHandlerCppToC
: public CefCppToC<CefDialogHandlerCppToC, CefDialogHandler,
cef_dialog_handler_t> {
public:
explicit CefDialogHandlerCppToC(CefDialogHandler* cls);
CefDialogHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DIALOG_HANDLER_CPPTOC_H_

76
libcef_dll/cpptoc/dictionary_value_cpptoc.cc
View File

@ -30,6 +30,8 @@ CEF_EXPORT cef_dictionary_value_t* cef_dictionary_value_create() {
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK dictionary_value_is_valid(
@ -624,41 +626,48 @@ int CEF_CALLBACK dictionary_value_set_list(struct _cef_dictionary_value_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDictionaryValueCppToC::CefDictionaryValueCppToC(CefDictionaryValue* cls)
: CefCppToC<CefDictionaryValueCppToC, CefDictionaryValue,
cef_dictionary_value_t>(cls) {
struct_.struct_.is_valid = dictionary_value_is_valid;
struct_.struct_.is_owned = dictionary_value_is_owned;
struct_.struct_.is_read_only = dictionary_value_is_read_only;
struct_.struct_.is_same = dictionary_value_is_same;
struct_.struct_.is_equal = dictionary_value_is_equal;
struct_.struct_.copy = dictionary_value_copy;
struct_.struct_.get_size = dictionary_value_get_size;
struct_.struct_.clear = dictionary_value_clear;
struct_.struct_.has_key = dictionary_value_has_key;
struct_.struct_.get_keys = dictionary_value_get_keys;
struct_.struct_.remove = dictionary_value_remove;
struct_.struct_.get_type = dictionary_value_get_type;
struct_.struct_.get_value = dictionary_value_get_value;
struct_.struct_.get_bool = dictionary_value_get_bool;
struct_.struct_.get_int = dictionary_value_get_int;
struct_.struct_.get_double = dictionary_value_get_double;
struct_.struct_.get_string = dictionary_value_get_string;
struct_.struct_.get_binary = dictionary_value_get_binary;
struct_.struct_.get_dictionary = dictionary_value_get_dictionary;
struct_.struct_.get_list = dictionary_value_get_list;
struct_.struct_.set_value = dictionary_value_set_value;
struct_.struct_.set_null = dictionary_value_set_null;
struct_.struct_.set_bool = dictionary_value_set_bool;
struct_.struct_.set_int = dictionary_value_set_int;
struct_.struct_.set_double = dictionary_value_set_double;
struct_.struct_.set_string = dictionary_value_set_string;
struct_.struct_.set_binary = dictionary_value_set_binary;
struct_.struct_.set_dictionary = dictionary_value_set_dictionary;
struct_.struct_.set_list = dictionary_value_set_list;
CefDictionaryValueCppToC::CefDictionaryValueCppToC() {
GetStruct()->is_valid = dictionary_value_is_valid;
GetStruct()->is_owned = dictionary_value_is_owned;
GetStruct()->is_read_only = dictionary_value_is_read_only;
GetStruct()->is_same = dictionary_value_is_same;
GetStruct()->is_equal = dictionary_value_is_equal;
GetStruct()->copy = dictionary_value_copy;
GetStruct()->get_size = dictionary_value_get_size;
GetStruct()->clear = dictionary_value_clear;
GetStruct()->has_key = dictionary_value_has_key;
GetStruct()->get_keys = dictionary_value_get_keys;
GetStruct()->remove = dictionary_value_remove;
GetStruct()->get_type = dictionary_value_get_type;
GetStruct()->get_value = dictionary_value_get_value;
GetStruct()->get_bool = dictionary_value_get_bool;
GetStruct()->get_int = dictionary_value_get_int;
GetStruct()->get_double = dictionary_value_get_double;
GetStruct()->get_string = dictionary_value_get_string;
GetStruct()->get_binary = dictionary_value_get_binary;
GetStruct()->get_dictionary = dictionary_value_get_dictionary;
GetStruct()->get_list = dictionary_value_get_list;
GetStruct()->set_value = dictionary_value_set_value;
GetStruct()->set_null = dictionary_value_set_null;
GetStruct()->set_bool = dictionary_value_set_bool;
GetStruct()->set_int = dictionary_value_set_int;
GetStruct()->set_double = dictionary_value_set_double;
GetStruct()->set_string = dictionary_value_set_string;
GetStruct()->set_binary = dictionary_value_set_binary;
GetStruct()->set_dictionary = dictionary_value_set_dictionary;
GetStruct()->set_list = dictionary_value_set_list;
}
template<> CefRefPtr<CefDictionaryValue> CefCppToC<CefDictionaryValueCppToC,
CefDictionaryValue, cef_dictionary_value_t>::UnwrapDerived(
CefWrapperType type, cef_dictionary_value_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -666,3 +675,6 @@ template<> base::AtomicRefCount CefCppToC<CefDictionaryValueCppToC,
CefDictionaryValue, cef_dictionary_value_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDictionaryValueCppToC,
CefDictionaryValue, cef_dictionary_value_t>::kWrapperType =
WT_DICTIONARY_VALUE;

3
libcef_dll/cpptoc/dictionary_value_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDictionaryValueCppToC
: public CefCppToC<CefDictionaryValueCppToC, CefDictionaryValue,
cef_dictionary_value_t> {
public:
explicit CefDictionaryValueCppToC(CefDictionaryValue* cls);
CefDictionaryValueCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DICTIONARY_VALUE_CPPTOC_H_

29
libcef_dll/cpptoc/display_handler_cpptoc.cc
View File

@ -16,6 +16,8 @@
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK display_handler_on_address_change(
@ -160,18 +162,25 @@ int CEF_CALLBACK display_handler_on_console_message(
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDisplayHandlerCppToC::CefDisplayHandlerCppToC(CefDisplayHandler* cls)
: CefCppToC<CefDisplayHandlerCppToC, CefDisplayHandler,
cef_display_handler_t>(cls) {
struct_.struct_.on_address_change = display_handler_on_address_change;
struct_.struct_.on_title_change = display_handler_on_title_change;
struct_.struct_.on_favicon_urlchange = display_handler_on_favicon_urlchange;
struct_.struct_.on_tooltip = display_handler_on_tooltip;
struct_.struct_.on_status_message = display_handler_on_status_message;
struct_.struct_.on_console_message = display_handler_on_console_message;
CefDisplayHandlerCppToC::CefDisplayHandlerCppToC() {
GetStruct()->on_address_change = display_handler_on_address_change;
GetStruct()->on_title_change = display_handler_on_title_change;
GetStruct()->on_favicon_urlchange = display_handler_on_favicon_urlchange;
GetStruct()->on_tooltip = display_handler_on_tooltip;
GetStruct()->on_status_message = display_handler_on_status_message;
GetStruct()->on_console_message = display_handler_on_console_message;
}
template<> CefRefPtr<CefDisplayHandler> CefCppToC<CefDisplayHandlerCppToC,
CefDisplayHandler, cef_display_handler_t>::UnwrapDerived(
CefWrapperType type, cef_display_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -179,3 +188,5 @@ template<> base::AtomicRefCount CefCppToC<CefDisplayHandlerCppToC,
CefDisplayHandler, cef_display_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDisplayHandlerCppToC, CefDisplayHandler,
cef_display_handler_t>::kWrapperType = WT_DISPLAY_HANDLER;

3
libcef_dll/cpptoc/display_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDisplayHandlerCppToC
: public CefCppToC<CefDisplayHandlerCppToC, CefDisplayHandler,
cef_display_handler_t> {
public:
explicit CefDisplayHandlerCppToC(CefDisplayHandler* cls);
CefDisplayHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DISPLAY_HANDLER_CPPTOC_H_

45
libcef_dll/cpptoc/domdocument_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/cpptoc/domnode_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
cef_dom_document_type_t CEF_CALLBACK domdocument_get_type(
@ -238,27 +240,34 @@ cef_string_userfree_t CEF_CALLBACK domdocument_get_complete_url(
return _retval.DetachToUserFree();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDOMDocumentCppToC::CefDOMDocumentCppToC(CefDOMDocument* cls)
: CefCppToC<CefDOMDocumentCppToC, CefDOMDocument, cef_domdocument_t>(cls) {
struct_.struct_.get_type = domdocument_get_type;
struct_.struct_.get_document = domdocument_get_document;
struct_.struct_.get_body = domdocument_get_body;
struct_.struct_.get_head = domdocument_get_head;
struct_.struct_.get_title = domdocument_get_title;
struct_.struct_.get_element_by_id = domdocument_get_element_by_id;
struct_.struct_.get_focused_node = domdocument_get_focused_node;
struct_.struct_.has_selection = domdocument_has_selection;
struct_.struct_.get_selection_start_offset =
CefDOMDocumentCppToC::CefDOMDocumentCppToC() {
GetStruct()->get_type = domdocument_get_type;
GetStruct()->get_document = domdocument_get_document;
GetStruct()->get_body = domdocument_get_body;
GetStruct()->get_head = domdocument_get_head;
GetStruct()->get_title = domdocument_get_title;
GetStruct()->get_element_by_id = domdocument_get_element_by_id;
GetStruct()->get_focused_node = domdocument_get_focused_node;
GetStruct()->has_selection = domdocument_has_selection;
GetStruct()->get_selection_start_offset =
domdocument_get_selection_start_offset;
struct_.struct_.get_selection_end_offset =
domdocument_get_selection_end_offset;
struct_.struct_.get_selection_as_markup = domdocument_get_selection_as_markup;
struct_.struct_.get_selection_as_text = domdocument_get_selection_as_text;
struct_.struct_.get_base_url = domdocument_get_base_url;
struct_.struct_.get_complete_url = domdocument_get_complete_url;
GetStruct()->get_selection_end_offset = domdocument_get_selection_end_offset;
GetStruct()->get_selection_as_markup = domdocument_get_selection_as_markup;
GetStruct()->get_selection_as_text = domdocument_get_selection_as_text;
GetStruct()->get_base_url = domdocument_get_base_url;
GetStruct()->get_complete_url = domdocument_get_complete_url;
}
template<> CefRefPtr<CefDOMDocument> CefCppToC<CefDOMDocumentCppToC,
CefDOMDocument, cef_domdocument_t>::UnwrapDerived(CefWrapperType type,
cef_domdocument_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -266,3 +275,5 @@ template<> base::AtomicRefCount CefCppToC<CefDOMDocumentCppToC, CefDOMDocument,
cef_domdocument_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDOMDocumentCppToC, CefDOMDocument,
cef_domdocument_t>::kWrapperType = WT_DOMDOCUMENT;

3
libcef_dll/cpptoc/domdocument_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDOMDocumentCppToC
: public CefCppToC<CefDOMDocumentCppToC, CefDOMDocument,
cef_domdocument_t> {
public:
explicit CefDOMDocumentCppToC(CefDOMDocument* cls);
CefDOMDocumentCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DOMDOCUMENT_CPPTOC_H_

65
libcef_dll/cpptoc/domnode_cpptoc.cc
View File

@ -15,6 +15,8 @@
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
cef_dom_node_type_t CEF_CALLBACK domnode_get_type(struct _cef_domnode_t* self) {
@ -427,37 +429,44 @@ cef_string_userfree_t CEF_CALLBACK domnode_get_element_inner_text(
return _retval.DetachToUserFree();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDOMNodeCppToC::CefDOMNodeCppToC(CefDOMNode* cls)
: CefCppToC<CefDOMNodeCppToC, CefDOMNode, cef_domnode_t>(cls) {
struct_.struct_.get_type = domnode_get_type;
struct_.struct_.is_text = domnode_is_text;
struct_.struct_.is_element = domnode_is_element;
struct_.struct_.is_editable = domnode_is_editable;
struct_.struct_.is_form_control_element = domnode_is_form_control_element;
struct_.struct_.get_form_control_element_type =
CefDOMNodeCppToC::CefDOMNodeCppToC() {
GetStruct()->get_type = domnode_get_type;
GetStruct()->is_text = domnode_is_text;
GetStruct()->is_element = domnode_is_element;
GetStruct()->is_editable = domnode_is_editable;
GetStruct()->is_form_control_element = domnode_is_form_control_element;
GetStruct()->get_form_control_element_type =
domnode_get_form_control_element_type;
struct_.struct_.is_same = domnode_is_same;
struct_.struct_.get_name = domnode_get_name;
struct_.struct_.get_value = domnode_get_value;
struct_.struct_.set_value = domnode_set_value;
struct_.struct_.get_as_markup = domnode_get_as_markup;
struct_.struct_.get_document = domnode_get_document;
struct_.struct_.get_parent = domnode_get_parent;
struct_.struct_.get_previous_sibling = domnode_get_previous_sibling;
struct_.struct_.get_next_sibling = domnode_get_next_sibling;
struct_.struct_.has_children = domnode_has_children;
struct_.struct_.get_first_child = domnode_get_first_child;
struct_.struct_.get_last_child = domnode_get_last_child;
struct_.struct_.get_element_tag_name = domnode_get_element_tag_name;
struct_.struct_.has_element_attributes = domnode_has_element_attributes;
struct_.struct_.has_element_attribute = domnode_has_element_attribute;
struct_.struct_.get_element_attribute = domnode_get_element_attribute;
struct_.struct_.get_element_attributes = domnode_get_element_attributes;
struct_.struct_.set_element_attribute = domnode_set_element_attribute;
struct_.struct_.get_element_inner_text = domnode_get_element_inner_text;
GetStruct()->is_same = domnode_is_same;
GetStruct()->get_name = domnode_get_name;
GetStruct()->get_value = domnode_get_value;
GetStruct()->set_value = domnode_set_value;
GetStruct()->get_as_markup = domnode_get_as_markup;
GetStruct()->get_document = domnode_get_document;
GetStruct()->get_parent = domnode_get_parent;
GetStruct()->get_previous_sibling = domnode_get_previous_sibling;
GetStruct()->get_next_sibling = domnode_get_next_sibling;
GetStruct()->has_children = domnode_has_children;
GetStruct()->get_first_child = domnode_get_first_child;
GetStruct()->get_last_child = domnode_get_last_child;
GetStruct()->get_element_tag_name = domnode_get_element_tag_name;
GetStruct()->has_element_attributes = domnode_has_element_attributes;
GetStruct()->has_element_attribute = domnode_has_element_attribute;
GetStruct()->get_element_attribute = domnode_get_element_attribute;
GetStruct()->get_element_attributes = domnode_get_element_attributes;
GetStruct()->set_element_attribute = domnode_set_element_attribute;
GetStruct()->get_element_inner_text = domnode_get_element_inner_text;
}
template<> CefRefPtr<CefDOMNode> CefCppToC<CefDOMNodeCppToC, CefDOMNode,
cef_domnode_t>::UnwrapDerived(CefWrapperType type, cef_domnode_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -465,3 +474,5 @@ template<> base::AtomicRefCount CefCppToC<CefDOMNodeCppToC, CefDOMNode,
cef_domnode_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDOMNodeCppToC, CefDOMNode,
cef_domnode_t>::kWrapperType = WT_DOMNODE;

3
libcef_dll/cpptoc/domnode_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefDOMNodeCppToC
: public CefCppToC<CefDOMNodeCppToC, CefDOMNode, cef_domnode_t> {
public:
explicit CefDOMNodeCppToC(CefDOMNode* cls);
CefDOMNodeCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DOMNODE_CPPTOC_H_

18
libcef_dll/cpptoc/domvisitor_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/ctocpp/domdocument_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK domvisitor_visit(struct _cef_domvisitor_t* self,
@ -33,12 +35,20 @@ void CEF_CALLBACK domvisitor_visit(struct _cef_domvisitor_t* self,
CefDOMDocumentCToCpp::Wrap(document));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDOMVisitorCppToC::CefDOMVisitorCppToC(CefDOMVisitor* cls)
: CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor, cef_domvisitor_t>(cls) {
struct_.struct_.visit = domvisitor_visit;
CefDOMVisitorCppToC::CefDOMVisitorCppToC() {
GetStruct()->visit = domvisitor_visit;
}
template<> CefRefPtr<CefDOMVisitor> CefCppToC<CefDOMVisitorCppToC,
CefDOMVisitor, cef_domvisitor_t>::UnwrapDerived(CefWrapperType type,
cef_domvisitor_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -46,3 +56,5 @@ template<> base::AtomicRefCount CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor,
cef_domvisitor_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor,
cef_domvisitor_t>::kWrapperType = WT_DOMVISITOR;

3
libcef_dll/cpptoc/domvisitor_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefDOMVisitorCppToC
: public CefCppToC<CefDOMVisitorCppToC, CefDOMVisitor, cef_domvisitor_t> {
public:
explicit CefDOMVisitorCppToC(CefDOMVisitor* cls);
CefDOMVisitorCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DOMVISITOR_CPPTOC_H_

22
libcef_dll/cpptoc/download_handler_cpptoc.cc
View File

@ -17,6 +17,8 @@
#include "libcef_dll/ctocpp/download_item_callback_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK download_handler_on_before_download(
@ -83,14 +85,21 @@ void CEF_CALLBACK download_handler_on_download_updated(
CefDownloadItemCallbackCToCpp::Wrap(callback));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDownloadHandlerCppToC::CefDownloadHandlerCppToC(CefDownloadHandler* cls)
: CefCppToC<CefDownloadHandlerCppToC, CefDownloadHandler,
cef_download_handler_t>(cls) {
struct_.struct_.on_before_download = download_handler_on_before_download;
struct_.struct_.on_download_updated = download_handler_on_download_updated;
CefDownloadHandlerCppToC::CefDownloadHandlerCppToC() {
GetStruct()->on_before_download = download_handler_on_before_download;
GetStruct()->on_download_updated = download_handler_on_download_updated;
}
template<> CefRefPtr<CefDownloadHandler> CefCppToC<CefDownloadHandlerCppToC,
CefDownloadHandler, cef_download_handler_t>::UnwrapDerived(
CefWrapperType type, cef_download_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -98,3 +107,6 @@ template<> base::AtomicRefCount CefCppToC<CefDownloadHandlerCppToC,
CefDownloadHandler, cef_download_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadHandlerCppToC,
CefDownloadHandler, cef_download_handler_t>::kWrapperType =
WT_DOWNLOAD_HANDLER;

3
libcef_dll/cpptoc/download_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDownloadHandlerCppToC
: public CefCppToC<CefDownloadHandlerCppToC, CefDownloadHandler,
cef_download_handler_t> {
public:
explicit CefDownloadHandlerCppToC(CefDownloadHandler* cls);
CefDownloadHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DOWNLOAD_HANDLER_CPPTOC_H_

25
libcef_dll/cpptoc/download_item_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/download_item_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK download_item_callback_cancel(
@ -51,16 +53,22 @@ void CEF_CALLBACK download_item_callback_resume(
CefDownloadItemCallbackCppToC::Get(self)->Resume();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDownloadItemCallbackCppToC::CefDownloadItemCallbackCppToC(
CefDownloadItemCallback* cls)
: CefCppToC<CefDownloadItemCallbackCppToC, CefDownloadItemCallback,
cef_download_item_callback_t>(cls) {
struct_.struct_.cancel = download_item_callback_cancel;
struct_.struct_.pause = download_item_callback_pause;
struct_.struct_.resume = download_item_callback_resume;
CefDownloadItemCallbackCppToC::CefDownloadItemCallbackCppToC() {
GetStruct()->cancel = download_item_callback_cancel;
GetStruct()->pause = download_item_callback_pause;
GetStruct()->resume = download_item_callback_resume;
}
template<> CefRefPtr<CefDownloadItemCallback> CefCppToC<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t>::UnwrapDerived(
CefWrapperType type, cef_download_item_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -68,3 +76,6 @@ template<> base::AtomicRefCount CefCppToC<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadItemCallbackCppToC,
CefDownloadItemCallback, cef_download_item_callback_t>::kWrapperType =
WT_DOWNLOAD_ITEM_CALLBACK;

3
libcef_dll/cpptoc/download_item_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDownloadItemCallbackCppToC
: public CefCppToC<CefDownloadItemCallbackCppToC, CefDownloadItemCallback,
cef_download_item_callback_t> {
public:
explicit CefDownloadItemCallbackCppToC(CefDownloadItemCallback* cls);
CefDownloadItemCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DOWNLOAD_ITEM_CALLBACK_CPPTOC_H_

53
libcef_dll/cpptoc/download_item_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/download_item_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK download_item_is_valid(struct _cef_download_item_t* self) {
@ -266,31 +268,36 @@ cef_string_userfree_t CEF_CALLBACK download_item_get_mime_type(
return _retval.DetachToUserFree();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDownloadItemCppToC::CefDownloadItemCppToC(CefDownloadItem* cls)
: CefCppToC<CefDownloadItemCppToC, CefDownloadItem, cef_download_item_t>(
cls) {
struct_.struct_.is_valid = download_item_is_valid;
struct_.struct_.is_in_progress = download_item_is_in_progress;
struct_.struct_.is_complete = download_item_is_complete;
struct_.struct_.is_canceled = download_item_is_canceled;
struct_.struct_.get_current_speed = download_item_get_current_speed;
struct_.struct_.get_percent_complete = download_item_get_percent_complete;
struct_.struct_.get_total_bytes = download_item_get_total_bytes;
struct_.struct_.get_received_bytes = download_item_get_received_bytes;
struct_.struct_.get_start_time = download_item_get_start_time;
struct_.struct_.get_end_time = download_item_get_end_time;
struct_.struct_.get_full_path = download_item_get_full_path;
struct_.struct_.get_id = download_item_get_id;
struct_.struct_.get_url = download_item_get_url;
struct_.struct_.get_original_url = download_item_get_original_url;
struct_.struct_.get_suggested_file_name =
download_item_get_suggested_file_name;
struct_.struct_.get_content_disposition =
download_item_get_content_disposition;
struct_.struct_.get_mime_type = download_item_get_mime_type;
CefDownloadItemCppToC::CefDownloadItemCppToC() {
GetStruct()->is_valid = download_item_is_valid;
GetStruct()->is_in_progress = download_item_is_in_progress;
GetStruct()->is_complete = download_item_is_complete;
GetStruct()->is_canceled = download_item_is_canceled;
GetStruct()->get_current_speed = download_item_get_current_speed;
GetStruct()->get_percent_complete = download_item_get_percent_complete;
GetStruct()->get_total_bytes = download_item_get_total_bytes;
GetStruct()->get_received_bytes = download_item_get_received_bytes;
GetStruct()->get_start_time = download_item_get_start_time;
GetStruct()->get_end_time = download_item_get_end_time;
GetStruct()->get_full_path = download_item_get_full_path;
GetStruct()->get_id = download_item_get_id;
GetStruct()->get_url = download_item_get_url;
GetStruct()->get_original_url = download_item_get_original_url;
GetStruct()->get_suggested_file_name = download_item_get_suggested_file_name;
GetStruct()->get_content_disposition = download_item_get_content_disposition;
GetStruct()->get_mime_type = download_item_get_mime_type;
}
template<> CefRefPtr<CefDownloadItem> CefCppToC<CefDownloadItemCppToC,
CefDownloadItem, cef_download_item_t>::UnwrapDerived(CefWrapperType type,
cef_download_item_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -298,3 +305,5 @@ template<> base::AtomicRefCount CefCppToC<CefDownloadItemCppToC,
CefDownloadItem, cef_download_item_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDownloadItemCppToC, CefDownloadItem,
cef_download_item_t>::kWrapperType = WT_DOWNLOAD_ITEM;

3
libcef_dll/cpptoc/download_item_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDownloadItemCppToC
: public CefCppToC<CefDownloadItemCppToC, CefDownloadItem,
cef_download_item_t> {
public:
explicit CefDownloadItemCppToC(CefDownloadItem* cls);
CefDownloadItemCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DOWNLOAD_ITEM_CPPTOC_H_

59
libcef_dll/cpptoc/drag_data_cpptoc.cc
View File

@ -28,6 +28,8 @@ CEF_EXPORT cef_drag_data_t* cef_drag_data_create() {
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
struct _cef_drag_data_t* CEF_CALLBACK drag_data_clone(
@ -365,33 +367,40 @@ void CEF_CALLBACK drag_data_add_file(struct _cef_drag_data_t* self,
CefString(display_name));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDragDataCppToC::CefDragDataCppToC(CefDragData* cls)
: CefCppToC<CefDragDataCppToC, CefDragData, cef_drag_data_t>(cls) {
struct_.struct_.clone = drag_data_clone;
struct_.struct_.is_read_only = drag_data_is_read_only;
struct_.struct_.is_link = drag_data_is_link;
struct_.struct_.is_fragment = drag_data_is_fragment;
struct_.struct_.is_file = drag_data_is_file;
struct_.struct_.get_link_url = drag_data_get_link_url;
struct_.struct_.get_link_title = drag_data_get_link_title;
struct_.struct_.get_link_metadata = drag_data_get_link_metadata;
struct_.struct_.get_fragment_text = drag_data_get_fragment_text;
struct_.struct_.get_fragment_html = drag_data_get_fragment_html;
struct_.struct_.get_fragment_base_url = drag_data_get_fragment_base_url;
struct_.struct_.get_file_name = drag_data_get_file_name;
struct_.struct_.get_file_contents = drag_data_get_file_contents;
struct_.struct_.get_file_names = drag_data_get_file_names;
struct_.struct_.set_link_url = drag_data_set_link_url;
struct_.struct_.set_link_title = drag_data_set_link_title;
struct_.struct_.set_link_metadata = drag_data_set_link_metadata;
struct_.struct_.set_fragment_text = drag_data_set_fragment_text;
struct_.struct_.set_fragment_html = drag_data_set_fragment_html;
struct_.struct_.set_fragment_base_url = drag_data_set_fragment_base_url;
struct_.struct_.reset_file_contents = drag_data_reset_file_contents;
struct_.struct_.add_file = drag_data_add_file;
CefDragDataCppToC::CefDragDataCppToC() {
GetStruct()->clone = drag_data_clone;
GetStruct()->is_read_only = drag_data_is_read_only;
GetStruct()->is_link = drag_data_is_link;
GetStruct()->is_fragment = drag_data_is_fragment;
GetStruct()->is_file = drag_data_is_file;
GetStruct()->get_link_url = drag_data_get_link_url;
GetStruct()->get_link_title = drag_data_get_link_title;
GetStruct()->get_link_metadata = drag_data_get_link_metadata;
GetStruct()->get_fragment_text = drag_data_get_fragment_text;
GetStruct()->get_fragment_html = drag_data_get_fragment_html;
GetStruct()->get_fragment_base_url = drag_data_get_fragment_base_url;
GetStruct()->get_file_name = drag_data_get_file_name;
GetStruct()->get_file_contents = drag_data_get_file_contents;
GetStruct()->get_file_names = drag_data_get_file_names;
GetStruct()->set_link_url = drag_data_set_link_url;
GetStruct()->set_link_title = drag_data_set_link_title;
GetStruct()->set_link_metadata = drag_data_set_link_metadata;
GetStruct()->set_fragment_text = drag_data_set_fragment_text;
GetStruct()->set_fragment_html = drag_data_set_fragment_html;
GetStruct()->set_fragment_base_url = drag_data_set_fragment_base_url;
GetStruct()->reset_file_contents = drag_data_reset_file_contents;
GetStruct()->add_file = drag_data_add_file;
}
template<> CefRefPtr<CefDragData> CefCppToC<CefDragDataCppToC, CefDragData,
cef_drag_data_t>::UnwrapDerived(CefWrapperType type, cef_drag_data_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -399,3 +408,5 @@ template<> base::AtomicRefCount CefCppToC<CefDragDataCppToC, CefDragData,
cef_drag_data_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDragDataCppToC, CefDragData,
cef_drag_data_t>::kWrapperType = WT_DRAG_DATA;

3
libcef_dll/cpptoc/drag_data_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefDragDataCppToC
: public CefCppToC<CefDragDataCppToC, CefDragData, cef_drag_data_t> {
public:
explicit CefDragDataCppToC(CefDragData* cls);
CefDragDataCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DRAG_DATA_CPPTOC_H_

18
libcef_dll/cpptoc/drag_handler_cpptoc.cc
View File

@ -15,6 +15,8 @@
#include "libcef_dll/ctocpp/drag_data_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK drag_handler_on_drag_enter(struct _cef_drag_handler_t* self,
@ -44,12 +46,20 @@ int CEF_CALLBACK drag_handler_on_drag_enter(struct _cef_drag_handler_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefDragHandlerCppToC::CefDragHandlerCppToC(CefDragHandler* cls)
: CefCppToC<CefDragHandlerCppToC, CefDragHandler, cef_drag_handler_t>(cls) {
struct_.struct_.on_drag_enter = drag_handler_on_drag_enter;
CefDragHandlerCppToC::CefDragHandlerCppToC() {
GetStruct()->on_drag_enter = drag_handler_on_drag_enter;
}
template<> CefRefPtr<CefDragHandler> CefCppToC<CefDragHandlerCppToC,
CefDragHandler, cef_drag_handler_t>::UnwrapDerived(CefWrapperType type,
cef_drag_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -57,3 +67,5 @@ template<> base::AtomicRefCount CefCppToC<CefDragHandlerCppToC, CefDragHandler,
cef_drag_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefDragHandlerCppToC, CefDragHandler,
cef_drag_handler_t>::kWrapperType = WT_DRAG_HANDLER;

3
libcef_dll/cpptoc/drag_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefDragHandlerCppToC
: public CefCppToC<CefDragHandlerCppToC, CefDragHandler,
cef_drag_handler_t> {
public:
explicit CefDragHandlerCppToC(CefDragHandler* cls);
CefDragHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_DRAG_HANDLER_CPPTOC_H_

21
libcef_dll/cpptoc/end_tracing_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/end_tracing_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK end_tracing_callback_on_end_tracing_complete(
@ -33,19 +35,28 @@ void CEF_CALLBACK end_tracing_callback_on_end_tracing_complete(
CefString(tracing_file));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefEndTracingCallbackCppToC::CefEndTracingCallbackCppToC(
CefEndTracingCallback* cls)
: CefCppToC<CefEndTracingCallbackCppToC, CefEndTracingCallback,
cef_end_tracing_callback_t>(cls) {
struct_.struct_.on_end_tracing_complete =
CefEndTracingCallbackCppToC::CefEndTracingCallbackCppToC() {
GetStruct()->on_end_tracing_complete =
end_tracing_callback_on_end_tracing_complete;
}
template<> CefRefPtr<CefEndTracingCallback> CefCppToC<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t>::UnwrapDerived(
CefWrapperType type, cef_end_tracing_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCppToC<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefEndTracingCallbackCppToC,
CefEndTracingCallback, cef_end_tracing_callback_t>::kWrapperType =
WT_END_TRACING_CALLBACK;

3
libcef_dll/cpptoc/end_tracing_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefEndTracingCallbackCppToC
: public CefCppToC<CefEndTracingCallbackCppToC, CefEndTracingCallback,
cef_end_tracing_callback_t> {
public:
explicit CefEndTracingCallbackCppToC(CefEndTracingCallback* cls);
CefEndTracingCallbackCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_END_TRACING_CALLBACK_CPPTOC_H_

23
libcef_dll/cpptoc/file_dialog_callback_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK file_dialog_callback_cont(
@ -52,15 +54,21 @@ void CEF_CALLBACK file_dialog_callback_cancel(
CefFileDialogCallbackCppToC::Get(self)->Cancel();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefFileDialogCallbackCppToC::CefFileDialogCallbackCppToC(
CefFileDialogCallback* cls)
: CefCppToC<CefFileDialogCallbackCppToC, CefFileDialogCallback,
cef_file_dialog_callback_t>(cls) {
struct_.struct_.cont = file_dialog_callback_cont;
struct_.struct_.cancel = file_dialog_callback_cancel;
CefFileDialogCallbackCppToC::CefFileDialogCallbackCppToC() {
GetStruct()->cont = file_dialog_callback_cont;
GetStruct()->cancel = file_dialog_callback_cancel;
}
template<> CefRefPtr<CefFileDialogCallback> CefCppToC<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t>::UnwrapDerived(
CefWrapperType type, cef_file_dialog_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -68,3 +76,6 @@ template<> base::AtomicRefCount CefCppToC<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFileDialogCallbackCppToC,
CefFileDialogCallback, cef_file_dialog_callback_t>::kWrapperType =
WT_FILE_DIALOG_CALLBACK;

3
libcef_dll/cpptoc/file_dialog_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefFileDialogCallbackCppToC
: public CefCppToC<CefFileDialogCallbackCppToC, CefFileDialogCallback,
cef_file_dialog_callback_t> {
public:
explicit CefFileDialogCallbackCppToC(CefFileDialogCallback* cls);
CefFileDialogCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_FILE_DIALOG_CALLBACK_CPPTOC_H_

18
libcef_dll/cpptoc/find_handler_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/ctocpp/browser_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK find_handler_on_find_result(struct _cef_find_handler_t* self,
@ -47,12 +49,20 @@ void CEF_CALLBACK find_handler_on_find_result(struct _cef_find_handler_t* self,
finalUpdate?true:false);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefFindHandlerCppToC::CefFindHandlerCppToC(CefFindHandler* cls)
: CefCppToC<CefFindHandlerCppToC, CefFindHandler, cef_find_handler_t>(cls) {
struct_.struct_.on_find_result = find_handler_on_find_result;
CefFindHandlerCppToC::CefFindHandlerCppToC() {
GetStruct()->on_find_result = find_handler_on_find_result;
}
template<> CefRefPtr<CefFindHandler> CefCppToC<CefFindHandlerCppToC,
CefFindHandler, cef_find_handler_t>::UnwrapDerived(CefWrapperType type,
cef_find_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -60,3 +70,5 @@ template<> base::AtomicRefCount CefCppToC<CefFindHandlerCppToC, CefFindHandler,
cef_find_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFindHandlerCppToC, CefFindHandler,
cef_find_handler_t>::kWrapperType = WT_FIND_HANDLER;

3
libcef_dll/cpptoc/find_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefFindHandlerCppToC
: public CefCppToC<CefFindHandlerCppToC, CefFindHandler,
cef_find_handler_t> {
public:
explicit CefFindHandlerCppToC(CefFindHandler* cls);
CefFindHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_FIND_HANDLER_CPPTOC_H_

23
libcef_dll/cpptoc/focus_handler_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/ctocpp/browser_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK focus_handler_on_take_focus(struct _cef_focus_handler_t* self,
@ -72,15 +74,22 @@ void CEF_CALLBACK focus_handler_on_got_focus(struct _cef_focus_handler_t* self,
CefBrowserCToCpp::Wrap(browser));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefFocusHandlerCppToC::CefFocusHandlerCppToC(CefFocusHandler* cls)
: CefCppToC<CefFocusHandlerCppToC, CefFocusHandler, cef_focus_handler_t>(
cls) {
struct_.struct_.on_take_focus = focus_handler_on_take_focus;
struct_.struct_.on_set_focus = focus_handler_on_set_focus;
struct_.struct_.on_got_focus = focus_handler_on_got_focus;
CefFocusHandlerCppToC::CefFocusHandlerCppToC() {
GetStruct()->on_take_focus = focus_handler_on_take_focus;
GetStruct()->on_set_focus = focus_handler_on_set_focus;
GetStruct()->on_got_focus = focus_handler_on_got_focus;
}
template<> CefRefPtr<CefFocusHandler> CefCppToC<CefFocusHandlerCppToC,
CefFocusHandler, cef_focus_handler_t>::UnwrapDerived(CefWrapperType type,
cef_focus_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -88,3 +97,5 @@ template<> base::AtomicRefCount CefCppToC<CefFocusHandlerCppToC,
CefFocusHandler, cef_focus_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFocusHandlerCppToC, CefFocusHandler,
cef_focus_handler_t>::kWrapperType = WT_FOCUS_HANDLER;

3
libcef_dll/cpptoc/focus_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefFocusHandlerCppToC
: public CefCppToC<CefFocusHandlerCppToC, CefFocusHandler,
cef_focus_handler_t> {
public:
explicit CefFocusHandlerCppToC(CefFocusHandler* cls);
CefFocusHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_FOCUS_HANDLER_CPPTOC_H_

63
libcef_dll/cpptoc/frame_cpptoc.cc
View File

@ -18,6 +18,8 @@
#include "libcef_dll/ctocpp/string_visitor_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK frame_is_valid(struct _cef_frame_t* self) {
@ -363,35 +365,42 @@ void CEF_CALLBACK frame_visit_dom(struct _cef_frame_t* self,
CefDOMVisitorCToCpp::Wrap(visitor));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefFrameCppToC::CefFrameCppToC(CefFrame* cls)
: CefCppToC<CefFrameCppToC, CefFrame, cef_frame_t>(cls) {
struct_.struct_.is_valid = frame_is_valid;
struct_.struct_.undo = frame_undo;
struct_.struct_.redo = frame_redo;
struct_.struct_.cut = frame_cut;
struct_.struct_.copy = frame_copy;
struct_.struct_.paste = frame_paste;
struct_.struct_.del = frame_del;
struct_.struct_.select_all = frame_select_all;
struct_.struct_.view_source = frame_view_source;
struct_.struct_.get_source = frame_get_source;
struct_.struct_.get_text = frame_get_text;
struct_.struct_.load_request = frame_load_request;
struct_.struct_.load_url = frame_load_url;
struct_.struct_.load_string = frame_load_string;
struct_.struct_.execute_java_script = frame_execute_java_script;
struct_.struct_.is_main = frame_is_main;
struct_.struct_.is_focused = frame_is_focused;
struct_.struct_.get_name = frame_get_name;
struct_.struct_.get_identifier = frame_get_identifier;
struct_.struct_.get_parent = frame_get_parent;
struct_.struct_.get_url = frame_get_url;
struct_.struct_.get_browser = frame_get_browser;
struct_.struct_.get_v8context = frame_get_v8context;
struct_.struct_.visit_dom = frame_visit_dom;
CefFrameCppToC::CefFrameCppToC() {
GetStruct()->is_valid = frame_is_valid;
GetStruct()->undo = frame_undo;
GetStruct()->redo = frame_redo;
GetStruct()->cut = frame_cut;
GetStruct()->copy = frame_copy;
GetStruct()->paste = frame_paste;
GetStruct()->del = frame_del;
GetStruct()->select_all = frame_select_all;
GetStruct()->view_source = frame_view_source;
GetStruct()->get_source = frame_get_source;
GetStruct()->get_text = frame_get_text;
GetStruct()->load_request = frame_load_request;
GetStruct()->load_url = frame_load_url;
GetStruct()->load_string = frame_load_string;
GetStruct()->execute_java_script = frame_execute_java_script;
GetStruct()->is_main = frame_is_main;
GetStruct()->is_focused = frame_is_focused;
GetStruct()->get_name = frame_get_name;
GetStruct()->get_identifier = frame_get_identifier;
GetStruct()->get_parent = frame_get_parent;
GetStruct()->get_url = frame_get_url;
GetStruct()->get_browser = frame_get_browser;
GetStruct()->get_v8context = frame_get_v8context;
GetStruct()->visit_dom = frame_visit_dom;
}
template<> CefRefPtr<CefFrame> CefCppToC<CefFrameCppToC, CefFrame,
cef_frame_t>::UnwrapDerived(CefWrapperType type, cef_frame_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -399,3 +408,5 @@ template<> base::AtomicRefCount CefCppToC<CefFrameCppToC, CefFrame,
cef_frame_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefFrameCppToC, CefFrame,
cef_frame_t>::kWrapperType = WT_FRAME;

3
libcef_dll/cpptoc/frame_cpptoc.h
View File

@ -31,9 +31,8 @@
class CefFrameCppToC
: public CefCppToC<CefFrameCppToC, CefFrame, cef_frame_t> {
public:
explicit CefFrameCppToC(CefFrame* cls);
CefFrameCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_FRAME_CPPTOC_H_

21
libcef_dll/cpptoc/geolocation_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/geolocation_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK geolocation_callback_cont(
@ -28,14 +30,20 @@ void CEF_CALLBACK geolocation_callback_cont(
allow?true:false);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefGeolocationCallbackCppToC::CefGeolocationCallbackCppToC(
CefGeolocationCallback* cls)
: CefCppToC<CefGeolocationCallbackCppToC, CefGeolocationCallback,
cef_geolocation_callback_t>(cls) {
struct_.struct_.cont = geolocation_callback_cont;
CefGeolocationCallbackCppToC::CefGeolocationCallbackCppToC() {
GetStruct()->cont = geolocation_callback_cont;
}
template<> CefRefPtr<CefGeolocationCallback> CefCppToC<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t>::UnwrapDerived(
CefWrapperType type, cef_geolocation_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -43,3 +51,6 @@ template<> base::AtomicRefCount CefCppToC<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefGeolocationCallbackCppToC,
CefGeolocationCallback, cef_geolocation_callback_t>::kWrapperType =
WT_GEOLOCATION_CALLBACK;

3
libcef_dll/cpptoc/geolocation_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefGeolocationCallbackCppToC
: public CefCppToC<CefGeolocationCallbackCppToC, CefGeolocationCallback,
cef_geolocation_callback_t> {
public:
explicit CefGeolocationCallbackCppToC(CefGeolocationCallback* cls);
CefGeolocationCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_GEOLOCATION_CALLBACK_CPPTOC_H_

23
libcef_dll/cpptoc/geolocation_handler_cpptoc.cc
View File

@ -15,6 +15,8 @@
#include "libcef_dll/ctocpp/geolocation_callback_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK geolocation_handler_on_request_geolocation_permission(
@ -75,21 +77,30 @@ void CEF_CALLBACK geolocation_handler_on_cancel_geolocation_permission(
request_id);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefGeolocationHandlerCppToC::CefGeolocationHandlerCppToC(
CefGeolocationHandler* cls)
: CefCppToC<CefGeolocationHandlerCppToC, CefGeolocationHandler,
cef_geolocation_handler_t>(cls) {
struct_.struct_.on_request_geolocation_permission =
CefGeolocationHandlerCppToC::CefGeolocationHandlerCppToC() {
GetStruct()->on_request_geolocation_permission =
geolocation_handler_on_request_geolocation_permission;
struct_.struct_.on_cancel_geolocation_permission =
GetStruct()->on_cancel_geolocation_permission =
geolocation_handler_on_cancel_geolocation_permission;
}
template<> CefRefPtr<CefGeolocationHandler> CefCppToC<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t>::UnwrapDerived(
CefWrapperType type, cef_geolocation_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCppToC<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefGeolocationHandlerCppToC,
CefGeolocationHandler, cef_geolocation_handler_t>::kWrapperType =
WT_GEOLOCATION_HANDLER;

3
libcef_dll/cpptoc/geolocation_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefGeolocationHandlerCppToC
: public CefCppToC<CefGeolocationHandlerCppToC, CefGeolocationHandler,
cef_geolocation_handler_t> {
public:
explicit CefGeolocationHandlerCppToC(CefGeolocationHandler* cls);
CefGeolocationHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_GEOLOCATION_HANDLER_CPPTOC_H_

22
libcef_dll/cpptoc/get_geolocation_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK get_geolocation_callback_on_location_update(
@ -38,15 +40,20 @@ void CEF_CALLBACK get_geolocation_callback_on_location_update(
positionObj);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefGetGeolocationCallbackCppToC::CefGetGeolocationCallbackCppToC(
CefGetGeolocationCallback* cls)
: CefCppToC<CefGetGeolocationCallbackCppToC, CefGetGeolocationCallback,
cef_get_geolocation_callback_t>(cls) {
struct_.struct_.on_location_update =
get_geolocation_callback_on_location_update;
CefGetGeolocationCallbackCppToC::CefGetGeolocationCallbackCppToC() {
GetStruct()->on_location_update = get_geolocation_callback_on_location_update;
}
template<> CefRefPtr<CefGetGeolocationCallback> CefCppToC<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t>::UnwrapDerived(
CefWrapperType type, cef_get_geolocation_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -55,3 +62,6 @@ template<> base::AtomicRefCount CefCppToC<CefGetGeolocationCallbackCppToC,
0;
#endif
template<> CefWrapperType CefCppToC<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t>::kWrapperType =
WT_GET_GEOLOCATION_CALLBACK;

3
libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefGetGeolocationCallbackCppToC
: public CefCppToC<CefGetGeolocationCallbackCppToC,
CefGetGeolocationCallback, cef_get_geolocation_callback_t> {
public:
explicit CefGetGeolocationCallbackCppToC(CefGetGeolocationCallback* cls);
CefGetGeolocationCallbackCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_

20
libcef_dll/cpptoc/jsdialog_callback_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/jsdialog_callback_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK jsdialog_callback_cont(struct _cef_jsdialog_callback_t* self,
@ -30,13 +32,20 @@ void CEF_CALLBACK jsdialog_callback_cont(struct _cef_jsdialog_callback_t* self,
CefString(user_input));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefJSDialogCallbackCppToC::CefJSDialogCallbackCppToC(CefJSDialogCallback* cls)
: CefCppToC<CefJSDialogCallbackCppToC, CefJSDialogCallback,
cef_jsdialog_callback_t>(cls) {
struct_.struct_.cont = jsdialog_callback_cont;
CefJSDialogCallbackCppToC::CefJSDialogCallbackCppToC() {
GetStruct()->cont = jsdialog_callback_cont;
}
template<> CefRefPtr<CefJSDialogCallback> CefCppToC<CefJSDialogCallbackCppToC,
CefJSDialogCallback, cef_jsdialog_callback_t>::UnwrapDerived(
CefWrapperType type, cef_jsdialog_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -44,3 +53,6 @@ template<> base::AtomicRefCount CefCppToC<CefJSDialogCallbackCppToC,
CefJSDialogCallback, cef_jsdialog_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefJSDialogCallbackCppToC,
CefJSDialogCallback, cef_jsdialog_callback_t>::kWrapperType =
WT_JSDIALOG_CALLBACK;

3
libcef_dll/cpptoc/jsdialog_callback_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefJSDialogCallbackCppToC
: public CefCppToC<CefJSDialogCallbackCppToC, CefJSDialogCallback,
cef_jsdialog_callback_t> {
public:
explicit CefJSDialogCallbackCppToC(CefJSDialogCallback* cls);
CefJSDialogCallbackCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_JSDIALOG_CALLBACK_CPPTOC_H_

27
libcef_dll/cpptoc/jsdialog_handler_cpptoc.cc
View File

@ -15,6 +15,8 @@
#include "libcef_dll/ctocpp/jsdialog_callback_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK jsdialog_handler_on_jsdialog(
@ -130,18 +132,24 @@ void CEF_CALLBACK jsdialog_handler_on_dialog_closed(
CefBrowserCToCpp::Wrap(browser));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefJSDialogHandlerCppToC::CefJSDialogHandlerCppToC(CefJSDialogHandler* cls)
: CefCppToC<CefJSDialogHandlerCppToC, CefJSDialogHandler,
cef_jsdialog_handler_t>(cls) {
struct_.struct_.on_jsdialog = jsdialog_handler_on_jsdialog;
struct_.struct_.on_before_unload_dialog =
CefJSDialogHandlerCppToC::CefJSDialogHandlerCppToC() {
GetStruct()->on_jsdialog = jsdialog_handler_on_jsdialog;
GetStruct()->on_before_unload_dialog =
jsdialog_handler_on_before_unload_dialog;
struct_.struct_.on_reset_dialog_state =
jsdialog_handler_on_reset_dialog_state;
struct_.struct_.on_dialog_closed = jsdialog_handler_on_dialog_closed;
GetStruct()->on_reset_dialog_state = jsdialog_handler_on_reset_dialog_state;
GetStruct()->on_dialog_closed = jsdialog_handler_on_dialog_closed;
}
template<> CefRefPtr<CefJSDialogHandler> CefCppToC<CefJSDialogHandlerCppToC,
CefJSDialogHandler, cef_jsdialog_handler_t>::UnwrapDerived(
CefWrapperType type, cef_jsdialog_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -149,3 +157,6 @@ template<> base::AtomicRefCount CefCppToC<CefJSDialogHandlerCppToC,
CefJSDialogHandler, cef_jsdialog_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefJSDialogHandlerCppToC,
CefJSDialogHandler, cef_jsdialog_handler_t>::kWrapperType =
WT_JSDIALOG_HANDLER;

3
libcef_dll/cpptoc/jsdialog_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefJSDialogHandlerCppToC
: public CefCppToC<CefJSDialogHandlerCppToC, CefJSDialogHandler,
cef_jsdialog_handler_t> {
public:
explicit CefJSDialogHandlerCppToC(CefJSDialogHandler* cls);
CefJSDialogHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_JSDIALOG_HANDLER_CPPTOC_H_

22
libcef_dll/cpptoc/keyboard_handler_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/ctocpp/browser_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK keyboard_handler_on_pre_key_event(
@ -93,14 +95,21 @@ int CEF_CALLBACK keyboard_handler_on_key_event(
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefKeyboardHandlerCppToC::CefKeyboardHandlerCppToC(CefKeyboardHandler* cls)
: CefCppToC<CefKeyboardHandlerCppToC, CefKeyboardHandler,
cef_keyboard_handler_t>(cls) {
struct_.struct_.on_pre_key_event = keyboard_handler_on_pre_key_event;
struct_.struct_.on_key_event = keyboard_handler_on_key_event;
CefKeyboardHandlerCppToC::CefKeyboardHandlerCppToC() {
GetStruct()->on_pre_key_event = keyboard_handler_on_pre_key_event;
GetStruct()->on_key_event = keyboard_handler_on_key_event;
}
template<> CefRefPtr<CefKeyboardHandler> CefCppToC<CefKeyboardHandlerCppToC,
CefKeyboardHandler, cef_keyboard_handler_t>::UnwrapDerived(
CefWrapperType type, cef_keyboard_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -108,3 +117,6 @@ template<> base::AtomicRefCount CefCppToC<CefKeyboardHandlerCppToC,
CefKeyboardHandler, cef_keyboard_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefKeyboardHandlerCppToC,
CefKeyboardHandler, cef_keyboard_handler_t>::kWrapperType =
WT_KEYBOARD_HANDLER;

3
libcef_dll/cpptoc/keyboard_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefKeyboardHandlerCppToC
: public CefCppToC<CefKeyboardHandlerCppToC, CefKeyboardHandler,
cef_keyboard_handler_t> {
public:
explicit CefKeyboardHandlerCppToC(CefKeyboardHandler* cls);
CefKeyboardHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_KEYBOARD_HANDLER_CPPTOC_H_

28
libcef_dll/cpptoc/life_span_handler_cpptoc.cc
View File

@ -16,6 +16,8 @@
#include "libcef_dll/ctocpp/frame_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK life_span_handler_on_before_popup(
@ -194,17 +196,24 @@ void CEF_CALLBACK life_span_handler_on_before_close(
CefBrowserCToCpp::Wrap(browser));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefLifeSpanHandlerCppToC::CefLifeSpanHandlerCppToC(CefLifeSpanHandler* cls)
: CefCppToC<CefLifeSpanHandlerCppToC, CefLifeSpanHandler,
cef_life_span_handler_t>(cls) {
struct_.struct_.on_before_popup = life_span_handler_on_before_popup;
struct_.struct_.on_after_created = life_span_handler_on_after_created;
struct_.struct_.run_modal = life_span_handler_run_modal;
struct_.struct_.do_close = life_span_handler_do_close;
struct_.struct_.on_before_close = life_span_handler_on_before_close;
CefLifeSpanHandlerCppToC::CefLifeSpanHandlerCppToC() {
GetStruct()->on_before_popup = life_span_handler_on_before_popup;
GetStruct()->on_after_created = life_span_handler_on_after_created;
GetStruct()->run_modal = life_span_handler_run_modal;
GetStruct()->do_close = life_span_handler_do_close;
GetStruct()->on_before_close = life_span_handler_on_before_close;
}
template<> CefRefPtr<CefLifeSpanHandler> CefCppToC<CefLifeSpanHandlerCppToC,
CefLifeSpanHandler, cef_life_span_handler_t>::UnwrapDerived(
CefWrapperType type, cef_life_span_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -212,3 +221,6 @@ template<> base::AtomicRefCount CefCppToC<CefLifeSpanHandlerCppToC,
CefLifeSpanHandler, cef_life_span_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefLifeSpanHandlerCppToC,
CefLifeSpanHandler, cef_life_span_handler_t>::kWrapperType =
WT_LIFE_SPAN_HANDLER;

3
libcef_dll/cpptoc/life_span_handler_cpptoc.h
View File

@ -30,9 +30,8 @@ class CefLifeSpanHandlerCppToC
: public CefCppToC<CefLifeSpanHandlerCppToC, CefLifeSpanHandler,
cef_life_span_handler_t> {
public:
explicit CefLifeSpanHandlerCppToC(CefLifeSpanHandler* cls);
CefLifeSpanHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_LIFE_SPAN_HANDLER_CPPTOC_H_

72
libcef_dll/cpptoc/list_value_cpptoc.cc
View File

@ -29,6 +29,8 @@ CEF_EXPORT cef_list_value_t* cef_list_value_create() {
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK list_value_is_valid(struct _cef_list_value_t* self) {
@ -576,39 +578,47 @@ int CEF_CALLBACK list_value_set_list(struct _cef_list_value_t* self, int index,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefListValueCppToC::CefListValueCppToC(CefListValue* cls)
: CefCppToC<CefListValueCppToC, CefListValue, cef_list_value_t>(cls) {
struct_.struct_.is_valid = list_value_is_valid;
struct_.struct_.is_owned = list_value_is_owned;
struct_.struct_.is_read_only = list_value_is_read_only;
struct_.struct_.is_same = list_value_is_same;
struct_.struct_.is_equal = list_value_is_equal;
struct_.struct_.copy = list_value_copy;
struct_.struct_.set_size = list_value_set_size;
struct_.struct_.get_size = list_value_get_size;
struct_.struct_.clear = list_value_clear;
struct_.struct_.remove = list_value_remove;
struct_.struct_.get_type = list_value_get_type;
struct_.struct_.get_value = list_value_get_value;
struct_.struct_.get_bool = list_value_get_bool;
struct_.struct_.get_int = list_value_get_int;
struct_.struct_.get_double = list_value_get_double;
struct_.struct_.get_string = list_value_get_string;
struct_.struct_.get_binary = list_value_get_binary;
struct_.struct_.get_dictionary = list_value_get_dictionary;
struct_.struct_.get_list = list_value_get_list;
struct_.struct_.set_value = list_value_set_value;
struct_.struct_.set_null = list_value_set_null;
struct_.struct_.set_bool = list_value_set_bool;
struct_.struct_.set_int = list_value_set_int;
struct_.struct_.set_double = list_value_set_double;
struct_.struct_.set_string = list_value_set_string;
struct_.struct_.set_binary = list_value_set_binary;
struct_.struct_.set_dictionary = list_value_set_dictionary;
struct_.struct_.set_list = list_value_set_list;
CefListValueCppToC::CefListValueCppToC() {
GetStruct()->is_valid = list_value_is_valid;
GetStruct()->is_owned = list_value_is_owned;
GetStruct()->is_read_only = list_value_is_read_only;
GetStruct()->is_same = list_value_is_same;
GetStruct()->is_equal = list_value_is_equal;
GetStruct()->copy = list_value_copy;
GetStruct()->set_size = list_value_set_size;
GetStruct()->get_size = list_value_get_size;
GetStruct()->clear = list_value_clear;
GetStruct()->remove = list_value_remove;
GetStruct()->get_type = list_value_get_type;
GetStruct()->get_value = list_value_get_value;
GetStruct()->get_bool = list_value_get_bool;
GetStruct()->get_int = list_value_get_int;
GetStruct()->get_double = list_value_get_double;
GetStruct()->get_string = list_value_get_string;
GetStruct()->get_binary = list_value_get_binary;
GetStruct()->get_dictionary = list_value_get_dictionary;
GetStruct()->get_list = list_value_get_list;
GetStruct()->set_value = list_value_set_value;
GetStruct()->set_null = list_value_set_null;
GetStruct()->set_bool = list_value_set_bool;
GetStruct()->set_int = list_value_set_int;
GetStruct()->set_double = list_value_set_double;
GetStruct()->set_string = list_value_set_string;
GetStruct()->set_binary = list_value_set_binary;
GetStruct()->set_dictionary = list_value_set_dictionary;
GetStruct()->set_list = list_value_set_list;
}
template<> CefRefPtr<CefListValue> CefCppToC<CefListValueCppToC, CefListValue,
cef_list_value_t>::UnwrapDerived(CefWrapperType type,
cef_list_value_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -616,3 +626,5 @@ template<> base::AtomicRefCount CefCppToC<CefListValueCppToC, CefListValue,
cef_list_value_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefListValueCppToC, CefListValue,
cef_list_value_t>::kWrapperType = WT_LIST_VALUE;

3
libcef_dll/cpptoc/list_value_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefListValueCppToC
: public CefCppToC<CefListValueCppToC, CefListValue, cef_list_value_t> {
public:
explicit CefListValueCppToC(CefListValue* cls);
CefListValueCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_LIST_VALUE_CPPTOC_H_

25
libcef_dll/cpptoc/load_handler_cpptoc.cc
View File

@ -15,6 +15,8 @@
#include "libcef_dll/ctocpp/frame_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK load_handler_on_loading_state_change(
@ -114,16 +116,23 @@ void CEF_CALLBACK load_handler_on_load_error(struct _cef_load_handler_t* self,
CefString(failedUrl));
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefLoadHandlerCppToC::CefLoadHandlerCppToC(CefLoadHandler* cls)
: CefCppToC<CefLoadHandlerCppToC, CefLoadHandler, cef_load_handler_t>(cls) {
struct_.struct_.on_loading_state_change =
load_handler_on_loading_state_change;
struct_.struct_.on_load_start = load_handler_on_load_start;
struct_.struct_.on_load_end = load_handler_on_load_end;
struct_.struct_.on_load_error = load_handler_on_load_error;
CefLoadHandlerCppToC::CefLoadHandlerCppToC() {
GetStruct()->on_loading_state_change = load_handler_on_loading_state_change;
GetStruct()->on_load_start = load_handler_on_load_start;
GetStruct()->on_load_end = load_handler_on_load_end;
GetStruct()->on_load_error = load_handler_on_load_error;
}
template<> CefRefPtr<CefLoadHandler> CefCppToC<CefLoadHandlerCppToC,
CefLoadHandler, cef_load_handler_t>::UnwrapDerived(CefWrapperType type,
cef_load_handler_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -131,3 +140,5 @@ template<> base::AtomicRefCount CefCppToC<CefLoadHandlerCppToC, CefLoadHandler,
cef_load_handler_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefLoadHandlerCppToC, CefLoadHandler,
cef_load_handler_t>::kWrapperType = WT_LOAD_HANDLER;

3
libcef_dll/cpptoc/load_handler_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefLoadHandlerCppToC
: public CefCppToC<CefLoadHandlerCppToC, CefLoadHandler,
cef_load_handler_t> {
public:
explicit CefLoadHandlerCppToC(CefLoadHandler* cls);
CefLoadHandlerCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_LOAD_HANDLER_CPPTOC_H_

114
libcef_dll/cpptoc/menu_model_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/menu_model_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK menu_model_clear(struct _cef_menu_model_t* self) {
@ -957,60 +959,68 @@ int CEF_CALLBACK menu_model_get_accelerator_at(struct _cef_menu_model_t* self,
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefMenuModelCppToC::CefMenuModelCppToC(CefMenuModel* cls)
: CefCppToC<CefMenuModelCppToC, CefMenuModel, cef_menu_model_t>(cls) {
struct_.struct_.clear = menu_model_clear;
struct_.struct_.get_count = menu_model_get_count;
struct_.struct_.add_separator = menu_model_add_separator;
struct_.struct_.add_item = menu_model_add_item;
struct_.struct_.add_check_item = menu_model_add_check_item;
struct_.struct_.add_radio_item = menu_model_add_radio_item;
struct_.struct_.add_sub_menu = menu_model_add_sub_menu;
struct_.struct_.insert_separator_at = menu_model_insert_separator_at;
struct_.struct_.insert_item_at = menu_model_insert_item_at;
struct_.struct_.insert_check_item_at = menu_model_insert_check_item_at;
struct_.struct_.insert_radio_item_at = menu_model_insert_radio_item_at;
struct_.struct_.insert_sub_menu_at = menu_model_insert_sub_menu_at;
struct_.struct_.remove = menu_model_remove;
struct_.struct_.remove_at = menu_model_remove_at;
struct_.struct_.get_index_of = menu_model_get_index_of;
struct_.struct_.get_command_id_at = menu_model_get_command_id_at;
struct_.struct_.set_command_id_at = menu_model_set_command_id_at;
struct_.struct_.get_label = menu_model_get_label;
struct_.struct_.get_label_at = menu_model_get_label_at;
struct_.struct_.set_label = menu_model_set_label;
struct_.struct_.set_label_at = menu_model_set_label_at;
struct_.struct_.get_type = menu_model_get_type;
struct_.struct_.get_type_at = menu_model_get_type_at;
struct_.struct_.get_group_id = menu_model_get_group_id;
struct_.struct_.get_group_id_at = menu_model_get_group_id_at;
struct_.struct_.set_group_id = menu_model_set_group_id;
struct_.struct_.set_group_id_at = menu_model_set_group_id_at;
struct_.struct_.get_sub_menu = menu_model_get_sub_menu;
struct_.struct_.get_sub_menu_at = menu_model_get_sub_menu_at;
struct_.struct_.is_visible = menu_model_is_visible;
struct_.struct_.is_visible_at = menu_model_is_visible_at;
struct_.struct_.set_visible = menu_model_set_visible;
struct_.struct_.set_visible_at = menu_model_set_visible_at;
struct_.struct_.is_enabled = menu_model_is_enabled;
struct_.struct_.is_enabled_at = menu_model_is_enabled_at;
struct_.struct_.set_enabled = menu_model_set_enabled;
struct_.struct_.set_enabled_at = menu_model_set_enabled_at;
struct_.struct_.is_checked = menu_model_is_checked;
struct_.struct_.is_checked_at = menu_model_is_checked_at;
struct_.struct_.set_checked = menu_model_set_checked;
struct_.struct_.set_checked_at = menu_model_set_checked_at;
struct_.struct_.has_accelerator = menu_model_has_accelerator;
struct_.struct_.has_accelerator_at = menu_model_has_accelerator_at;
struct_.struct_.set_accelerator = menu_model_set_accelerator;
struct_.struct_.set_accelerator_at = menu_model_set_accelerator_at;
struct_.struct_.remove_accelerator = menu_model_remove_accelerator;
struct_.struct_.remove_accelerator_at = menu_model_remove_accelerator_at;
struct_.struct_.get_accelerator = menu_model_get_accelerator;
struct_.struct_.get_accelerator_at = menu_model_get_accelerator_at;
CefMenuModelCppToC::CefMenuModelCppToC() {
GetStruct()->clear = menu_model_clear;
GetStruct()->get_count = menu_model_get_count;
GetStruct()->add_separator = menu_model_add_separator;
GetStruct()->add_item = menu_model_add_item;
GetStruct()->add_check_item = menu_model_add_check_item;
GetStruct()->add_radio_item = menu_model_add_radio_item;
GetStruct()->add_sub_menu = menu_model_add_sub_menu;
GetStruct()->insert_separator_at = menu_model_insert_separator_at;
GetStruct()->insert_item_at = menu_model_insert_item_at;
GetStruct()->insert_check_item_at = menu_model_insert_check_item_at;
GetStruct()->insert_radio_item_at = menu_model_insert_radio_item_at;
GetStruct()->insert_sub_menu_at = menu_model_insert_sub_menu_at;
GetStruct()->remove = menu_model_remove;
GetStruct()->remove_at = menu_model_remove_at;
GetStruct()->get_index_of = menu_model_get_index_of;
GetStruct()->get_command_id_at = menu_model_get_command_id_at;
GetStruct()->set_command_id_at = menu_model_set_command_id_at;
GetStruct()->get_label = menu_model_get_label;
GetStruct()->get_label_at = menu_model_get_label_at;
GetStruct()->set_label = menu_model_set_label;
GetStruct()->set_label_at = menu_model_set_label_at;
GetStruct()->get_type = menu_model_get_type;
GetStruct()->get_type_at = menu_model_get_type_at;
GetStruct()->get_group_id = menu_model_get_group_id;
GetStruct()->get_group_id_at = menu_model_get_group_id_at;
GetStruct()->set_group_id = menu_model_set_group_id;
GetStruct()->set_group_id_at = menu_model_set_group_id_at;
GetStruct()->get_sub_menu = menu_model_get_sub_menu;
GetStruct()->get_sub_menu_at = menu_model_get_sub_menu_at;
GetStruct()->is_visible = menu_model_is_visible;
GetStruct()->is_visible_at = menu_model_is_visible_at;
GetStruct()->set_visible = menu_model_set_visible;
GetStruct()->set_visible_at = menu_model_set_visible_at;
GetStruct()->is_enabled = menu_model_is_enabled;
GetStruct()->is_enabled_at = menu_model_is_enabled_at;
GetStruct()->set_enabled = menu_model_set_enabled;
GetStruct()->set_enabled_at = menu_model_set_enabled_at;
GetStruct()->is_checked = menu_model_is_checked;
GetStruct()->is_checked_at = menu_model_is_checked_at;
GetStruct()->set_checked = menu_model_set_checked;
GetStruct()->set_checked_at = menu_model_set_checked_at;
GetStruct()->has_accelerator = menu_model_has_accelerator;
GetStruct()->has_accelerator_at = menu_model_has_accelerator_at;
GetStruct()->set_accelerator = menu_model_set_accelerator;
GetStruct()->set_accelerator_at = menu_model_set_accelerator_at;
GetStruct()->remove_accelerator = menu_model_remove_accelerator;
GetStruct()->remove_accelerator_at = menu_model_remove_accelerator_at;
GetStruct()->get_accelerator = menu_model_get_accelerator;
GetStruct()->get_accelerator_at = menu_model_get_accelerator_at;
}
template<> CefRefPtr<CefMenuModel> CefCppToC<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t>::UnwrapDerived(CefWrapperType type,
cef_menu_model_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -1018,3 +1028,5 @@ template<> base::AtomicRefCount CefCppToC<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefMenuModelCppToC, CefMenuModel,
cef_menu_model_t>::kWrapperType = WT_MENU_MODEL;

3
libcef_dll/cpptoc/menu_model_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefMenuModelCppToC
: public CefCppToC<CefMenuModelCppToC, CefMenuModel, cef_menu_model_t> {
public:
explicit CefMenuModelCppToC(CefMenuModel* cls);
CefMenuModelCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_MENU_MODEL_CPPTOC_H_

38
libcef_dll/cpptoc/navigation_entry_cpptoc.cc
View File

@ -13,6 +13,8 @@
#include "libcef_dll/cpptoc/navigation_entry_cpptoc.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK navigation_entry_is_valid(
@ -166,22 +168,29 @@ int CEF_CALLBACK navigation_entry_get_http_status_code(
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefNavigationEntryCppToC::CefNavigationEntryCppToC(CefNavigationEntry* cls)
: CefCppToC<CefNavigationEntryCppToC, CefNavigationEntry,
cef_navigation_entry_t>(cls) {
struct_.struct_.is_valid = navigation_entry_is_valid;
struct_.struct_.get_url = navigation_entry_get_url;
struct_.struct_.get_display_url = navigation_entry_get_display_url;
struct_.struct_.get_original_url = navigation_entry_get_original_url;
struct_.struct_.get_title = navigation_entry_get_title;
struct_.struct_.get_transition_type = navigation_entry_get_transition_type;
struct_.struct_.has_post_data = navigation_entry_has_post_data;
struct_.struct_.get_frame_name = navigation_entry_get_frame_name;
struct_.struct_.get_completion_time = navigation_entry_get_completion_time;
struct_.struct_.get_http_status_code = navigation_entry_get_http_status_code;
CefNavigationEntryCppToC::CefNavigationEntryCppToC() {
GetStruct()->is_valid = navigation_entry_is_valid;
GetStruct()->get_url = navigation_entry_get_url;
GetStruct()->get_display_url = navigation_entry_get_display_url;
GetStruct()->get_original_url = navigation_entry_get_original_url;
GetStruct()->get_title = navigation_entry_get_title;
GetStruct()->get_transition_type = navigation_entry_get_transition_type;
GetStruct()->has_post_data = navigation_entry_has_post_data;
GetStruct()->get_frame_name = navigation_entry_get_frame_name;
GetStruct()->get_completion_time = navigation_entry_get_completion_time;
GetStruct()->get_http_status_code = navigation_entry_get_http_status_code;
}
template<> CefRefPtr<CefNavigationEntry> CefCppToC<CefNavigationEntryCppToC,
CefNavigationEntry, cef_navigation_entry_t>::UnwrapDerived(
CefWrapperType type, cef_navigation_entry_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -189,3 +198,6 @@ template<> base::AtomicRefCount CefCppToC<CefNavigationEntryCppToC,
CefNavigationEntry, cef_navigation_entry_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefNavigationEntryCppToC,
CefNavigationEntry, cef_navigation_entry_t>::kWrapperType =
WT_NAVIGATION_ENTRY;

3
libcef_dll/cpptoc/navigation_entry_cpptoc.h
View File

@ -28,9 +28,8 @@ class CefNavigationEntryCppToC
: public CefCppToC<CefNavigationEntryCppToC, CefNavigationEntry,
cef_navigation_entry_t> {
public:
explicit CefNavigationEntryCppToC(CefNavigationEntry* cls);
CefNavigationEntryCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_NAVIGATION_ENTRY_CPPTOC_H_

21
libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.cc
View File

@ -14,6 +14,8 @@
#include "libcef_dll/ctocpp/navigation_entry_ctocpp.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK navigation_entry_visitor_visit(
@ -41,14 +43,20 @@ int CEF_CALLBACK navigation_entry_visitor_visit(
return _retval;
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefNavigationEntryVisitorCppToC::CefNavigationEntryVisitorCppToC(
CefNavigationEntryVisitor* cls)
: CefCppToC<CefNavigationEntryVisitorCppToC, CefNavigationEntryVisitor,
cef_navigation_entry_visitor_t>(cls) {
struct_.struct_.visit = navigation_entry_visitor_visit;
CefNavigationEntryVisitorCppToC::CefNavigationEntryVisitorCppToC() {
GetStruct()->visit = navigation_entry_visitor_visit;
}
template<> CefRefPtr<CefNavigationEntryVisitor> CefCppToC<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t>::UnwrapDerived(
CefWrapperType type, cef_navigation_entry_visitor_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -57,3 +65,6 @@ template<> base::AtomicRefCount CefCppToC<CefNavigationEntryVisitorCppToC,
0;
#endif
template<> CefWrapperType CefCppToC<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t>::kWrapperType =
WT_NAVIGATION_ENTRY_VISITOR;

3
libcef_dll/cpptoc/navigation_entry_visitor_cpptoc.h
View File

@ -30,9 +30,8 @@ class CefNavigationEntryVisitorCppToC
: public CefCppToC<CefNavigationEntryVisitorCppToC,
CefNavigationEntryVisitor, cef_navigation_entry_visitor_t> {
public:
explicit CefNavigationEntryVisitorCppToC(CefNavigationEntryVisitor* cls);
CefNavigationEntryVisitorCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_NAVIGATION_ENTRY_VISITOR_CPPTOC_H_

27
libcef_dll/cpptoc/post_data_cpptoc.cc
View File

@ -28,6 +28,8 @@ CEF_EXPORT cef_post_data_t* cef_post_data_create() {
}
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK post_data_is_read_only(struct _cef_post_data_t* self) {
@ -144,17 +146,24 @@ void CEF_CALLBACK post_data_remove_elements(struct _cef_post_data_t* self) {
CefPostDataCppToC::Get(self)->RemoveElements();
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefPostDataCppToC::CefPostDataCppToC(CefPostData* cls)
: CefCppToC<CefPostDataCppToC, CefPostData, cef_post_data_t>(cls) {
struct_.struct_.is_read_only = post_data_is_read_only;
struct_.struct_.get_element_count = post_data_get_element_count;
struct_.struct_.get_elements = post_data_get_elements;
struct_.struct_.remove_element = post_data_remove_element;
struct_.struct_.add_element = post_data_add_element;
struct_.struct_.remove_elements = post_data_remove_elements;
CefPostDataCppToC::CefPostDataCppToC() {
GetStruct()->is_read_only = post_data_is_read_only;
GetStruct()->get_element_count = post_data_get_element_count;
GetStruct()->get_elements = post_data_get_elements;
GetStruct()->remove_element = post_data_remove_element;
GetStruct()->add_element = post_data_add_element;
GetStruct()->remove_elements = post_data_remove_elements;
}
template<> CefRefPtr<CefPostData> CefCppToC<CefPostDataCppToC, CefPostData,
cef_post_data_t>::UnwrapDerived(CefWrapperType type, cef_post_data_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
@ -162,3 +171,5 @@ template<> base::AtomicRefCount CefCppToC<CefPostDataCppToC, CefPostData,
cef_post_data_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefPostDataCppToC, CefPostData,
cef_post_data_t>::kWrapperType = WT_POST_DATA;

3
libcef_dll/cpptoc/post_data_cpptoc.h
View File

@ -27,9 +27,8 @@
class CefPostDataCppToC
: public CefCppToC<CefPostDataCppToC, CefPostData, cef_post_data_t> {
public:
explicit CefPostDataCppToC(CefPostData* cls);
CefPostDataCppToC();
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_POST_DATA_CPPTOC_H_

Some files were not shown because too many files have changed in this diff Show More