- Auto-generate all C/C++ translation code (issue #33).

- Change index parameter types from int to size_t to make 0-based range implicit. - Make CefPrintOptions and CefMenuInfo proper wrapper classes. - Normalize the naming of menu-related types. - Remove unused command_line variable from test_suite.cc. git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@408 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
2025-06-05 21:39:12 +02:00 · 2011-12-08 01:38:30 +00:00
parent b4653ce1da
commit 64e08c2918
238 changed files with 14703 additions and 4322 deletions
--- a/libcef_dll/cpptoc/request_handler_cpptoc.cc
+++ b/libcef_dll/cpptoc/request_handler_cpptoc.cc
@ -4,8 +4,8 @@
 //
 // ---------------------------------------------------------------------------
 //
-// A portion of this file was generated by the CEF translator tool.  When
-// making changes by hand only do so within the body of existing function
+// This file was generated by the CEF translator tool. If making changes by
+// hand only do so within the body of existing method and function
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
@ -27,139 +27,311 @@ int CEF_CALLBACK request_handler_on_before_browse(
    cef_frame_t* frame, struct _cef_request_t* request,
    enum cef_handler_navtype_t navType, int isRedirect)
 {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: browser; type: refptr_diff
  DCHECK(browser);
+  if (!browser)
+    return 0;
+  // Verify param: frame; type: refptr_diff
  DCHECK(frame);
+  if (!frame)
+    return 0;
+  // Verify param: request; type: refptr_diff
  DCHECK(request);
-  if (!self || !browser || !frame || !request)
+  if (!request)
    return 0;

-  return CefRequestHandlerCppToC::Get(self)->OnBeforeBrowse(
-      CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
-      CefRequestCToCpp::Wrap(request), navType, (isRedirect ? true : false));
+  // Execute
+  bool _retval = CefRequestHandlerCppToC::Get(self)->OnBeforeBrowse(
+      CefBrowserCToCpp::Wrap(browser),
+      CefFrameCToCpp::Wrap(frame),
+      CefRequestCToCpp::Wrap(request),
+      navType,
+      isRedirect?true:false);
+
+  // Return type: bool
+  return _retval;
 }

+
 int CEF_CALLBACK request_handler_on_before_resource_load(
    struct _cef_request_handler_t* self, cef_browser_t* browser,
    struct _cef_request_t* request, cef_string_t* redirectUrl,
    struct _cef_stream_reader_t** resourceStream,
    struct _cef_response_t* response, int loadFlags)
 {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: browser; type: refptr_diff
  DCHECK(browser);
+  if (!browser)
+    return 0;
+  // Verify param: request; type: refptr_diff
  DCHECK(request);
+  if (!request)
+    return 0;
+  // Verify param: redirectUrl; type: string_byref
  DCHECK(redirectUrl);
+  if (!redirectUrl)
+    return 0;
+  // Verify param: resourceStream; type: refptr_diff_byref
  DCHECK(resourceStream);
+  if (!resourceStream)
+    return 0;
+  // Verify param: response; type: refptr_diff
  DCHECK(response);
-  if (!self || !browser || !request || !redirectUrl || !resourceStream ||
-      !response)
+  if (!response)
    return 0;

-  CefRefPtr<CefStreamReader> streamPtr;
-
+  // Translate param: redirectUrl; type: string_byref
  CefString redirectUrlStr(redirectUrl);
-  int rv = CefRequestHandlerCppToC::Get(self)->OnBeforeResourceLoad(
-      CefBrowserCToCpp::Wrap(browser), CefRequestCToCpp::Wrap(request),
-      redirectUrlStr, streamPtr, CefResponseCToCpp::Wrap(response), loadFlags);
+  // Translate param: resourceStream; type: refptr_diff_byref
+  CefRefPtr<CefStreamReader> resourceStreamPtr;
+  if (resourceStream && *resourceStream)
+    resourceStreamPtr = CefStreamReaderCToCpp::Wrap(*resourceStream);
+  CefStreamReader* resourceStreamOrig = resourceStreamPtr.get();

-  if(streamPtr.get())
-    *resourceStream = CefStreamReaderCToCpp::Unwrap(streamPtr);
+  // Execute
+  bool _retval = CefRequestHandlerCppToC::Get(self)->OnBeforeResourceLoad(
+      CefBrowserCToCpp::Wrap(browser),
+      CefRequestCToCpp::Wrap(request),
+      redirectUrlStr,
+      resourceStreamPtr,
+      CefResponseCToCpp::Wrap(response),
+      loadFlags);

-  return rv;
+  // Restore param: resourceStream; type: refptr_diff_byref
+  if (resourceStream) {
+    if (resourceStreamPtr.get()) {
+      if (resourceStreamPtr.get() != resourceStreamOrig) {
+        *resourceStream = CefStreamReaderCToCpp::Unwrap(resourceStreamPtr);
+      }
+    } else {
+      *resourceStream = NULL;
+    }
+  }
+
+  // Return type: bool
+  return _retval;
 }

+
 void CEF_CALLBACK request_handler_on_resource_response(
    struct _cef_request_handler_t* self, cef_browser_t* browser,
    const cef_string_t* url, struct _cef_response_t* response,
    struct _cef_content_filter_t** filter)
 {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
  DCHECK(self);
+  if (!self)
+    return;
+  // Verify param: browser; type: refptr_diff
  DCHECK(browser);
+  if (!browser)
+    return;
+  // Verify param: url; type: string_byref_const
  DCHECK(url);
+  if (!url)
+    return;
+  // Verify param: response; type: refptr_diff
  DCHECK(response);
+  if (!response)
+    return;
+  // Verify param: filter; type: refptr_same_byref
  DCHECK(filter);
-  if (!self || !browser || !url || !response || !filter)
+  if (!filter)
    return;

+  // Translate param: filter; type: refptr_same_byref
  CefRefPtr<CefContentFilter> filterPtr;
+  if (filter && *filter)
+    filterPtr = CefContentFilterCppToC::Unwrap(*filter);
+  CefContentFilter* filterOrig = filterPtr.get();

+  // Execute
  CefRequestHandlerCppToC::Get(self)->OnResourceResponse(
-      CefBrowserCToCpp::Wrap(browser), url, CefResponseCToCpp::Wrap(response),
+      CefBrowserCToCpp::Wrap(browser),
+      CefString(url),
+      CefResponseCToCpp::Wrap(response),
      filterPtr);

-  if(filterPtr.get())
-    *filter = CefContentFilterCppToC::Wrap(filterPtr);
+  // Restore param: filter; type: refptr_same_byref
+  if (filter) {
+    if (filterPtr.get()) {
+      if (filterPtr.get() != filterOrig) {
+        *filter = CefContentFilterCppToC::Wrap(filterPtr);
+      }
+    } else {
+      *filter = NULL;
+    }
+  }
 }

+
 int CEF_CALLBACK request_handler_on_protocol_execution(
    struct _cef_request_handler_t* self, cef_browser_t* browser,
    const cef_string_t* url, int* allowOSExecution)
 {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: browser; type: refptr_diff
  DCHECK(browser);
+  if (!browser)
+    return 0;
+  // Verify param: url; type: string_byref_const
  DCHECK(url);
+  if (!url)
+    return 0;
+  // Verify param: allowOSExecution; type: bool_byref
  DCHECK(allowOSExecution);
-  if (!self || !browser || !url || !allowOSExecution)
+  if (!allowOSExecution)
    return 0;

-  bool allowExec = *allowOSExecution?true:false;
-  int rv = CefRequestHandlerCppToC::Get(self)->OnProtocolExecution(
-      CefBrowserCToCpp::Wrap(browser), CefString(url), allowExec);
-  *allowOSExecution = allowExec;
+  // Translate param: allowOSExecution; type: bool_byref
+  bool allowOSExecutionBool = (
+      allowOSExecution && *allowOSExecution)?true:false;

-  return rv;
+  // Execute
+  bool _retval = CefRequestHandlerCppToC::Get(self)->OnProtocolExecution(
+      CefBrowserCToCpp::Wrap(browser),
+      CefString(url),
+      allowOSExecutionBool);
+
+  // Restore param: allowOSExecution; type: bool_byref
+  if (allowOSExecution)
+    *allowOSExecution = allowOSExecutionBool?true:false;
+
+  // Return type: bool
+  return _retval;
 }

+
 int CEF_CALLBACK request_handler_get_download_handler(
    struct _cef_request_handler_t* self, cef_browser_t* browser,
    const cef_string_t* mimeType, const cef_string_t* fileName,
    int64 contentLength, struct _cef_download_handler_t** handler)
 {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: browser; type: refptr_diff
  DCHECK(browser);
+  if (!browser)
+    return 0;
+  // Verify param: mimeType; type: string_byref_const
  DCHECK(mimeType);
+  if (!mimeType)
+    return 0;
+  // Verify param: fileName; type: string_byref_const
  DCHECK(fileName);
+  if (!fileName)
+    return 0;
+  // Verify param: handler; type: refptr_same_byref
  DCHECK(handler);
-  if (!self || !browser || !mimeType || !fileName || !handler)
+  if (!handler)
    return 0;

-  CefRefPtr<CefDownloadHandler> downloadPtr;
+  // Translate param: handler; type: refptr_same_byref
+  CefRefPtr<CefDownloadHandler> handlerPtr;
+  if (handler && *handler)
+    handlerPtr = CefDownloadHandlerCppToC::Unwrap(*handler);
+  CefDownloadHandler* handlerOrig = handlerPtr.get();

-  int rv = CefRequestHandlerCppToC::Get(self)->GetDownloadHandler(
-      CefBrowserCToCpp::Wrap(browser), CefString(mimeType), CefString(fileName),
-      contentLength, downloadPtr);
+  // Execute
+  bool _retval = CefRequestHandlerCppToC::Get(self)->GetDownloadHandler(
+      CefBrowserCToCpp::Wrap(browser),
+      CefString(mimeType),
+      CefString(fileName),
+      contentLength,
+      handlerPtr);

-  if(downloadPtr.get())
-    *handler = CefDownloadHandlerCppToC::Wrap(downloadPtr);
+  // Restore param: handler; type: refptr_same_byref
+  if (handler) {
+    if (handlerPtr.get()) {
+      if (handlerPtr.get() != handlerOrig) {
+        *handler = CefDownloadHandlerCppToC::Wrap(handlerPtr);
+      }
+    } else {
+      *handler = NULL;
+    }
+  }

-  return rv;
+  // Return type: bool
+  return _retval;
 }

+
 int CEF_CALLBACK request_handler_get_auth_credentials(
    struct _cef_request_handler_t* self, cef_browser_t* browser, int isProxy,
    const cef_string_t* host, int port, const cef_string_t* realm,
    const cef_string_t* scheme, cef_string_t* username,
    cef_string_t* password)
 {
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
  DCHECK(self);
+  if (!self)
+    return 0;
+  // Verify param: browser; type: refptr_diff
  DCHECK(browser);
+  if (!browser)
+    return 0;
+  // Verify param: host; type: string_byref_const
  DCHECK(host);
+  if (!host)
+    return 0;
+  // Verify param: realm; type: string_byref_const
  DCHECK(realm);
+  if (!realm)
+    return 0;
+  // Verify param: scheme; type: string_byref_const
  DCHECK(scheme);
+  if (!scheme)
+    return 0;
+  // Verify param: username; type: string_byref
  DCHECK(username);
+  if (!username)
+    return 0;
+  // Verify param: password; type: string_byref
  DCHECK(password);
-  if (!self || !browser || !host || !realm || !scheme || !username || !password)
+  if (!password)
    return 0;

+  // Translate param: username; type: string_byref
  CefString usernameStr(username);
+  // Translate param: password; type: string_byref
  CefString passwordStr(password);
-  return CefRequestHandlerCppToC::Get(self)->GetAuthCredentials(
-      CefBrowserCToCpp::Wrap(browser), (isProxy ? true : false),
-      CefString(host), port, CefString(realm), CefString(scheme), usernameStr,
+
+  // Execute
+  bool _retval = CefRequestHandlerCppToC::Get(self)->GetAuthCredentials(
+      CefBrowserCToCpp::Wrap(browser),
+      isProxy?true:false,
+      CefString(host),
+      port,
+      CefString(realm),
+      CefString(scheme),
+      usernameStr,
      passwordStr);
+
+  // Return type: bool
+  return _retval;
 }


+
 // CONSTRUCTOR - Do not edit by hand.

 CefRequestHandlerCppToC::CefRequestHandlerCppToC(CefRequestHandler* cls)