cef/tools/translator.README.txt

Chromium Embedded Framework (CEF) Translator Tool -- translator.py
-------------------------------------------------------------------------------

Document Last Updated: February 14, 2012


OVERVIEW
--------

The CEF translator tool automatically generates CEF source code based on the
contents of the CEF header file (cef.h). The generated source code includes the
main C API header file (cef_capi.h) and all files in the libcef_dll/cpptoc and
libcef_dll/ctocpp directories.

If any differences are detected between the new translator-generated output and
the file that currently exists on disk a backup of the existing file will be
created before the new file is written (this behavior can be controlled using
a command-line switch -- see 'translator.py -h' for more information). Header
files (*.h) are completely generated by the translator and should never be
edited by hand. Implementation files (*.cc) may contain user-created content
within method and function body blocks. The user-created content is extracted
from the existing file and inserted into the new translator-generated file. Any
differences between existing method/function prototypes and new method/function
prototypes in manually edited implementations will be noted as a warning in new
output file.

   // WARNING - CHANGED ATTRIBUTES
   //   REMOVED: const wchar_t* key
   //   ADDED:   int index
   // WARNING - CHANGED RETURN VALUE
   //   WAS: void
   //   NOW: int
   #pragma message("Warning: "__FILE__": MyFunction prototype has changed")

Auto-generated implementations will be added in the new output file for any
methods/functions that exist in the CEF header file but did not exist in the
current on-disk implementation file. Each time the translator re-generates the
implementation file it will warn if an implementation could not be auto-
generated. Delete the indicated portion of the generated code after adding the
implementation manually.

   size_t CEF_CALLBACK frame_new_func(struct _cef_frame_t* self)
   {
     // BEGIN DELETE BEFORE MODIFYING
     // AUTO-GENERATED CONTENT
     #pragma message("Warning: "__FILE__": frame_new_func is not implemented")
     // END DELETE BEFORE MODIFYING
   }

If the complete function or method implementation has been auto-generated the
body of the function or method will contain the following comment.

   // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING

If you edit the implementation manually you should remove this comment so that
CEF will not discard your changes on the next run of the translator tool.

The 'translator.[bat|sh]' file can be used to run the translator tool with
command- line arguments that match the default CEF directory structure and
output options. Run 'translator.py -h' for a complete list of available command-
line arguments.


HEADER ATTRIBUTES
-----------------

Comment-based attribute tags are added before each function, class and method
definition in the CEF header file to provide the translator with additional
information about how the output should be generated. The attribute tags must
be in the form of a comma-delimited list of name=value pairs. Attribute names
and values must contain only alpha-numeric characters, numbers and underscores,
and must all exist on a single line.

   /*--cef(name1=value1,name2=value2,name3=value3)--*/

Supported method/function attributes:

   capi_name=[string]      (Optional) Force a specific output name for the
                           resulting C API function.
   optional_param=[param]  (Optional) Parameter name that will be optional
                           instead of required.
   index_param=[param]     (Optional) Parameter name representing an index
                           value that will be verified as >= 0.
   default_retval=[string] (Required for enumeration types, Optional for other
                           types) Specify the default return value.
   count_func=[param:func] (Required for non-const non-string std::vector
                           types) Specify the C++ function that returns the
                           count of elements for a vector parameter.
   api_hash_check          (Optional) If set an API hash check will be added
                           to the CToCpp version of the method/function.
   
Supported class attributes:

   source=[library|client] (Required) Indicates whether the class
                           implementation is provided by the library or the
                           client. This effects the generation of guard
                           blocks in the cpptoc and ctocpp header files.
   no_debugct_check       (Optional) If set the debug reference count
                           of the object will not be checked on shutdown.


TRANSLATION RULES
-----------------

All C++ names in the CEF header file are written in CamelCaps format and all
C API translations are generated in lowercase_underscore format.


Translating Classes and Methods
-------------------------------

Class names and global function names must be prefixed with the 'Cef' string.

   Global function translation
      C++:   void CefShutdown()
      C API: void cef_shutdown()

The translation of a C++ class name to a C API structure name is prefixed with
'_' and postfixed with '_t'.  A typedef of the C API structure to a value
without the prefixed '_' is also provided and may be used interchangeably.

   Class name translation
      C++:   class CefPostData
      C API: typedef struct _cef_post_data_t { ... } cef_post_data_t

The translation of a C++ virtual class method to a C API member function adds a
'self' structure pointer as the first parameter. This will always be a pointer
to the structure that contains the member function.

   Virtual method translation
      C++:   virtual void SetFocus(bool enable)
      C API: void set_focus(struct _cef_browser_t* self, int enable)

The translation of a C++ static class method to a C API global function
is prefixed with 'cef_classname_' where 'classname' is the
lowercase_underscore name of the class that contains the static method.  Any
repeat of 'classname' in the function name is removed.

   Static method translation
      C++:   static CefRefPtr<CefRequest> CreateRequest()
      C API: struct _cef_request_t* cef_request_create()

Implementation of the wrapper method/function body is generally formatted as
follows.

   Static/Global CppToC (without Return):

      CEF_EXPORT void cef_function(capi_params)
      {
        // Parameter Verification (Optional)
        // Verify the C parameter values.
        // ...

        // Parameter Translation (Optional)
        // Convert C parameter values to C++ parameter values.
        // ...

        // Execution
        CefFunction(cpp_arams);
        
        // Parameter Restoration (Optional)
        // Retore the C parameter values if changed.
        // ...
      }
   
   Static/Global CppToC (with Return):

      CEF_EXPORT capi_retval cef_function(capi_params)
      {
        // Parameter Verification (Optional)
        // Verify the C parameter values.
        // ...

        // Parameter Translation (Optional)
        // Convert C parameter values to C++ parameter values.
        // ...

        // Execution
        cpp_retval _rv = CefFunction(cpp_params);
        
        // Parameter Restoration (Optional)
        // Restore the C parameter values if changed.
        // ...
        
        // Return Translation
        // Convert the C++ return value to a C return value.
        return ...;
      }
   
   Static/Global CToCpp (without Return):
   
      void CefFunction(cpp_params)
      {
        // Parameter Verification (Optional)
        // Verify the C++ parameter values.
        // ...

        // Parameter Translation (Optional)
        // Convert C++ parameter values to C parameter values.
        // ...
        
        // Execution
        cef_function(capi_params);
        
        // Parameter Restoration (Optional)
        // Restore the C++ parameter values if changed.
        // ...
      }
   
   Static/Global CToCpp (with Return):
   
      cpp_retval CefFunction(cpp_params)
      {
        // Parameter Verification (Optional)
        // Verify the C++ parameter values.
        // ...

        // Parameter Translation (Optional)
        // Convert C++ parameter values to C parameter values.
        // ...
        
        // Execution
        capi_retval _rv = cef_function(capi_params);
        
        // Parameter Restoration (Optional)
        // Restore the C++ parameter values if changed.
        // ...
        
        // Return Translation
        // Convert the C return value to a C++ return value.
        return ...;
      }
   
   Member CppToC (without Return):
   
      CEF_CALLBACK void class_function(cef_class_t* self, capi_params)
      {
        // Parameter Verification.
        // Verify the C parameter values.
        DCHECK(self);
        DCHECK(...);
        if (!self || ...)
          return;
          
        // Parameter Translation (Optional)
        // Convert the C parameter values to C++ parameter values.
        // ...

        // Execution
        CefClassCppToC::Get(self)->CefFunction(cpp_params);
        
        // Parameter Restoration (Optional)
        // Restore the C parameter values if changed.
        // ...
      }

   Member CppToC (with Return):
   
      CEF_CALLBACK capi_retval class_function(cef_class_t* self, capi_params)
      {
        // Parameter Verification.
        // Verify the C parameter values.
        DCHECK(self);
        DCHECK(...);
        if (!self || ...)
          return default_retval; // Configured or defaulted automatically.
          
        // Parameter Translation (Optional)
        // Convert the C parameter values to C++ parameter values.
        // ...

        // Execution
        cpp_retval _rv = CefClassCppToC::Get(self)->CefFunction(cpp_params);
        
        // Parameter Restoration (Optional)
        // Restore the C parameter values if changed.
        // ...
        
        // Return Translation
        // Convert the C++ return value to a C return value.
        return ...;
      }

   Member CToCpp (without Return):

      void CefClassCToCpp::Function(cpp_params)
      {
        // Structure Verification
        if (CEF_MEMBER_MISSING(struct_, function))
          return;

        // Parameter Verification (Optional)
        // Verify the C++ parameter values.
        // ...

        // Parameter Translation (Optional)
        // Convert C++ parameter values to C parameter values.
        // ...
        
        // Execution
        struct_->class_function(struct_, capi_params);
        
        // Parameter Restoration (Optional)
        // Restore the C++ parameter values if changed.
        // ...
      }

   Member CToCpp (with Return):

      cpp_retval CefClassCToCpp::Function(cpp_params)
      {
        // Structure Verification
        if (CEF_MEMBER_MISSING(struct_, function))
          return default_retval; // Configured or defaulted automatically.

        // Parameter Verification (Optional)
        // Verify the C++ parameter values.
        // ...

        // Parameter Translation (Optional)
        // Convert C++ parameter values to C parameter values.
        // ...
        
        // Execution
        capi_retval _rv = struct_->class_function(struct_, capi_params);
        
        // Parameter Restoration (Optional)
        // Restore the C++ parameter values if changed.
        // ...
        
        // Return Translation
        // Convert the C return value to a C++ return value.
        return ...;
      }
   

Translating Data Types
----------------------

Data types that are available in both C++ and C are left unchanged. This
includes the 'double', 'int', 'long', 'size_t' and 'void' basic types. Other
data types have differing levels of support as indicated below. The translation
tool will terminate with an exception if it encounters a data type that it
cannot translate.

Parameters:

   Simple/enumeration type by value (simple_byval):
      C++:   int value
      C API: int value

      // CppToC Example
      CEF_EXPORT void cef_function(int value)
      {
        // Execution
        CefFunction(value);
      }

      // CToCpp Example
      void CefFunction(int value)
      {
        // Execution
        cef_function(value);
      }

   Simple/enumeration type by reference (simple_byref):
      C++:   int& value
      C API: int* value

      // CppToC Example
      CEF_EXPORT void cef_function(int* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Parameter Translation
        int valueVal = value?*value:0;
          
        // Execution
        CefFunction(valueVal);
        
        // Parameter Restoration
        if (value)
          *value = valueVal;
      }

      // CToCpp Example
      void CefFunction(int& value)
      {
        // Execution
        cef_function(&value);
      }

   Simple/enumeration const type by reference (simple_byref_const):
      C++:   const int& value
      C API: const int* value

      // CppToC Example
      CEF_EXPORT void cef_function(const int* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Parameter Translation
        int valueVal = value?*value:0;
          
        // Execution
        CefFunction(valueVal);
      }

      // CToCpp Example
      void CefFunction(const int& value)
      {
        // Execution
        cef_function(&value);
      }

   Simple/enumeration type by address (simple_byaddr):
      C++:   int* value
      C API: int* value

      // CppToC Example
      CEF_EXPORT void cef_function(int* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Execution
        CefFunction(value);
      }

      // CToCpp Example
      void CefFunction(int* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Execution
        cef_function(value);
      }

   Boolean type by value (bool_byval):
      C++:   bool value
      C API: int value

      // CppToC Example
      CEF_EXPORT void cef_function(int value)
      {
        // Execution
        CefFunction(value?true:false);
      }

      // CToCpp Example
      void CefFunction(bool value)
      {
        // Execution
        cef_function(value);
      }

   Boolean type by reference (bool_byref):
      C++:   bool& value
      C API: int* value

      // CppToC Example
      CEF_EXPORT void cef_function(int* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Parameter Translation
        bool valueBool = (value && *value)?true:false;
          
        // Execution
        CefFunction(valueBool);
        
        // Parameter Restoration
        if (value)
          *value = valueBool?true:false;
      }

      // CToCpp Example
      void CefFunction(bool& value)
      {
        // Parameter Translation
        int valueInt = value;

        // Execution
        cef_function(&valueInt);
        
        // Parameter Restoration
        value = valueInt?true:false;
      }

   Boolean type by address (bool_byaddr):
      C++:   bool* value
      C API: int* value

      // CppToC Example
      CEF_EXPORT void cef_function(int* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Parameter Translation
        bool valueBool = (value && *value)?true:false;
          
        // Execution
        CefFunction(&valueBool);
        
        // Parameter Restoration
        if (value)
          *value = valueBool?true:false;
      }

      // CToCpp Example
      void CefFunction(bool* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Parameter Translation
        int valueInt = value?*value:0;

        // Execution
        cef_function(&valueInt);
        
        // Parameter Restoration
        if (value)
          *value = valueInt?true:false;
      }

   Structure const type by reference (struct_byref_const):
      C++:   const CefPopupFeatures& value
      C API: const cef_popup_features_t* value

      // CppToC Example
      CEF_EXPORT void cef_function(const cef_popup_features_t* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;
          
        // Parameter Translation
        CefPopupFeatures valueObj;
        // Reference the existing values instead of copying.
        if (value)
          valueObj.Set(*value, false);
          
        // Execution
        CefFunction(valueObj);
      }

      // CToCpp Example
      void CefFunction(const CefPopupFeatures& value)
      {
        // Execution
        cef_function(&value);
      }

   Structure non-const type by reference (struct_byref):
      C++:   CefWindowInfo& value
      C API: cef_window_info_t* value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_window_info_t* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        CefWindowInfo valueObj;
        // Take ownership of the values.
        if (value)
          valueObj.AttachTo(*value);

        // Execution
        CefFunction(valueObj);

        // Parameter Restoration
        // Return the values to the structure.
        if (value)
          valueObj.DetachTo(*value);
      }

      // CToCpp Example
      void CefFunction(CefWindowInfo& value)
      {
        // Execution
        cef_function(&value);
      }
      
   String const type by reference (string_byref_const):
      C++:   const CefString& value
      C API: const cef_string_t* value

      // CppToC Example
      CEF_EXPORT void cef_function(const cef_string_t* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Execution
        CefFunction(CefString(value));
      }

      // CToCpp Example
      void CefFunction(const CefString& value)
      {
        // Execution
        cef_function(value.GetStruct());
      }

   String non-const type by reference (string_byref):
      C++:   CefString& value
      C API: cef_string_t* value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_t* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        CefString valueStr(value);

        // Execution
        CefFunction(valueStr);
      }

      // CToCpp Example
      void CefFunction(CefString& value)
      {
        // Execution
        cef_function(value.GetWritableStruct());
      }

   Smart pointer type same boundary side (refptr_same):
      C++:   CefRefPtr<CefBrowser> value
      C API: cef_browser_t* value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_browser_t* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Execution
        CefFunction(CefBrowserCppToC::Unwrap(value));
      }

      // CToCpp Example
      void CefFunction(CefRefPtr<CefBrowser> value)
      {
        // Execution
        cef_function(CefBrowserCToCpp::Unwrap(value));
      }

   Smart pointer type same boundary side by reference (refptr_same_byref):
      C++:   CefRefPtr<CefClient>& value
      C API: cef_client_t** value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_client_t** value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        CefRefPtr<CefClient> valuePtr;
        if (value && *value)
          valuePtr = CefClientCppToC::Unwrap(*value);
        CefClient* valueOrig = valuePtr.get();

        // Execution
        CefFunction(valuePtr);

        // Parameter Restoration
        if (value) {
          if (valuePtr.get()) {
            if (valuePtr.get() != valueOrig) {
              // The value has been changed.
              *value = CefClientCppToC::Wrap(valuePtr);
            }
          } else {
            *value = NULL;
          }
        }
      }

      // CToCpp Example
      void CefFunction(CefRefPtr<CefClient>& value)
      {
        // Parameter Translation
        cef_client_t* valueStruct = NULL;
        if(value.get())
          valueStruct = CefClientCToCpp::Unwrap(value);
        cef_client_t* valueOrig = valueStruct;

        // Execution
        cef_function(valueStuct);
        
        // Parameter Restoration
        if (valueStruct) {
          if (valueStruct != valueOrig) {
            // The value was changed.
            value = CefClientCToCpp::Wrap(valueStruct);
          }
        } else {
          value = NULL;
        }
      }

   Smart pointer type different boundary side (refptr_diff):
      C++:   CefRefPtr<CefBrowser> value
      C API: cef_browser_t* value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_browser_t* value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Execution
        CefFunction(CefBrowserCToCpp::Wrap(value));
      }

      // CToCpp Example
      void CefFunction(CefRefPtr<CefBrowser> value)
      {
        // Execution
        cef_function(CefBrowserCppToC::Wrap(value));
      }

   Smart pointer type different boundary side by reference (refptr_diff_byref):
      C++:   CefRefPtr<CefClient>& value
      C API: cef_client_t** value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_client_t** value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        CefRefPtr<CefClient> valuePtr;
        if (value && *value)
          valuePtr = CefClientCToCpp::Wrap(*value);
        CefClient* valueOrig = valuePtr.get();

        // Execution
        CefFunction(valuePtr);

        // Parameter Restoration
        if (value) {
          if (valuePtr.get()) {
            if (valuePtr.get() != valueOrig) {
              // The value has been changed.
              *value = CefClientCToCpp::Unwrap(valuePtr);
            }
          } else {
            *value = NULL;
          }
        }
      }

      // CToCpp Example
      void CefFunction(CefRefPtr<CefClient>& value)
      {
        // Parameter Translation
        cef_client_t* valueStruct = NULL;
        if(value.get())
          valueStruct = CefClientCppToC::Wrap(value);
        cef_client_t* valueOrig = valueStruct;

        // Execution
        cef_function(valueStuct);
        
        // Parameter Restoration
        if (valueStruct) {
          if (valueStruct != valueOrig) {
            // The value was changed.
            value = CefClientCppToC::Unwrap(valueStruct);
          }
        } else {
          value = NULL;
        }
      }

   String vector type by reference (string_vec_byref):
      C++:   std::vector<CefString>& value
      C API: cef_string_list_t value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_list_t value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        std::vector<CefString> valueList;
        transfer_string_list_contents(value, valueList);

        // Execution
        CefFunction(valueList);
        
        // Parameter Restoration
        cef_string_list_clear(value);
        transfer_string_list_contents(valueList, value);
      }

      // CToCpp Example
      void CefFunction(std::vector<CefString>& value)
      {
        // Parameter Translation
        cef_string_list_t valueList = cef_string_list_alloc();
        DCHECK(valueList);
        if (valueList)
          transfer_string_list_contents(value, valueList);

        // Execution
        cef_function(valueList);
        
        // Parameter Restoration
        if (valueList) {
          value.clear();
          transfer_string_list_contents(valueList, value);
          cef_string_list_free(valueList);
        }
      }

   String vector const type by reference (string_vec_byref_const):
      C++:   const std::vector<CefString>& value
      C API: cef_string_list_t value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_list_t value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        std::vector<CefString> valueList;
        transfer_string_list_contents(value, valueList);

        // Execution
        CefFunction(valueList);
      }

      // CToCpp Example
      void CefFunction(const std::vector<CefString>& value)
      {
        // Parameter Translation
        cef_string_list_t valueList = cef_string_list_alloc();
        DCHECK(valueList);
        if (valueList)
          transfer_string_list_contents(value, valueList);

        // Execution
        cef_function(valueList);
        
        // Parameter Restoration
        if (valueList)
          cef_string_list_free(valueList);
      }

   String-to-string single map type by reference (string_map_single_byref):
      C++:   std::map<CefString,CefString>& value
      C API: cef_string_map_t value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_map_t value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        std::map<CefString,CefString> valueMap;
        transfer_string_map_contents(value, valueMap);

        // Execution
        CefFunction(valueMap);
        
        // Parameter Restoration
        cef_string_map_clear(value);
        transfer_string_map_contents(valueMap, value);
      }

      // CToCpp Example
      void CefFunction(std::map<CefString,CefString>& value)
      {
        // Parameter Translation
        cef_string_map_t valueMap = cef_string_map_alloc();
        DCHECK(valueMap);
        if (valueMap)
          transfer_string_map_contents(value, valueMap);

        // Execution
        cef_function(valueMap);
        
        // Parameter Restoration
        if (valueMap) {
          value.clear();
          transfer_string_map_contents(valueMap, value);
          cef_string_map_free(valueMap);
        }
      }

   String-to-string single map const type by reference
     (string_map_single_byref_const):
      C++:   const std::map<CefString,CefString>& value
      C API: cef_string_map_t value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_map_t value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        std::map<CefString,CefString> valueMap;
        transfer_string_map_contents(value, valueMap);

        // Execution
        CefFunction(valueMap);
      }

      // CToCpp Example
      void CefFunction(const std::map<CefString,CefString>& value)
      {
        // Parameter Translation
        cef_string_map_t valueMap = cef_string_map_alloc();
        DCHECK(valueMap);
        if (valueMap)
          transfer_string_map_contents(value, valueMap);

        // Execution
        cef_function(valueMap);
        
        // Parameter Restoration
        if (valueMap)
          cef_string_map_free(valueMap);
      }

   String-to-string multi map type by reference (string_map_multi_byref):
      C++:   std::multimap<CefString,CefString>& value
      C API: cef_string_multimap_t value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_multimap_t value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        std::multimap<CefString,CefString> valueMultimap;
        transfer_string_multimap_contents(value, valueMultimap);

        // Execution
        CefFunction(valueMultimap);
        
        // Parameter Restoration
        cef_string_multimap_clear(value);
        transfer_string_multimap_contents(valueMultimap, value);
      }

      // CToCpp Example
      void CefFunction(std::multimap<CefString,CefString>& value)
      {
        // Parameter Translation
        cef_string_multimap_t valueMultimap = cef_string_multimap_alloc();
        DCHECK(valueMultimap);
        if (valueMultimap)
          transfer_string_multimap_contents(value, valueMultimap);

        // Execution
        cef_function(valueMultimap);
        
        // Parameter Restoration
        if (valueMultimap) {
          value.clear();
          transfer_string_multimap_contents(valueMultimap, value);
          cef_string_multimap_free(valueMultimap);
        }
      }
   
   String-to-string multi map const type by reference
   (string_map_multi_byref_const):
      C++:   const std::multimap<CefString,CefString>& value
      C API: cef_string_multimap_t value

      // CppToC Example
      CEF_EXPORT void cef_function(cef_string_multimap_t value)
      {
        // Parameter Verification
        DHECK(value);
        if (!value)
          return;

        // Parameter Translation
        std::multimap<CefString,CefString> valueMultimap;
        transfer_string_multimap_contents(value, valueMultimap);

        // Execution
        CefFunction(valueMultimap);
      }

      // CToCpp Example
      void CefFunction(const std::multimap<CefString,CefString>& value)
      {
        // Parameter Translation
        cef_string_multimap_t valueMultimap = cef_string_multimap_alloc();
        DCHECK(valueMultimap);
        if (valueMultimap)
          transfer_string_multimap_contents(value, valueMultimap);

        // Execution
        cef_function(valueMultimap);
        
        // Parameter Restoration
        if (valueMultimap)
          cef_string_multimap_free(valueMultimap);
      }
   
   Simple/Enumeration vector non-const type by reference (simple_vec_byref):
      C++:   std::vector<int>& value
      C API: size_t* valueCount, int* value

      // CppToC Example
      CEF_EXPORT void cef_function(size_t* valueCount, int* value)
      {
        // Parameter Verification
        DCHECK(valueCount && (*valueCount == 0 || value));
        if (!valueCount || (*valueCount > 0 && !value))
          return;
        
        // Parameter Translation
        std::vector<int> valueList;
        if (valueCount && *valueCount > 0 && value) {
          for (size_t i = 0; i < *valueCount; ++i)
            valueList.push_back(value[i]);
        }
        
        // Execution
        CefFunction(valueList);
        
        // Parameter Restoration
        if (valueCount && value) {
          *valueCount = std::min(valueList.size(), *valueCount);
          if (*valueCount > 0) {
            for (size_t i = 0; i < *valueCount; ++i)
              value[i] = valueList[i];
          }
        }
      }

      // CToCpp Example
      void CefFunction(std::vector<int>& value)
      {
        // Parameter Translation
        // Function identified by the "count_func" method attribute.
        size_t valueSize = value.size();
        size_t valueCount = std::max(GetFunctionCount(), valueSize);
        int* valueList = NULL;
        if (valueCount > 0) {
          valueList = new int[valueCount];
          DCHECK(valueList);
          if (valueList)
            memset(valueList, 0, sizeof(int)*valueCount);
          if (valueList && valueSize > 0) {
            for (size_t i = 0; i < valueSize; ++i) {
              valueList[i] = value[i];
            }
          }
        }

        // Execution
        cef_function(&valueCount, valueList);
        
        // Parameter Restoration
        value.clear();
        if (valueCount > 0 && valueList) {
          for (size_t i = 0; i < valueCount; ++i)
            value.push_back(valueList[i]);
          delete [] valueList;
        }
      }

   Simple/Enumeration vector const type by reference (simple_vec_byref_const):
      C++:   const std::vector<int>& value
      C API: size_t valueCount, int const* value

      // CppToC Example
      CEF_EXPORT void cef_function(size_t valueCount, int const* value)
      {
        // Parameter Verification
        DCHECK(valueCount == 0 || value);
        if (valueCount > 0 && !value)
          return;
        
        // Parameter Translation
        std::vector<int> valueList;
        if (valueCount > 0) {
          for (size_t i = 0; i < valueCount; ++i)
            valueList.push_back(value[i]);
        }

        // Execution
        CefFunction(valueList);
      }

      // CToCpp Example
      void CefFunction(const std::vector<int>& value)
      {
        // Parameter Translation
        const size_t valueCount = value.size();
        int* valueList = NULL;
        if (valueCount > 0) {
          valueList = new int[valueCount];
          DCHECK(valueList);
          if (valueList) {
            for (size_t i = 0; i < valueCount; ++i)
              valueList[i] = value[i];
          }
        }
        
        // Execution
        cef_function(valueCount, valueList);

        // Parameter Restoration
        if (valueList)
          delete [] valueList;
      }

   Boolean vector non-const type by reference (bool_vec_byref):
      C++:   std::vector<bool>& value
      C API: size_t* valueCount, int* value
      
      // CppToC Example
      CEF_EXPORT void cef_function(size_t* valueCount, int* value)
      {
        // Parameter Verification
        DCHECK(valueCount && (*valueCount == 0 || value));
        if (!valueCount || (*valueCount > 0 && !value))
          return;
        
        // Parameter Translation
        std::vector<bool> valueList;
        if (valueCount && *valueCount > 0 && value) {
          for (size_t i = 0; i < *valueCount; ++i)
            valueList.push_back(value[i]?true:false);
        }
        
        // Execution
        CefFunction(valueList);
        
        // Parameter Restoration
        if (valueCount && value) {
          *valueCount = std::min(valueList.size(), *valueCount);
          if (*valueCount > 0) {
            for (size_t i = 0; i < *valueCount; ++i)
              value[i] = valueList[i];
          }
        }
      }

      // CToCpp Example
      void CefFunction(std::vector<bool>& value)
      {
        // Parameter Translation
        // Function identified by the "count_func" method attribute.
        size_t valueSize = value.size();
        size_t valueCount = std::max(GetFunctionCount(), valueSize);
        int* valueList = NULL;
        if (valueCount > 0) {
          valueList = new int[valueCount];
          DCHECK(valueList);
          if (valueList)
            memset(valueList, 0, sizeof(int)*valueCount);
          if (valueList && valueSize > 0) {
            for (size_t i = 0; i < valueSize; ++i) {
              valueList[i] = value[i];
            }
          }
        }

        // Execution
        cef_function(&valueCount, valueList);
        
        // Parameter Restoration
        value.clear();
        if (valueCount > 0 && valueList) {
          for (size_t i = 0; i < valueCount; ++i)
            value.push_back(valueList[i]?true:false);
          delete [] valueList;
        }
      }

   Boolean vector const type by reference (bool_vec_byref_const):
      C++:   const std::vector<bool>& value
      C API: size_t valueCount, int const* value
      
      // CppToC Example
      CEF_EXPORT void cef_function(size_t valueCount, int const* value)
      {
        // Parameter Verification
        DCHECK(valueCount == 0 || value);
        if (valueCount > 0 && !value)
          return;
        
        // Parameter Translation
        std::vector<bool> valueList;
        if (valueCount > 0) {
          for (size_t i = 0; i < valueCount; ++i)
            valueList.push_back(value[i]?true:false);
        }

        // Execution
        CefFunction(valueList);
      }

      // CToCpp Example
      void CefFunction(const std::vector<bool>& value)
      {
        // Parameter Translation
        const size_t valueCount = value.size();
        int* valueList = NULL;
        if (valueCount > 0) {
          valueList = new int[valueCount];
          DCHECK(valueList)
          if (valueList) {
            for (size_t i = 0; i < valueCount; ++i)
              valueList[i] = value[i];
          }
        }
        
        // Execution
        cef_function(valueCount, valueList);

        // Parameter Restoration
        if (valueList)
          delete [] valueList;
      }

   Smart pointer vector non-const type same boundary side by reference
      (refptr_vec_same_byref):
      C++:   std::vector<CefRefPtr<CefPostDataElement>>& value
      C API: size_t* valueCount, cef_post_data_element_t** value
      
      // CppToC Example
      CEF_EXPORT void cef_function(size_t* valueCount,
                                   cef_post_data_element_t** value)
      {
        // Parameter Verification
        DCHECK(valueCount && (*valueCount == 0 || value));
        if (!valueCount || (*valueCount > 0 && !value))
          return;
        
        // Parameter Translation
        std::vector<CefRefPtr<CefPostDataElement>> valueList;
        if (valueCount && *valueCount > 0 && value) {
          for (size_t i = 0; i < *valueCount; ++i)
            valueList.push_back(CefPostDataElementCppToC::Unwrap(value[i]));
        }
        
        // Execution
        CefFunction(valueList);
        
        // Parameter Restoration
        if (valueCount && value) {
          *valueCount = std::min(valueList.size(), *valueCount);
          if (*valueCount > 0) {
            for (size_t i = 0; i < *valueCount; ++i)
              value[i] = CefPostDataElementCppToC::Wrap(valueList[i]);
          }
        }
      }

      // CToCpp Example
      void CefFunction(std::vector<bool>& value)
      {
        // Parameter Translation
        // Function identified by the "count_func" method attribute.
        size_t valueSize = value.size();
        size_t valueCount = std::max(GetFunctionCount(), valueSize);
        cef_post_data_element_t** valueList = NULL;
        if (valueCount > 0) {
          valueList = new cef_post_data_element_t*[valueCount];
          DCHECK(valueList);
          if (valueList)
            memset(valueList, 0, sizeof(cef_post_data_element_t*)*valueCount);
          if (valueList && valueSize > 0) {
            for (size_t i = 0; i < valueSize; ++i) {
              valueList[i] = CefPostDataElementCToCpp::Unwrap(value[i]);
            }
          }
        }

        // Execution
        cef_function(&valueCount, valueList);
        
        // Parameter Restoration
        value.clear();
        if (valueCount > 0 && valueList) {
          for (size_t i = 0; i < valueCount; ++i)
            value.push_back(CefPostDataElementCToCpp::Wrap(valueList[i]));
          delete [] valueList;
        }
      }

   Smart pointer vector const type same boundary side by reference
      (refptr_vec_same_byref_const):
      C++:   const std::vector<CefRefPtr<CefV8Value>>& value
      C API: size_t valueCount, const cef_v8value_t** value
      
      // CppToC Example
      CEF_EXPORT void cef_function(size_t valueCount,
                                   const cef_v8value_t** value)
      {
        // Parameter Verification
        DCHECK(valueCount == 0 || value);
        if (valueCount > 0 && !value)
          return;
        
        // Parameter Translation
        std::vector<CefRefPtr<CefV8Value>> valueList;
        if (valueCount > 0) {
          for (size_t i = 0; i < valueCount; ++i)
            valueList.push_back(CefV8ValueCppToC::Unwrap(value[i]));
        }

        // Execution
        CefFunction(valueList);
      }

      // CToCpp Example
      void CefFunction(const std::vector<bool>& value)
      {
        // Parameter Translation
        const size_t valueCount = value.size();
        cef_v8value_t** valueList = NULL;
        if (valueCount > 0) {
          valueList = new int[valueCount];
          DCHECK(valueList);
          if (valueList) {
            for (size_t i = 0; i < valueCount; ++i)
              valueList[i] = CefV8ValueCToCpp::Unwrap(value[i]);
          }
        }
        
        // Execution
        cef_function(valueCount, valueList);

        // Parameter Restoration
        if (valueList)
          delete [] valueList;
      }

   Smart pointer vector non-const type different boundary side by reference
      (refptr_vec_diff_byref):
      C++:   std::vector<CefRefPtr<CefPostDataElement>>& value
      C API: size_t* valueCount, cef_post_data_element_t** value
      
      // CppToC Example
      CEF_EXPORT void cef_function(size_t* valueCount,
                                   cef_post_data_element_t** value)
      {
        // Parameter Verification
        DCHECK(valueCount && (*valueCount == 0 || value));
        if (!valueCount || (*valueCount > 0 && !value))
          return;
        
        // Parameter Translation
        std::vector<CefRefPtr<CefPostDataElement>> valueList;
        if (valueCount && *valueCount > 0 && value) {
          for (size_t i = 0; i < *valueCount; ++i)
            valueList.push_back(CefPostDataElementCToCpp::Wrap(value[i]));
        }
        
        // Execution
        CefFunction(valueList);
        
        // Parameter Restoration
        if (valueCount && value) {
          *valueCount = std::min(valueList.size(), *valueCount);
          if (*valueCount > 0) {
            for (size_t i = 0; i < *valueCount; ++i)
              value[i] = CefPostDataElementCToCpp::Unwrap(valueList[i]);
          }
        }
      }

      // CToCpp Example
      void CefFunction(std::vector<bool>& value)
      {
        // Parameter Translation
        // Function identified by the "count_func" method attribute.
        size_t valueSize = value.size();
        size_t valueCount = std::max(GetFunctionCount(), valueSize);
        cef_post_data_element_t** valueList = NULL;
        if (valueCount > 0) {
          valueList = new cef_post_data_element_t*[valueCount];
          DCHECK(valueList);
          if (valueList)
            memset(valueList, 0, sizeof(cef_post_data_element_t*)*valueCount);
          if (valueList && valueSize > 0) {
            for (size_t i = 0; i < valueSize; ++i) {
              valueList[i] = CefPostDataElementCppToC::Wrap(value[i]);
            }
          }
        }

        // Execution
        cef_function(&valueCount, valueList);
        
        // Parameter Restoration
        value.clear();
        if (valueCount > 0 && valueList) {
          for (size_t i = 0; i < valueCount; ++i)
            value.push_back(CefPostDataElementCppToC::Unwrap(valueList[i]));
          delete [] valueList;
        }
      }

   Smart pointer vector const type different boundary side by reference
      (refptr_vec_diff_byref_const):
      C++:   const std::vector<CefRefPtr<CefV8Value>>& value
      C API: size_t valueCount, const cef_v8value_t** value
      
      // CppToC Example
      CEF_EXPORT void cef_function(size_t valueCount,
                                   const cef_v8value_t** value)
      {
        // Parameter Verification
        DCHECK(valueCount == 0 || value);
        if (valueCount > 0 && !value)
          return;
        
        // Parameter Translation
        std::vector<CefRefPtr<CefV8Value>> valueList;
        if (valueCount > 0) {
          for (size_t i = 0; i < valueCount; ++i)
            valueList.push_back(CefV8ValueCToCpp::Wrap(value[i]));
        }

        // Execution
        CefFunction(valueList);
      }

      // CToCpp Example
      void CefFunction(const std::vector<bool>& value)
      {
        // Parameter Translation
        const size_t valueCount = value.size();
        cef_v8value_t** valueList = NULL;
        if (valueCount > 0) {
          valueList = new int[valueCount];
          DCHECK(valueList);
          if (valueList) {
            for (size_t i = 0; i < valueCount; ++i)
              valueList[i] = CefV8ValueCppToC::Wrap(value[i]);
          }
        }
        
        // Execution
        cef_function(valueCount, valueList);

        // Parameter Restoration
        if (valueList)
          delete [] valueList;
      }

Return Values:

   Simple/Enumeration type (simple):
      C++:   int
      C API: int

      // CppToC Example
      CEF_EXPORT int cef_function()
      {
        // Execution
        int _rv = CefFunction();
        
        // Return Translation
        return _rv;
      }

      // CToCpp Example
      int CefFunction()
      {
        // Execution
        int _rv = cef_function();
        
        // Return Translation
        return _rv;
      }

   Boolean type (bool):
      C++:   bool
      C API: int

      // CppToC Example
      CEF_EXPORT int cef_function()
      {
        // Execution
        bool _rv = CefFunction();
        
        // Return Translation
        return _rv;
      }

      // CToCpp Example
      bool CefFunction()
      {
        // Execution
        int _rv = cef_function();
        
        // Return Translation
        return _rv?true:false;
      }

   String non-const by reference type (string):
      C++:   CefString
      C API: cef_string_userfree_t

      // CppToC Example
      CEF_EXPORT cef_string_userfree_t cef_function()
      {
        // Execution
        CefString _rv = CefFunction();
        
        // Return Translation
        return _rv.DetachToUserFree();
      }

      // CToCpp Example
      CefString CefFunction()
      {
        // Execution
        cef_string_userfree_t _rv = cef_function();
        
        // Return Translation
        CefString _rvStr;
        _rvStr.AttachToUserFree(_rv);
        return _rvStr;
      }

   Smart pointer type same boundary side (refptr_same):
      C++:   CefRefPtr<CefBrowser>
      C API: cef_browser_t*

      // CppToC Example
      CEF_EXPORT cef_browser_t* cef_function()
      {
        // Execution
        CefRefPtr<CefBrowser> _rv = CefFunction();
        
        // Return Translation
        return CefBrowserCppToC::Wrap(_rv);
      }

      // CToCpp Example
      CefString CefFunction()
      {
        // Execution
        cef_browser_t* _rv = cef_function();
        
        // Return Translation
        return CefBrowserCToCpp::Wrap(_rv);
      }

   Smart pointer type different boundary side (refptr_diff):
      C++:   CefRefPtr<CefBrowser>
      C API: cef_browser_t*

      // CppToC Example
      CEF_EXPORT cef_browser_t* cef_function()
      {
        // Execution
        CefRefPtr<CefBrowser> _rv = CefFunction();
        
        // Return Translation
        return CefBrowserCToCpp::Unwrap(_rv);
      }

      // CToCpp Example
      CefString CefFunction()
      {
        // Execution
        cef_browser_t* _rv = cef_function();
        
        // Return Translation
        return CefBrowserCppToC::Unwrap(_rv);
      }


Translating Comments
--------------------

Comments from the CEF header file are reproduced in the C API header file with
any referenced C++ types and terminology changed to reflect C API types and
terminology.

C++:
// Create a new CefV8Value object of the specified type.  These methods
// should only be called from within the JavaScript context -- either in a
// CefV8Handler::Execute() callback or a CefHandler::HandleJSBinding()
// callback.

C API:
// Create a new cef_v8value_t object of the specified type.  These functions
// should only be called from within the JavaScript context -- either in a
// cef_v8handler_t::execute() callback or a cef_handler_t::handle_jsbinding()
// callback.

Situations where the user is responsible for freeing strings allocated and
returned by the library are also noted by comments in the C API header file.

C API:
   // The resulting string must be freed by calling cef_string_free().

A comment must occur immediately before the function, class or method that it
documents with no extra space in between.  Comments may span multiple lines
but each line must start with the '//' comment identifier.

C++:
   // Set focus for the browser window.  If |enable| is true focus will be set
   // to the window.  Otherwise, focus will be removed.
   /*--cef()--*/
   virtual void SetFocus(bool enable) =0;

If two comments are separated by an empty line it will be assumed that the
higher comment represents a section header and additional space will be added
before it in the translated output.

C++:
   // ARRAY METHODS - These methods are only available on arrays.
   
   // Returns the number of elements in the array.
   /*--cef()--*/
   virtual int GetArrayLength() =0;

Empty lines and lines with the comment identifier but no content are considered
paragraph breaks for the purposes of wrapping the translated text. Any content
indented more than one space is reproduced as-is without content translation
or wrapping.

C++:
// Register a new V8 extension with the specified JavaScript extension code and
// handler. Functions implemented by the handler are prototyped using the
// keyword 'native'. The calling of a native function is restricted to the scope
// in which the prototype of the native function is defined.
//
// Example JavaScript extension code:
//
//   // create the 'example' global object if it doesn't already exist.
//   if (!example)
//     example = {};