bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Introduce CefString and cef_string_t implementations that support string type conversions and customization of the API string type (issue #146).

Browse Source 
git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@145 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2010-11-22 17:49:46 +00:00
parent 1e1c2ad8d7
commit 7d60642638
121 changed files with 2598 additions and 3209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
libcef_dll/cpptoc/browser_cpptoc.cc
View File

@ -13,43 +13,40 @@
#include "libcef_dll/cpptoc/browser_cpptoc.h"
#include "libcef_dll/cpptoc/frame_cpptoc.h"
#include "libcef_dll/ctocpp/handler_ctocpp.h"
#include "libcef_dll/transfer_util.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT int cef_browser_create(cef_window_info_t* windowInfo, int popup,
struct _cef_handler_t* handler, const wchar_t* url)
struct _cef_handler_t* handler, const cef_string_t* url)
{
DCHECK(windowInfo);
CefRefPtr<CefHandler> handlerPtr;
std::wstring urlStr;
CefWindowInfo wi = *windowInfo;
if(handler)
handlerPtr = CefHandlerCToCpp::Wrap(handler);
if(url)
urlStr = url;
return CefBrowser::CreateBrowser(wi, popup?true:false, handlerPtr, urlStr);
return CefBrowser::CreateBrowser(wi, popup?true:false, handlerPtr,
CefString(url));
}
CEF_EXPORT cef_browser_t* cef_browser_create_sync(cef_window_info_t* windowInfo,
int popup, struct _cef_handler_t* handler, const wchar_t* url)
int popup, struct _cef_handler_t* handler, const cef_string_t* url)
{
DCHECK(windowInfo);
CefRefPtr<CefHandler> handlerPtr;
std::wstring urlStr;
CefWindowInfo wi = *windowInfo;
if(handler)
handlerPtr = CefHandlerCToCpp::Wrap(handler);
if(url)
urlStr = url;
CefRefPtr<CefBrowser> browserPtr(
CefBrowser::CreateBrowserSync(wi, popup?true:false, handlerPtr, urlStr));
CefBrowser::CreateBrowserSync(wi, popup?true:false, handlerPtr,
CefString(url)));
if(browserPtr.get())
return CefBrowserCppToC::Wrap(browserPtr);
return NULL;
@ -193,20 +190,14 @@ struct _cef_frame_t* CEF_CALLBACK browser_get_focused_frame(
}
struct _cef_frame_t* CEF_CALLBACK browser_get_frame(struct _cef_browser_t* self,
const wchar_t* name)
const cef_string_t* name)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring nameStr;
if(name)
nameStr = name;
if(nameStr.empty())
return NULL;
CefRefPtr<CefBrowser> browserPtr = CefBrowserCppToC::Get(self);
CefRefPtr<CefFrame> framePtr = browserPtr->GetFrame(nameStr);
CefRefPtr<CefFrame> framePtr = browserPtr->GetFrame(CefString(name));
if(framePtr.get())
return CefFrameCppToC::Wrap(framePtr);
return NULL;
@ -221,25 +212,19 @@ void CEF_CALLBACK browser_get_frame_names(struct _cef_browser_t* self,
return;
CefRefPtr<CefBrowser> browserPtr = CefBrowserCppToC::Get(self);
std::vector<std::wstring> stringList;
std::vector<CefString> stringList;
browserPtr->GetFrameNames(stringList);
size_t size = stringList.size();
for(size_t i = 0; i < size; ++i)
cef_string_list_append(names, stringList[i].c_str());
transfer_string_list_contents(stringList, names);
}
void CEF_CALLBACK browser_find(struct _cef_browser_t* self, int identifier,
const wchar_t* searchText, int forward, int matchCase, int findNext)
const cef_string_t* searchText, int forward, int matchCase, int findNext)
{
DCHECK(self);
if(!self)
return;
std::wstring searchTextStr;
if(searchText)
searchTextStr = searchText;
CefBrowserCppToC::Get(self)->Find(identifier, searchTextStr,
CefBrowserCppToC::Get(self)->Find(identifier, CefString(searchText),
forward?true:false, matchCase?true:false, findNext?true:false);
}

71
libcef_dll/cpptoc/frame_cpptoc.cc
View File

@ -98,28 +98,24 @@ void CEF_CALLBACK frame_view_source(struct _cef_frame_t* self)
CefFrameCppToC::Get(self)->ViewSource();
}
cef_string_t CEF_CALLBACK frame_get_source(struct _cef_frame_t* self)
cef_string_userfree_t CEF_CALLBACK frame_get_source(struct _cef_frame_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring sourceStr = CefFrameCppToC::Get(self)->GetSource();
if(!sourceStr.empty())
return cef_string_alloc(sourceStr.c_str());
return NULL;
CefString sourceStr = CefFrameCppToC::Get(self)->GetSource();
return sourceStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK frame_get_text(struct _cef_frame_t* self)
cef_string_userfree_t CEF_CALLBACK frame_get_text(struct _cef_frame_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring textStr = CefFrameCppToC::Get(self)->GetText();
if(!textStr.empty())
return cef_string_alloc(textStr.c_str());
return NULL;
CefString textStr = CefFrameCppToC::Get(self)->GetText();
return textStr.DetachToUserFree();
}
void CEF_CALLBACK frame_load_request(struct _cef_frame_t* self,
@ -134,64 +130,47 @@ void CEF_CALLBACK frame_load_request(struct _cef_frame_t* self,
CefFrameCppToC::Get(self)->LoadRequest(requestPtr);
}
void CEF_CALLBACK frame_load_url(struct _cef_frame_t* self, const wchar_t* url)
void CEF_CALLBACK frame_load_url(struct _cef_frame_t* self,
const cef_string_t* url)
{
DCHECK(self);
if(!self)
return;
std::wstring urlStr;
if(url)
urlStr = url;
CefFrameCppToC::Get(self)->LoadURL(urlStr);
CefFrameCppToC::Get(self)->LoadURL(CefString(url));
}
void CEF_CALLBACK frame_load_string(struct _cef_frame_t* self,
const wchar_t* string, const wchar_t* url)
const cef_string_t* string, const cef_string_t* url)
{
DCHECK(self);
if(!self)
return;
std::wstring stringStr, urlStr;
if(string)
stringStr = string;
if(url)
urlStr = url;
CefFrameCppToC::Get(self)->LoadString(stringStr, urlStr);
CefFrameCppToC::Get(self)->LoadString(CefString(string), CefString(url));
}
void CEF_CALLBACK frame_load_stream(struct _cef_frame_t* self,
struct _cef_stream_reader_t* stream, const wchar_t* url)
struct _cef_stream_reader_t* stream, const cef_string_t* url)
{
DCHECK(self);
DCHECK(stream);
if(!self || !stream)
return;
CefRefPtr<CefStreamReader> streamPtr = CefStreamReaderCppToC::Unwrap(stream);
std::wstring urlStr;
if(url)
urlStr = url;
CefFrameCppToC::Get(self)->LoadStream(streamPtr, urlStr);
CefFrameCppToC::Get(self)->LoadStream(CefStreamReaderCppToC::Unwrap(stream),
CefString(url));
}
void CEF_CALLBACK frame_execute_java_script(struct _cef_frame_t* self,
const wchar_t* jsCode, const wchar_t* scriptUrl, int startLine)
const cef_string_t* jsCode, const cef_string_t* scriptUrl, int startLine)
{
DCHECK(self);
if(!self)
return;
std::wstring jsCodeStr, scriptUrlStr;
if(jsCode)
jsCodeStr = jsCode;
if(scriptUrl)
scriptUrlStr = scriptUrl;
CefFrameCppToC::Get(self)->ExecuteJavaScript(jsCodeStr, scriptUrlStr,
startLine);
CefFrameCppToC::Get(self)->ExecuteJavaScript(CefString(jsCode),
CefString(scriptUrl), startLine);
}
int CEF_CALLBACK frame_is_main(struct _cef_frame_t* self)
@ -212,28 +191,24 @@ int CEF_CALLBACK frame_is_focused(struct _cef_frame_t* self)
return CefFrameCppToC::Get(self)->IsFocused();
}
cef_string_t CEF_CALLBACK frame_get_name(struct _cef_frame_t* self)
cef_string_userfree_t CEF_CALLBACK frame_get_name(struct _cef_frame_t* self)
{
DCHECK(self);
if(!self)
return 0;
std::wstring nameStr = CefFrameCppToC::Get(self)->GetName();
if(!nameStr.empty())
return cef_string_alloc(nameStr.c_str());
return NULL;
CefString nameStr = CefFrameCppToC::Get(self)->GetName();
return nameStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK frame_get_url(struct _cef_frame_t* self)
cef_string_userfree_t CEF_CALLBACK frame_get_url(struct _cef_frame_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring urlStr = CefFrameCppToC::Get(self)->GetURL();
if(!urlStr.empty())
return cef_string_alloc(urlStr.c_str());
return NULL;
CefString urlStr = CefFrameCppToC::Get(self)->GetURL();
return urlStr.DetachToUserFree();
}

195
libcef_dll/cpptoc/handler_cpptoc.cc
View File

@ -17,7 +17,6 @@
#include "libcef_dll/ctocpp/request_ctocpp.h"
#include "libcef_dll/ctocpp/stream_reader_ctocpp.h"
#include "libcef_dll/ctocpp/v8value_ctocpp.h"
#include "libcef_dll/transfer_util.h"
// MEMBER FUNCTIONS - Body may be edited by hand.
@ -54,17 +53,11 @@ enum cef_retval_t CEF_CALLBACK handler_handle_before_created(
if(parentBrowser)
browserPtr = CefBrowserCToCpp::Wrap(parentBrowser);
std::wstring urlStr;
if(*url)
urlStr = *url;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleBeforeCreated(
browserPtr, wndInfo, popup?true:false, features, handlerPtr, urlStr,
browserSettings);
browserPtr, wndInfo, popup?true:false, features, handlerPtr,
CefString(url), browserSettings);
transfer_string_contents(urlStr, url);
if(handlerPtr.get() != origHandler) {
if(handlerPtr.get() != origHandler) {
// The handler has been changed.
*handler = CefHandlerCppToC::Wrap(handlerPtr);
}
@ -97,7 +90,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_after_created(
enum cef_retval_t CEF_CALLBACK handler_handle_address_change(
struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
const wchar_t* url)
const cef_string_t* url)
{
DCHECK(self);
DCHECK(browser);
@ -105,28 +98,22 @@ enum cef_retval_t CEF_CALLBACK handler_handle_address_change(
if(!self || !browser || !frame)
return RV_CONTINUE;
std::wstring urlStr;
if(url)
urlStr = url;
return CefHandlerCppToC::Get(self)->HandleAddressChange(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame), urlStr);
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
CefString(url));
}
enum cef_retval_t CEF_CALLBACK handler_handle_title_change(
struct _cef_handler_t* self, cef_browser_t* browser, const wchar_t* title)
struct _cef_handler_t* self, cef_browser_t* browser,
const cef_string_t* title)
{
DCHECK(self);
DCHECK(browser);
if(!self || !browser)
return RV_CONTINUE;
std::wstring titleStr;
if(title)
titleStr = title;
return CefHandlerCppToC::Get(self)->HandleTitleChange(
CefBrowserCToCpp::Wrap(browser), titleStr);
CefBrowserCToCpp::Wrap(browser), CefString(title));
}
enum cef_retval_t CEF_CALLBACK handler_handle_before_browse(
@ -180,7 +167,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_load_end(
enum cef_retval_t CEF_CALLBACK handler_handle_load_error(
struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
enum cef_handler_errorcode_t errorCode, const wchar_t* failedUrl,
enum cef_handler_errorcode_t errorCode, const cef_string_t* failedUrl,
cef_string_t* errorText)
{
DCHECK(self);
@ -190,20 +177,9 @@ enum cef_retval_t CEF_CALLBACK handler_handle_load_error(
if(!self || !browser || !errorText || !frame)
return RV_CONTINUE;
std::wstring failedUrlStr, errorTextStr;
if(failedUrl)
failedUrlStr = failedUrl;
if(*errorText)
errorTextStr = *errorText;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleLoadError(
return CefHandlerCppToC::Get(self)->HandleLoadError(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame), errorCode,
failedUrlStr, errorTextStr);
transfer_string_contents(errorTextStr, errorText);
return rv;
CefString(failedUrl), CefString(errorText));
}
enum cef_retval_t CEF_CALLBACK handler_handle_before_resource_load(
@ -220,21 +196,12 @@ enum cef_retval_t CEF_CALLBACK handler_handle_before_resource_load(
if(!self || !browser || !redirectUrl || !resourceStream || !mimeType)
return RV_CONTINUE;
std::wstring redirectUrlStr, mimeTypeStr;
CefRefPtr<CefStreamReader> streamPtr;
if(*redirectUrl)
redirectUrlStr = *redirectUrl;
if(*mimeType)
mimeTypeStr = *mimeType;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->
HandleBeforeResourceLoad(CefBrowserCToCpp::Wrap(browser),
CefRequestCToCpp::Wrap(request), redirectUrlStr, streamPtr, mimeTypeStr,
loadFlags);
transfer_string_contents(redirectUrlStr, redirectUrl);
transfer_string_contents(mimeTypeStr, mimeType);
CefRequestCToCpp::Wrap(request), CefString(redirectUrl), streamPtr,
CefString(mimeType), loadFlags);
if(streamPtr.get())
*resourceStream = CefStreamReaderCToCpp::Unwrap(streamPtr);
@ -244,8 +211,8 @@ enum cef_retval_t CEF_CALLBACK handler_handle_before_resource_load(
enum cef_retval_t CEF_CALLBACK handler_handle_download_response(
struct _cef_handler_t* self, cef_browser_t* browser,
const wchar_t* mimeType, const wchar_t* fileName, int64 contentLength,
struct _cef_download_handler_t** handler)
const cef_string_t* mimeType, const cef_string_t* fileName,
int64 contentLength, struct _cef_download_handler_t** handler)
{
DCHECK(self);
DCHECK(browser);
@ -254,17 +221,11 @@ enum cef_retval_t CEF_CALLBACK handler_handle_download_response(
if(!self || !browser || !mimeType || !fileName)
return RV_CONTINUE;
std::wstring mimeTypeStr, fileNameStr;
CefRefPtr<CefDownloadHandler> downloadPtr;
if(mimeType)
mimeTypeStr = mimeType;
if(fileName)
fileNameStr = fileName;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->
HandleDownloadResponse(CefBrowserCToCpp::Wrap(browser), mimeTypeStr,
fileNameStr, contentLength, downloadPtr);
HandleDownloadResponse(CefBrowserCToCpp::Wrap(browser),
CefString(mimeType), CefString(fileName), contentLength, downloadPtr);
if(downloadPtr.get())
*handler = CefDownloadHandlerCppToC::Wrap(downloadPtr);
@ -296,16 +257,8 @@ enum cef_retval_t CEF_CALLBACK handler_handle_get_menu_label(
if(!self || !browser || !label)
return RV_CONTINUE;
std::wstring labelStr;
if(*label)
labelStr = *label;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleGetMenuLabel(
CefBrowserCToCpp::Wrap(browser), menuId, labelStr);
transfer_string_contents(labelStr, label);
return rv;
return CefHandlerCppToC::Get(self)->HandleGetMenuLabel(
CefBrowserCToCpp::Wrap(browser), menuId, CefString(label));
}
enum cef_retval_t CEF_CALLBACK handler_handle_menu_action(
@ -336,10 +289,11 @@ enum cef_retval_t CEF_CALLBACK handler_handle_print_options(
enum cef_retval_t CEF_CALLBACK handler_handle_print_header_footer(
struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
cef_print_info_t* printInfo, const wchar_t* url, const wchar_t* title,
int currentPage, int maxPages, cef_string_t* topLeft,
cef_string_t* topCenter, cef_string_t* topRight, cef_string_t* bottomLeft,
cef_string_t* bottomCenter, cef_string_t* bottomRight)
cef_print_info_t* printInfo, const cef_string_t* url,
const cef_string_t* title, int currentPage, int maxPages,
cef_string_t* topLeft, cef_string_t* topCenter, cef_string_t* topRight,
cef_string_t* bottomLeft, cef_string_t* bottomCenter,
cef_string_t* bottomRight)
{
DCHECK(self);
DCHECK(browser);
@ -351,47 +305,19 @@ enum cef_retval_t CEF_CALLBACK handler_handle_print_header_footer(
|| !topRight || !bottomLeft || !bottomCenter || !bottomRight)
return RV_CONTINUE;
std::wstring urlStr, titleStr;
std::wstring topLeftStr, topCenterStr, topRightStr;
std::wstring bottomLeftStr, bottomCenterStr, bottomRightStr;
CefPrintInfo info = *printInfo;
if(url)
urlStr = url;
if(title)
titleStr = title;
if(*topLeft)
topLeftStr = *topLeft;
if(*topCenter)
topCenterStr = *topCenter;
if(*topRight)
topRightStr = *topRight;
if(*bottomLeft)
bottomLeftStr = *bottomLeft;
if(*bottomCenter)
bottomCenterStr = *bottomCenter;
if(*bottomRight)
bottomRightStr = *bottomRight;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->
return CefHandlerCppToC::Get(self)->
HandlePrintHeaderFooter(CefBrowserCToCpp::Wrap(browser),
CefFrameCToCpp::Wrap(frame), info, urlStr, titleStr, currentPage,
maxPages, topLeftStr, topCenterStr, topRightStr, bottomLeftStr,
bottomCenterStr, bottomRightStr);
transfer_string_contents(topLeftStr, topLeft);
transfer_string_contents(topCenterStr, topCenter);
transfer_string_contents(topRightStr, topRight);
transfer_string_contents(bottomLeftStr, bottomLeft);
transfer_string_contents(bottomCenterStr, bottomCenter);
transfer_string_contents(bottomRightStr, bottomRight);
return rv;
CefFrameCToCpp::Wrap(frame), info, CefString(url), CefString(title),
currentPage, maxPages, CefString(topLeft), CefString(topCenter),
CefString(topRight), CefString(bottomLeft), CefString(bottomCenter),
CefString(bottomRight));
}
enum cef_retval_t CEF_CALLBACK handler_handle_jsalert(
struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
const wchar_t* message)
const cef_string_t* message)
{
DCHECK(self);
DCHECK(browser);
@ -399,17 +325,14 @@ enum cef_retval_t CEF_CALLBACK handler_handle_jsalert(
if(!self || !browser || !frame)
return RV_CONTINUE;
std::wstring messageStr;
if(message)
messageStr = message;
return CefHandlerCppToC::Get(self)->HandleJSAlert(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame), messageStr);
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
CefString(message));
}
enum cef_retval_t CEF_CALLBACK handler_handle_jsconfirm(
struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
const wchar_t* message, int* retval)
const cef_string_t* message, int* retval)
{
DCHECK(self);
DCHECK(browser);
@ -418,14 +341,10 @@ enum cef_retval_t CEF_CALLBACK handler_handle_jsconfirm(
if(!self || !browser || !retval || !frame)
return RV_CONTINUE;
std::wstring messageStr;
if(message)
messageStr = message;
bool ret = false;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleJSConfirm(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame), messageStr,
ret);
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
CefString(message), ret);
*retval = (ret ? 1 : 0);
return rv;
@ -433,7 +352,7 @@ enum cef_retval_t CEF_CALLBACK handler_handle_jsconfirm(
enum cef_retval_t CEF_CALLBACK handler_handle_jsprompt(
struct _cef_handler_t* self, cef_browser_t* browser, cef_frame_t* frame,
const wchar_t* message, const wchar_t* defaultValue, int* retval,
const cef_string_t* message, const cef_string_t* defaultValue, int* retval,
cef_string_t* result)
{
DCHECK(self);
@ -444,23 +363,12 @@ enum cef_retval_t CEF_CALLBACK handler_handle_jsprompt(
if(!self || !browser || !frame || !retval || !result)
return RV_CONTINUE;
std::wstring messageStr, defaultValueStr, resultStr;
if(message)
messageStr = message;
if(defaultValue)
defaultValueStr = defaultValue;
if(*result)
resultStr = *result;
bool ret = false;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleJSPrompt(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame), messageStr,
defaultValueStr, ret, resultStr);
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
CefString(message), CefString(defaultValue), ret, CefString(result));
*retval = (ret ? 1 : 0);
transfer_string_contents(resultStr, result);
return rv;
}
@ -540,35 +448,22 @@ enum cef_retval_t CEF_CALLBACK handler_handle_tooltip(
if(!self || !browser || !text)
return RV_CONTINUE;
std::wstring textStr;
if(*text)
textStr = *text;
enum cef_retval_t rv = CefHandlerCppToC::Get(self)->HandleTooltip(
CefBrowserCToCpp::Wrap(browser), textStr);
transfer_string_contents(textStr, text);
return rv;
return CefHandlerCppToC::Get(self)->HandleTooltip(
CefBrowserCToCpp::Wrap(browser), CefString(text));
}
enum cef_retval_t CEF_CALLBACK handler_handle_console_message(
struct _cef_handler_t* self, cef_browser_t* browser, const wchar_t* message,
const wchar_t* source, int line)
struct _cef_handler_t* self, cef_browser_t* browser,
const cef_string_t* message, const cef_string_t* source, int line)
{
DCHECK(self);
DCHECK(browser);
if(!self || !browser)
return RV_CONTINUE;
std::wstring messageStr, sourceStr;
if(message)
messageStr = message;
if(source)
sourceStr = source;
return CefHandlerCppToC::Get(self)->HandleConsoleMessage(
CefBrowserCToCpp::Wrap(browser), messageStr, sourceStr, line);
CefBrowserCToCpp::Wrap(browser), CefString(message), CefString(source),
line);
}
enum cef_retval_t CEF_CALLBACK handler_handle_find_result(

17
libcef_dll/cpptoc/post_data_element_cpptoc.cc
View File

@ -38,17 +38,13 @@ void CEF_CALLBACK post_data_element_set_to_empty(
}
void CEF_CALLBACK post_data_element_set_to_file(
struct _cef_post_data_element_t* self, const wchar_t* fileName)
struct _cef_post_data_element_t* self, const cef_string_t* fileName)
{
DCHECK(self);
if(!self)
return;
std::wstring fileNameStr;
if(fileName)
fileNameStr = fileName;
CefPostDataElementCppToC::Get(self)->SetToFile(fileNameStr);
CefPostDataElementCppToC::Get(self)->SetToFile(CefString(fileName));
}
void CEF_CALLBACK post_data_element_set_to_bytes(
@ -71,18 +67,15 @@ enum cef_postdataelement_type_t CEF_CALLBACK post_data_element_get_type(
return CefPostDataElementCppToC::Get(self)->GetType();
}
cef_string_t CEF_CALLBACK post_data_element_get_file(
cef_string_userfree_t CEF_CALLBACK post_data_element_get_file(
struct _cef_post_data_element_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring fileNameStr =
CefPostDataElementCppToC::Get(self)->GetFile();
if(!fileNameStr.empty())
return cef_string_alloc(fileNameStr.c_str());
return NULL;
CefString fileNameStr = CefPostDataElementCppToC::Get(self)->GetFile();
return fileNameStr.DetachToUserFree();
}
size_t CEF_CALLBACK post_data_element_get_bytes_count(

45
libcef_dll/cpptoc/request_cpptoc.cc
View File

@ -28,54 +28,45 @@ CEF_EXPORT cef_request_t* cef_request_create()
// MEMBER FUNCTIONS - Body may be edited by hand.
cef_string_t CEF_CALLBACK request_get_url(struct _cef_request_t* self)
cef_string_userfree_t CEF_CALLBACK request_get_url(struct _cef_request_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring urlStr = CefRequestCppToC::Get(self)->GetURL();
if(!urlStr.empty())
return cef_string_alloc(urlStr.c_str());
return NULL;
CefString urlStr = CefRequestCppToC::Get(self)->GetURL();
return urlStr.DetachToUserFree();
}
void CEF_CALLBACK request_set_url(struct _cef_request_t* self,
const wchar_t* url)
const cef_string_t* url)
{
DCHECK(self);
if(!self)
return;
std::wstring urlStr;
if(url)
urlStr = url;
CefRequestCppToC::Get(self)->SetURL(urlStr);
CefRequestCppToC::Get(self)->SetURL(CefString(url));
}
cef_string_t CEF_CALLBACK request_get_method(struct _cef_request_t* self)
cef_string_userfree_t CEF_CALLBACK request_get_method(
struct _cef_request_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring methodStr = CefRequestCppToC::Get(self)->GetMethod();
if(!methodStr.empty())
return cef_string_alloc(methodStr.c_str());
return NULL;
CefString methodStr = CefRequestCppToC::Get(self)->GetMethod();
return methodStr.DetachToUserFree();
}
void CEF_CALLBACK request_set_method(struct _cef_request_t* self,
const wchar_t* method)
const cef_string_t* method)
{
DCHECK(self);
if(!self)
return;
std::wstring methodStr;
if(method)
methodStr = method;
CefRequestCppToC::Get(self)->SetMethod(methodStr);
CefRequestCppToC::Get(self)->SetMethod(CefString(method));
}
struct _cef_post_data_t* CEF_CALLBACK request_get_post_data(
@ -133,28 +124,24 @@ void CEF_CALLBACK request_set_header_map(struct _cef_request_t* self,
CefRequestCppToC::Get(self)->SetHeaderMap(map);
}
void CEF_CALLBACK request_set(struct _cef_request_t* self, const wchar_t* url,
const wchar_t* method, struct _cef_post_data_t* postData,
cef_string_map_t headerMap)
void CEF_CALLBACK request_set(struct _cef_request_t* self,
const cef_string_t* url, const cef_string_t* method,
struct _cef_post_data_t* postData, cef_string_map_t headerMap)
{
DCHECK(self);
if(!self)
return;
std::wstring urlStr, methodStr;
CefRefPtr<CefPostData> postDataPtr;
CefRequest::HeaderMap map;
if(url)
urlStr = url;
if(method)
methodStr = method;
if(postData)
postDataPtr = CefPostDataCppToC::Unwrap(postData);
if(headerMap)
transfer_string_map_contents(headerMap, map);
CefRequestCppToC::Get(self)->Set(urlStr, methodStr, postDataPtr, map);
CefRequestCppToC::Get(self)->Set(CefString(url), CefString(method),
postDataPtr, map);
}

13
libcef_dll/cpptoc/scheme_handler_cpptoc.cc
View File

@ -12,7 +12,6 @@
#include "libcef_dll/cpptoc/scheme_handler_cpptoc.h"
#include "libcef_dll/ctocpp/request_ctocpp.h"
#include "libcef_dll/transfer_util.h"
// MEMBER FUNCTIONS - Body may be edited by hand.
@ -28,16 +27,8 @@ int CEF_CALLBACK scheme_handler_process_request(
if(!self || !request || !mime_type || !response_length)
return 0;
std::wstring mimeTypeStr;
if(*mime_type)
mimeTypeStr = *mime_type;
bool rv = CefSchemeHandlerCppToC::Get(self)->ProcessRequest(
CefRequestCToCpp::Wrap(request), mimeTypeStr, response_length);
transfer_string_contents(mimeTypeStr, mime_type);
return rv?1:0;
return CefSchemeHandlerCppToC::Get(self)->ProcessRequest(
CefRequestCToCpp::Wrap(request), CefString(mime_type), response_length);
}
void CEF_CALLBACK scheme_handler_cancel(struct _cef_scheme_handler_t* self)

8
libcef_dll/cpptoc/stream_reader_cpptoc.cc
View File

@ -17,12 +17,10 @@
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT cef_stream_reader_t* cef_stream_reader_create_for_file(
const wchar_t* fileName)
const cef_string_t* fileName)
{
std::wstring filenamestr;
if(fileName)
filenamestr = fileName;
CefRefPtr<CefStreamReader> impl = CefStreamReader::CreateForFile(filenamestr);
CefRefPtr<CefStreamReader> impl =
CefStreamReader::CreateForFile(CefString(fileName));
if(impl.get())
return CefStreamReaderCppToC::Wrap(impl);
return NULL;

6
libcef_dll/cpptoc/stream_writer_cpptoc.cc
View File

@ -17,14 +17,14 @@
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT cef_stream_writer_t* cef_stream_writer_create_for_file(
const wchar_t* fileName)
const cef_string_t* fileName)
{
DCHECK(fileName);
if(!fileName)
return NULL;
std::wstring fileNameStr = fileName;
CefRefPtr<CefStreamWriter> impl = CefStreamWriter::CreateForFile(fileName);
CefRefPtr<CefStreamWriter> impl =
CefStreamWriter::CreateForFile(CefString(fileName));
if(impl.get())
return CefStreamWriterCppToC::Wrap(impl);
return NULL;

17
libcef_dll/cpptoc/v8handler_cpptoc.cc
View File

@ -17,9 +17,9 @@
// MEMBER FUNCTIONS - Body may be edited by hand.
int CEF_CALLBACK v8handler_execute(struct _cef_v8handler_t* self,
const wchar_t* name, struct _cef_v8value_t* object, size_t argumentCount,
struct _cef_v8value_t* const* arguments, struct _cef_v8value_t** retval,
cef_string_t* exception)
const cef_string_t* name, struct _cef_v8value_t* object,
size_t argumentCount, struct _cef_v8value_t* const* arguments,
struct _cef_v8value_t** retval, cef_string_t* exception)
{
DCHECK(self);
if(!self)
@ -29,22 +29,15 @@ int CEF_CALLBACK v8handler_execute(struct _cef_v8handler_t* self,
if(object)
objectPtr = CefV8ValueCToCpp::Wrap(object);
std::wstring nameStr;
if(name)
nameStr = name;
CefV8ValueList list;
for(size_t i = 0; i < argumentCount; ++i) {
list.push_back(CefV8ValueCToCpp::Wrap(arguments[i]));
}
CefRefPtr<CefV8Value> retValPtr;
std::wstring exceptionStr;
bool rv = CefV8HandlerCppToC::Get(self)->Execute(nameStr, objectPtr,
list, retValPtr, exceptionStr);
bool rv = CefV8HandlerCppToC::Get(self)->Execute(CefString(name), objectPtr,
list, retValPtr, CefString(exception));
if(rv) {
if(!exceptionStr.empty() && exception)
*exception = cef_string_alloc(exceptionStr.c_str());
if(retValPtr.get() && retval)
*retval = CefV8ValueCToCpp::Unwrap(retValPtr);
}

76
libcef_dll/cpptoc/v8value_cpptoc.cc
View File

@ -57,13 +57,9 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_double(double value)
return NULL;
}
CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const wchar_t* value)
CEF_EXPORT cef_v8value_t* cef_v8value_create_string(const cef_string_t* value)
{
std::wstring valueStr;
if(value)
valueStr = value;
CefRefPtr<CefV8Value> impl = CefV8Value::CreateString(valueStr);
CefRefPtr<CefV8Value> impl = CefV8Value::CreateString(CefString(value));
if(impl.get())
return CefV8ValueCppToC::Wrap(impl);
return NULL;
@ -89,17 +85,15 @@ CEF_EXPORT cef_v8value_t* cef_v8value_create_array()
return NULL;
}
CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const wchar_t* name,
CEF_EXPORT cef_v8value_t* cef_v8value_create_function(const cef_string_t* name,
cef_v8handler_t* handler)
{
std::wstring nameStr;
if(name)
nameStr = name;
CefRefPtr<CefV8Handler> handlerPtr;
if(handler)
handlerPtr = CefV8HandlerCToCpp::Wrap(handler);
CefRefPtr<CefV8Value> impl = CefV8Value::CreateFunction(nameStr, handlerPtr);
CefRefPtr<CefV8Value> impl =
CefV8Value::CreateFunction(CefString(name), handlerPtr);
if(impl.get())
return CefV8ValueCppToC::Wrap(impl);
return NULL;
@ -216,30 +210,25 @@ double CEF_CALLBACK v8value_get_double_value(struct _cef_v8value_t* self)
return CefV8ValueCppToC::Get(self)->GetDoubleValue();
}
cef_string_t CEF_CALLBACK v8value_get_string_value(struct _cef_v8value_t* self)
cef_string_userfree_t CEF_CALLBACK v8value_get_string_value(
struct _cef_v8value_t* self)
{
DCHECK(self);
if(!self)
return 0;
std::wstring valueStr = CefV8ValueCppToC::Get(self)->GetStringValue();
if(!valueStr.empty())
return cef_string_alloc(valueStr.c_str());
return NULL;
CefString valueStr = CefV8ValueCppToC::Get(self)->GetStringValue();
return valueStr.DetachToUserFree();
}
int CEF_CALLBACK v8value_has_value_bykey(struct _cef_v8value_t* self,
const wchar_t* key)
const cef_string_t* key)
{
DCHECK(self);
if(!self)
return 0;
std::wstring keyStr;
if(key)
keyStr = key;
return CefV8ValueCppToC::Get(self)->HasValue(keyStr);
return CefV8ValueCppToC::Get(self)->HasValue(CefString(key));
}
int CEF_CALLBACK v8value_has_value_byindex(struct _cef_v8value_t* self,
@ -253,17 +242,13 @@ int CEF_CALLBACK v8value_has_value_byindex(struct _cef_v8value_t* self,
}
int CEF_CALLBACK v8value_delete_value_bykey(struct _cef_v8value_t* self,
const wchar_t* key)
const cef_string_t* key)
{
DCHECK(self);
if(!self)
return 0;
std::wstring keyStr;
if(key)
keyStr = key;
return CefV8ValueCppToC::Get(self)->DeleteValue(keyStr);
return CefV8ValueCppToC::Get(self)->DeleteValue(CefString(key));
}
int CEF_CALLBACK v8value_delete_value_byindex(struct _cef_v8value_t* self,
@ -277,18 +262,14 @@ int CEF_CALLBACK v8value_delete_value_byindex(struct _cef_v8value_t* self,
}
struct _cef_v8value_t* CEF_CALLBACK v8value_get_value_bykey(
struct _cef_v8value_t* self, const wchar_t* key)
struct _cef_v8value_t* self, const cef_string_t* key)
{
DCHECK(self);
if(!self)
return 0;
std::wstring keyStr;
if(key)
keyStr = key;
CefRefPtr<CefV8Value> valuePtr =
CefV8ValueCppToC::Get(self)->GetValue(keyStr);
CefV8ValueCppToC::Get(self)->GetValue(CefString(key));
return CefV8ValueCppToC::Wrap(valuePtr);
}
@ -305,18 +286,14 @@ struct _cef_v8value_t* CEF_CALLBACK v8value_get_value_byindex(
}
int CEF_CALLBACK v8value_set_value_bykey(struct _cef_v8value_t* self,
const wchar_t* key, struct _cef_v8value_t* value)
const cef_string_t* key, struct _cef_v8value_t* value)
{
DCHECK(self);
if(!self)
return 0;
std::wstring keyStr;
if(key)
keyStr = key;
CefRefPtr<CefV8Value> valuePtr = CefV8ValueCppToC::Unwrap(value);
return CefV8ValueCppToC::Get(self)->SetValue(keyStr, valuePtr);
return CefV8ValueCppToC::Get(self)->SetValue(CefString(key), valuePtr);
}
int CEF_CALLBACK v8value_set_value_byindex(struct _cef_v8value_t* self,
@ -337,11 +314,11 @@ int CEF_CALLBACK v8value_get_keys(struct _cef_v8value_t* self,
if(!self)
return 0;
std::vector<std::wstring> keysList;
std::vector<CefString> keysList;
CefV8ValueCppToC::Get(self)->GetKeys(keysList);
size_t size = keysList.size();
for(size_t i = 0; i < size; ++i)
cef_string_list_append(keys, keysList[i].c_str());
cef_string_list_append(keys, keysList[i].GetStruct());
return size;
}
@ -366,17 +343,15 @@ int CEF_CALLBACK v8value_get_array_length(struct _cef_v8value_t* self)
return CefV8ValueCppToC::Get(self)->GetArrayLength();
}
cef_string_t CEF_CALLBACK v8value_get_function_name(struct _cef_v8value_t* self)
cef_string_userfree_t CEF_CALLBACK v8value_get_function_name(
struct _cef_v8value_t* self)
{
DCHECK(self);
if(!self)
return 0;
std::wstring functionNameStr =
CefV8ValueCppToC::Get(self)->GetFunctionName();
if(!functionNameStr.empty())
return cef_string_alloc(functionNameStr.c_str());
return NULL;
CefString functionNameStr = CefV8ValueCppToC::Get(self)->GetFunctionName();
return functionNameStr.DetachToUserFree();
}
cef_v8handler_t* CEF_CALLBACK v8value_get_function_handler(
@ -409,14 +384,11 @@ int CEF_CALLBACK v8value_execute_function(struct _cef_v8value_t* self,
argsList.push_back(CefV8ValueCppToC::Unwrap(arguments[i]));
}
CefRefPtr<CefV8Value> retvalPtr;
std::wstring exceptionStr;
bool rv = CefV8ValueCppToC::Get(self)->ExecuteFunction(objectPtr,
argsList, retvalPtr, exceptionStr);
argsList, retvalPtr, CefString(exception));
if(retvalPtr.get() && retval)
*retval = CefV8ValueCppToC::Wrap(retvalPtr);
if(!exceptionStr.empty() && exception)
*exception = cef_string_alloc(exceptionStr.c_str());
return rv;
}

151
libcef_dll/cpptoc/xml_reader_cpptoc.cc
View File

@ -17,13 +17,10 @@
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT cef_xml_reader_t* cef_xml_reader_create(cef_stream_reader_t* stream,
enum cef_xml_encoding_type_t encodingType, const wchar_t* URI)
enum cef_xml_encoding_type_t encodingType, const cef_string_t* URI)
{
std::wstring encodingTypeStr;
if(encodingType)
encodingTypeStr = encodingType;
CefRefPtr<CefXmlReader> impl = CefXmlReader::Create(
CefStreamReaderCppToC::Unwrap(stream), encodingType, encodingTypeStr);
CefStreamReaderCppToC::Unwrap(stream), encodingType, CefString(URI));
if(impl.get())
return CefXmlReaderCppToC::Wrap(impl);
return NULL;
@ -59,16 +56,15 @@ int CEF_CALLBACK xml_reader_has_error(struct _cef_xml_reader_t* self)
return CefXmlReaderCppToC::Get(self)->HasError();
}
cef_string_t CEF_CALLBACK xml_reader_get_error(struct _cef_xml_reader_t* self)
cef_string_userfree_t CEF_CALLBACK xml_reader_get_error(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetError();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetError();
return retStr.DetachToUserFree();
}
enum cef_xml_node_type_t CEF_CALLBACK xml_reader_get_type(
@ -90,81 +86,70 @@ int CEF_CALLBACK xml_reader_get_depth(struct _cef_xml_reader_t* self)
return CefXmlReaderCppToC::Get(self)->GetDepth();
}
cef_string_t CEF_CALLBACK xml_reader_get_local_name(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_local_name(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetLocalName();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetLocalName();
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_prefix(struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetPrefix();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
}
cef_string_t CEF_CALLBACK xml_reader_get_qualified_name(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_prefix(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetQualifiedName();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetPrefix();
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_namespace_uri(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_qualified_name(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetNamespaceURI();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetQualifiedName();
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_base_uri(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_namespace_uri(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetBaseURI();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetNamespaceURI();
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_xml_lang(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_base_uri(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetXmlLang();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetBaseURI();
return retStr.DetachToUserFree();
}
cef_string_userfree_t CEF_CALLBACK xml_reader_get_xml_lang(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetXmlLang();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_is_empty_element(struct _cef_xml_reader_t* self)
@ -185,16 +170,15 @@ int CEF_CALLBACK xml_reader_has_value(struct _cef_xml_reader_t* self)
return CefXmlReaderCppToC::Get(self)->HasValue();
}
cef_string_t CEF_CALLBACK xml_reader_get_value(struct _cef_xml_reader_t* self)
cef_string_userfree_t CEF_CALLBACK xml_reader_get_value(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetValue();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetValue();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_has_attributes(struct _cef_xml_reader_t* self)
@ -216,37 +200,33 @@ size_t CEF_CALLBACK xml_reader_get_attribute_count(
return CefXmlReaderCppToC::Get(self)->GetAttributeCount();
}
cef_string_t CEF_CALLBACK xml_reader_get_attribute_byindex(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_byindex(
struct _cef_xml_reader_t* self, int index)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(index);
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(index);
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_attribute_byqname(
struct _cef_xml_reader_t* self, const wchar_t* qualifiedName)
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_byqname(
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName)
{
DCHECK(self);
DCHECK(qualifiedName);
if(!self || !qualifiedName)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
qualifiedName);
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
CefString(qualifiedName));
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_attribute_bylname(
struct _cef_xml_reader_t* self, const wchar_t* localName,
const wchar_t* namespaceURI)
cef_string_userfree_t CEF_CALLBACK xml_reader_get_attribute_bylname(
struct _cef_xml_reader_t* self, const cef_string_t* localName,
const cef_string_t* namespaceURI)
{
DCHECK(self);
DCHECK(localName);
@ -254,37 +234,31 @@ cef_string_t CEF_CALLBACK xml_reader_get_attribute_bylname(
if(!self || !localName || !namespaceURI)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
localName, namespaceURI);
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetAttribute(
CefString(localName), CefString(namespaceURI));
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_inner_xml(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_inner_xml(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetInnerXml();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetInnerXml();
return retStr.DetachToUserFree();
}
cef_string_t CEF_CALLBACK xml_reader_get_outer_xml(
cef_string_userfree_t CEF_CALLBACK xml_reader_get_outer_xml(
struct _cef_xml_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefXmlReaderCppToC::Get(self)->GetOuterXml();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return NULL;
CefString retStr = CefXmlReaderCppToC::Get(self)->GetOuterXml();
return retStr.DetachToUserFree();
}
int CEF_CALLBACK xml_reader_get_line_number(struct _cef_xml_reader_t* self)
@ -307,19 +281,20 @@ int CEF_CALLBACK xml_reader_move_to_attribute_byindex(
}
int CEF_CALLBACK xml_reader_move_to_attribute_byqname(
struct _cef_xml_reader_t* self, const wchar_t* qualifiedName)
struct _cef_xml_reader_t* self, const cef_string_t* qualifiedName)
{
DCHECK(self);
DCHECK(qualifiedName);
if(!self || !qualifiedName)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(qualifiedName);
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(
CefString(qualifiedName));
}
int CEF_CALLBACK xml_reader_move_to_attribute_bylname(
struct _cef_xml_reader_t* self, const wchar_t* localName,
const wchar_t* namespaceURI)
struct _cef_xml_reader_t* self, const cef_string_t* localName,
const cef_string_t* namespaceURI)
{
DCHECK(self);
DCHECK(localName);
@ -327,8 +302,8 @@ int CEF_CALLBACK xml_reader_move_to_attribute_bylname(
if(!self || !localName || !namespaceURI)
return 0;
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(localName,
namespaceURI);
return CefXmlReaderCppToC::Get(self)->MoveToAttribute(CefString(localName),
CefString(namespaceURI));
}
int CEF_CALLBACK xml_reader_move_to_first_attribute(

22
libcef_dll/cpptoc/zip_reader_cpptoc.cc
View File

@ -47,17 +47,13 @@ int CEF_CALLBACK zip_reader_move_to_next_file(struct _cef_zip_reader_t* self)
}
int CEF_CALLBACK zip_reader_move_to_file(struct _cef_zip_reader_t* self,
const wchar_t* fileName, int caseSensitive)
const cef_string_t* fileName, int caseSensitive)
{
DCHECK(self);
if(!self)
return 0;
std::wstring fileNameStr;
if (fileName)
fileNameStr = fileName;
return CefZipReaderCppToC::Get(self)->MoveToFile(fileNameStr,
return CefZipReaderCppToC::Get(self)->MoveToFile(CefString(fileName),
caseSensitive ? true : false);
}
@ -70,16 +66,16 @@ int CEF_CALLBACK zip_reader_close(struct _cef_zip_reader_t* self)
return CefZipReaderCppToC::Get(self)->Close();
}
cef_string_t CEF_CALLBACK zip_reader_get_file_name(
cef_string_userfree_t CEF_CALLBACK zip_reader_get_file_name(
struct _cef_zip_reader_t* self)
{
DCHECK(self);
if(!self)
return NULL;
std::wstring retStr = CefZipReaderCppToC::Get(self)->GetFileName();
CefString retStr = CefZipReaderCppToC::Get(self)->GetFileName();
if(!retStr.empty())
return cef_string_alloc(retStr.c_str());
return retStr.DetachToUserFree();
return NULL;
}
@ -103,17 +99,13 @@ time_t CEF_CALLBACK zip_reader_get_file_last_modified(
}
int CEF_CALLBACK zip_reader_open_file(struct _cef_zip_reader_t* self,
const wchar_t* password)
const cef_string_t* password)
{
DCHECK(self);
if(!self)
return 0;
std::wstring passwordStr;
if (password)
passwordStr = password;
return CefZipReaderCppToC::Get(self)->OpenFile(passwordStr);
return CefZipReaderCppToC::Get(self)->OpenFile(CefString(password));
}
int CEF_CALLBACK zip_reader_close_file(struct _cef_zip_reader_t* self)