From e79d6bf79989c66e2f77019c2d2bf9a9dd46b04f Mon Sep 17 00:00:00 2001 From: cztomczak Date: Sat, 14 May 2016 11:07:18 +0200 Subject: [PATCH] Remove CEF 1 deprecated files. Issue #106. --- cefpython/cookie_cef1.pyx | 326 ------------------ cefpython/cython_includes/cef_cookie_cef1.pxd | 40 --- .../cython_includes/cef_request_cef1.pxd | 59 ---- .../cython_includes/cef_response_cef1.pxd | 22 -- cefpython/cython_includes/cef_types_cef1.pxd | 162 --------- .../cef_web_urlrequest_cef1.pxd | 16 - .../cef_web_urlrequest_static_cef1.pxd | 12 - .../cython_includes/http_authentication.pxd | 16 - .../web_request_client_cef1.pxd | 9 - cefpython/display_handler_cef1.pyx | 157 --------- cefpython/http_authentication_win.pyx | 18 - cefpython/javascript_callback_cef1.pyx | 123 ------- cefpython/keyboard_handler_cef1.pyx | 42 --- cefpython/lifespan_handler_cef1.pyx | 64 ---- cefpython/load_handler_cef1.pyx | 69 ---- cefpython/network_error_cef1.pyx | 54 --- cefpython/paint_buffer_cef1.pyx | 50 --- cefpython/python_callback_cef1.pyx | 32 -- cefpython/render_handler_cef1.pyx | 169 --------- cefpython/request_cef1.pyx | 208 ----------- cefpython/request_handler_cef1.pyx | 271 --------------- cefpython/response_cef1.pyx | 102 ------ cefpython/v8context_handler_cef1.pyx | 172 --------- cefpython/v8function_handler_cef1.pyx | 89 ----- cefpython/v8utils_cef1.pyx | 223 ------------ cefpython/web_request_cef1.pyx | 209 ----------- cefpython/window_info_cef1.pyx | 105 ------ 27 files changed, 2819 deletions(-) delete mode 100644 cefpython/cookie_cef1.pyx delete mode 100644 cefpython/cython_includes/cef_cookie_cef1.pxd delete mode 100644 cefpython/cython_includes/cef_request_cef1.pxd delete mode 100644 cefpython/cython_includes/cef_response_cef1.pxd delete mode 100644 cefpython/cython_includes/cef_types_cef1.pxd delete mode 100644 cefpython/cython_includes/cef_web_urlrequest_cef1.pxd delete mode 100644 cefpython/cython_includes/cef_web_urlrequest_static_cef1.pxd delete mode 100644 cefpython/cython_includes/http_authentication.pxd delete mode 100644 cefpython/cython_includes/web_request_client_cef1.pxd delete mode 100644 cefpython/display_handler_cef1.pyx delete mode 100644 cefpython/http_authentication_win.pyx delete mode 100644 cefpython/javascript_callback_cef1.pyx delete mode 100644 cefpython/keyboard_handler_cef1.pyx delete mode 100644 cefpython/lifespan_handler_cef1.pyx delete mode 100644 cefpython/load_handler_cef1.pyx delete mode 100644 cefpython/network_error_cef1.pyx delete mode 100644 cefpython/paint_buffer_cef1.pyx delete mode 100644 cefpython/python_callback_cef1.pyx delete mode 100644 cefpython/render_handler_cef1.pyx delete mode 100644 cefpython/request_cef1.pyx delete mode 100644 cefpython/request_handler_cef1.pyx delete mode 100644 cefpython/response_cef1.pyx delete mode 100644 cefpython/v8context_handler_cef1.pyx delete mode 100644 cefpython/v8function_handler_cef1.pyx delete mode 100644 cefpython/v8utils_cef1.pyx delete mode 100644 cefpython/web_request_cef1.pyx delete mode 100644 cefpython/window_info_cef1.pyx diff --git a/cefpython/cookie_cef1.pyx b/cefpython/cookie_cef1.pyx deleted file mode 100644 index 5480b6c7..00000000 --- a/cefpython/cookie_cef1.pyx +++ /dev/null @@ -1,326 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -# ------------------------------------------------------------------------------ -# Tests -# ------------------------------------------------------------------------------ - -#cdef Cookie cookie = Cookie() -#cookie.SetName("asd1") -#print("cookie.cefCookie: %s" % cookie.cefCookie) -#print("cookie.GetName(): %s" % cookie.GetName()) -#print("cookie.GetCreation(): %s" % cookie.GetCreation()) -#cookie.SetCreation(datetime.datetime(2013,5,23)) -#print("cookie.GetCreation(): %s" % cookie.GetCreation()) -#print("cookie: %s" % cookie.Get()) - -# ------------------------------------------------------------------------------ -# Globals -# ------------------------------------------------------------------------------ - -cdef PyCookieManager g_globalCookieManager = None -# See StoreUserCookieVisitor(). -cdef object g_userCookieVisitors = weakref.WeakValueDictionary() -cdef int g_userCookieVisitorMaxId = 0 - -# ------------------------------------------------------------------------------ -# Cookie -# ------------------------------------------------------------------------------ - -ctypedef Cookie PyCookie - -cdef PyCookie CreatePyCookie(CefCookie cefCookie): - cdef PyCookie pyCookie = Cookie() - pyCookie.cefCookie = cefCookie - return pyCookie - -cdef class Cookie: - cdef CefCookie cefCookie - - cpdef py_void Set(self, dict cookie): - for key in cookie: - if key == "name": - self.SetName(cookie[key]) - elif key == "value": - self.SetValue(cookie[key]) - elif key == "domain": - self.SetDomain(cookie[key]) - elif key == "path": - self.SetPath(cookie[key]) - elif key == "secure": - self.SetSecure(cookie[key]) - elif key == "httpOnly": - self.SetHttpOnly(cookie[key]) - elif key == "creation": - self.SetCreation(cookie[key]) - elif key == "lastAccess": - self.SetLastAccess(cookie[key]) - elif key == "hasExpires": - self.SetHasExpires(cookie[key]) - elif key == "expires": - self.SetExpires(cookie[key]) - else: - raise Exception("Invalid key: %s" % key) - - cpdef dict Get(self): - return { - "name": self.GetName(), - "value": self.GetValue(), - "domain": self.GetDomain(), - "path": self.GetPath(), - "secure": self.GetSecure(), - "httpOnly": self.GetHttpOnly(), - "creation": self.GetCreation(), - "lastAccess": self.GetLastAccess(), - "hasExpires": self.GetHasExpires(), - "expires": self.GetExpires(), - } - - cpdef py_void SetName(self, py_string name): - # This works: - # | CefString(&self.cefCookie.name).FromString(name) - # This does not work: - # | cdef CefString cefString = CefString(&self.cefCookie.name) - # | PyToCefString(name, cefString) - # Because it's a Copy Constructor, it does not reference the - # same underlying cef_string_t, instead it copies the value. - # "T a(b)" - direct initialization (not supported by cython) - # "T a = b" - copy initialization - # But this works: - # | cdef CefString* cefString = new CefString(&self.cefCookie.name) - # | PyToCefStringPointer(name, cefString) - # | del cefString - # Solution: use Attach() method to pass reference to cef_string_t. - cdef CefString cefString - cefString.Attach(&self.cefCookie.name, False) - PyToCefString(name, cefString) - - cpdef str GetName(self): - cdef CefString cefString - cefString.Attach(&self.cefCookie.name, False) - return CefToPyString(cefString) - - cpdef py_void SetValue(self, py_string value): - cdef CefString cefString - cefString.Attach(&self.cefCookie.value, False) - PyToCefString(value, cefString) - - cpdef str GetValue(self): - cdef CefString cefString - cefString.Attach(&self.cefCookie.value, False) - return CefToPyString(cefString) - - cpdef py_void SetDomain(self, py_string domain): - cdef CefString cefString - cefString.Attach(&self.cefCookie.domain, False) - PyToCefString(domain, cefString) - - cpdef str GetDomain(self): - cdef CefString cefString - cefString.Attach(&self.cefCookie.domain, False) - return CefToPyString(cefString) - - cpdef py_void SetPath(self, py_string path): - cdef CefString cefString - cefString.Attach(&self.cefCookie.path, False) - PyToCefString(path, cefString) - - cpdef str GetPath(self): - cdef CefString cefString - cefString.Attach(&self.cefCookie.path, False) - return CefToPyString(cefString) - - cpdef py_void SetSecure(self, py_bool secure): - # Need to wrap it with bool() to get rid of the C++ compiler - # warnings: "cefpython.cpp(24740) : warning C4800: 'int' : - # forcing value to bool 'true' or 'false' (performance warning)". - self.cefCookie.secure = bool(secure) - - cpdef py_bool GetSecure(self): - return self.cefCookie.secure - - cpdef py_void SetHttpOnly(self, py_bool httpOnly): - self.cefCookie.httponly = bool(httpOnly) - - cpdef py_bool GetHttpOnly(self): - return self.cefCookie.httponly - - cpdef py_void SetCreation(self, object creation): - DatetimeToCefTimeT(creation, self.cefCookie.creation) - - cpdef object GetCreation(self): - return CefTimeTToDatetime(self.cefCookie.creation) - - cpdef py_void SetLastAccess(self, object lastAccess): - DatetimeToCefTimeT(lastAccess, self.cefCookie.last_access) - - cpdef object GetLastAccess(self): - return CefTimeTToDatetime(self.cefCookie.last_access) - - cpdef py_void SetHasExpires(self, py_bool hasExpires): - self.cefCookie.has_expires = bool(hasExpires) - - cpdef py_bool GetHasExpires(self): - return self.cefCookie.has_expires - - cpdef py_void SetExpires(self, object expires): - DatetimeToCefTimeT(expires, self.cefCookie.expires) - - cpdef object GetExpires(self): - return CefTimeTToDatetime(self.cefCookie.expires) - -# ------------------------------------------------------------------------------ -# CookieManager -# ------------------------------------------------------------------------------ - -class CookieManager: - @staticmethod - def GetGlobalManager(): - global g_globalCookieManager - cdef CefRefPtr[CefCookieManager] cefCookieManager - if not g_globalCookieManager: - cefCookieManager = CefCookieManager_GetGlobalManager() - g_globalCookieManager = CreatePyCookieManager(cefCookieManager) - return g_globalCookieManager - - @staticmethod - def CreateManager(py_string path, py_bool persistSessionCookies=False): - cdef CefRefPtr[CefCookieManager] cefCookieManager - IF CEF_VERSION == 1: - cefCookieManager = CefCookieManager_CreateManager( - PyToCefStringValue(path)) - ELIF CEF_VERSION == 3: - cefCookieManager = CefCookieManager_CreateManager( - PyToCefStringValue(path), bool(persistSessionCookies)) - if cefCookieManager != NULL and cefCookieManager.get(): - return CreatePyCookieManager(cefCookieManager) - return None - -# ------------------------------------------------------------------------------ -# PyCookieManager -# ------------------------------------------------------------------------------ - -cdef PyCookieManager CreatePyCookieManager( - CefRefPtr[CefCookieManager] cefCookieManager): - cdef PyCookieManager pyCookieManager = PyCookieManager() - pyCookieManager.cefCookieManager = cefCookieManager - return pyCookieManager - -cdef class PyCookieManager: - cdef CefRefPtr[CefCookieManager] cefCookieManager - - cpdef py_void SetSupportedSchemes(self, list schemes): - cdef cpp_vector[CefString] schemesVector - for scheme in schemes: - schemesVector.push_back(PyToCefStringValue(scheme)) - self.cefCookieManager.get().SetSupportedSchemes(schemesVector) - - cdef py_void ValidateUserCookieVisitor(self, object userCookieVisitor): - if userCookieVisitor and hasattr(userCookieVisitor, "Visit") and \ - callable(getattr(userCookieVisitor, "Visit")): - return - raise Exception("CookieVisitor object is missing Visit() method") - - cpdef py_bool VisitAllCookies(self, object userCookieVisitor): - self.ValidateUserCookieVisitor(userCookieVisitor) - cdef int cookieVisitorId = StoreUserCookieVisitor(userCookieVisitor) - cdef CefRefPtr[CefCookieVisitor] cefCookieVisitor = ( - new CookieVisitor( - cookieVisitorId)) - return self.cefCookieManager.get().VisitAllCookies( - cefCookieVisitor) - - cpdef py_bool VisitUrlCookies(self, py_string url, - py_bool includeHttpOnly, object userCookieVisitor): - self.ValidateUserCookieVisitor(userCookieVisitor) - cdef int cookieVisitorId = StoreUserCookieVisitor(userCookieVisitor) - cdef CefRefPtr[CefCookieVisitor] cefCookieVisitor = ( - new CookieVisitor( - cookieVisitorId)) - return self.cefCookieManager.get().VisitUrlCookies( - PyToCefStringValue(url), bool(includeHttpOnly), - cefCookieVisitor) - - cpdef py_void SetCookie(self, py_string url, PyCookie cookie): - assert isinstance(cookie, Cookie), "cookie object is invalid" - CefPostTask(TID_IO, NewCefRunnableMethod(self.cefCookieManager.get(), - &cef_cookie_manager_namespace.SetCookie, - PyToCefStringValue(url), cookie.cefCookie)) - - cpdef py_void DeleteCookies(self, py_string url, py_string cookie_name): - CefPostTask(TID_IO, NewCefRunnableMethod(self.cefCookieManager.get(), - &cef_cookie_manager_namespace.DeleteCookies, - PyToCefStringValue(url), PyToCefStringValue(cookie_name))) - - cpdef py_bool SetStoragePath(self, py_string path, - py_bool persistSessionCookies=False): - IF CEF_VERSION == 1: - return self.cefCookieManager.get().SetStoragePath( - PyToCefStringValue(path)) - ELIF CEF_VERSION == 3: - return self.cefCookieManager.get().SetStoragePath( - PyToCefStringValue(path), bool(persistSessionCookies)) - -# ------------------------------------------------------------------------------ -# PyCookieVisitor -# ------------------------------------------------------------------------------ - -cdef int StoreUserCookieVisitor(object userCookieVisitor) except *: - global g_userCookieVisitorMaxId - global g_userCookieVisitors - g_userCookieVisitorMaxId += 1 - g_userCookieVisitors[g_userCookieVisitorMaxId] = userCookieVisitor - return g_userCookieVisitorMaxId - -cdef PyCookieVisitor GetPyCookieVisitor(int cookieVisitorId): - global g_userCookieVisitors - cdef object userCookieVisitor - cdef PyCookieVisitor pyCookieVisitor - if cookieVisitorId in g_userCookieVisitors: - userCookieVisitor = g_userCookieVisitors[cookieVisitorId] - pyCookieVisitor = PyCookieVisitor(userCookieVisitor) - return pyCookieVisitor - -cdef class PyCookieVisitor: - cdef object userCookieVisitor - - def __init__(self, object userCookieVisitor): - self.userCookieVisitor = userCookieVisitor - - cdef object GetCallback(self, str funcName): - if self.userCookieVisitor and ( - hasattr(self.userCookieVisitor, funcName) and ( - callable(getattr(self.userCookieVisitor, funcName)))): - return getattr(self.userCookieVisitor, funcName) - -# ------------------------------------------------------------------------------ -# C++ CookieVisitor -# ------------------------------------------------------------------------------ - -cdef public cpp_bool CookieVisitor_Visit( - int cookieVisitorId, - const CefCookie& cookie, - int count, - int total, - cpp_bool& deleteCookie - ) except * with gil: - cdef PyCookieVisitor pyCookieVisitor - cdef object callback - cdef py_bool ret - cdef PyCookie pyCookie - cdef list pyDeleteCookie = [False] - try: - assert IsThread(TID_IO), "Must be called on the IO thread" - pyCookieVisitor = GetPyCookieVisitor(cookieVisitorId) - pyCookie = CreatePyCookie(cookie) - if pyCookieVisitor: - callback = pyCookieVisitor.GetCallback("Visit") - if callback: - ret = callback(pyCookie, count, total, pyDeleteCookie) - (&deleteCookie)[0] = bool(pyDeleteCookie[0]) - return bool(ret) - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/cython_includes/cef_cookie_cef1.pxd b/cefpython/cython_includes/cef_cookie_cef1.pxd deleted file mode 100644 index 5dc31468..00000000 --- a/cefpython/cython_includes/cef_cookie_cef1.pxd +++ /dev/null @@ -1,40 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from cef_string cimport cef_string_t -from libcpp cimport bool as cpp_bool -from cef_time cimport cef_time_t -from libcpp.vector cimport vector as cpp_vector -from cef_string cimport CefString -from cef_ptr cimport CefRefPtr - -cdef extern from "include/cef_cookie.h": - ctypedef struct CefCookie: - cef_string_t name - cef_string_t value - cef_string_t domain - cef_string_t path - cpp_bool secure - cpp_bool httponly - cef_time_t creation - cef_time_t last_access - cpp_bool has_expires - cef_time_t expires - cdef CefRefPtr[CefCookieManager] CefCookieManager_GetGlobalManager \ - "CefCookieManager::GetGlobalManager"() - cdef CefRefPtr[CefCookieManager] CefCookieManager_CreateManager \ - "CefCookieManager::CreateManager"(const CefString& path) - cdef cppclass CefCookieManager: - void SetSupportedSchemes(const cpp_vector[CefString]& schemes) - cpp_bool VisitAllCookies(CefRefPtr[CefCookieVisitor] visitor) - cpp_bool VisitUrlCookies(const CefString& url, - cpp_bool includeHttpOnly, - CefRefPtr[CefCookieVisitor] visitor) - cpp_bool SetCookie(const CefString& url, const CefCookie& cookie) - cpp_bool DeleteCookies(const CefString& url, - const CefString& cookie_name) - cpp_bool SetStoragePath(const CefString& path) - - cdef cppclass CefCookieVisitor: - pass diff --git a/cefpython/cython_includes/cef_request_cef1.pxd b/cefpython/cython_includes/cef_request_cef1.pxd deleted file mode 100644 index 2eafece3..00000000 --- a/cefpython/cython_includes/cef_request_cef1.pxd +++ /dev/null @@ -1,59 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from cef_base cimport CefBase -from cef_ptr cimport CefRefPtr -from cef_string cimport CefString -from cef_types cimport cef_weburlrequest_flags_t, cef_postdataelement_type_t -from libcpp.vector cimport vector as cpp_vector -from libcpp cimport bool as cpp_bool -from multimap cimport multimap as cpp_multimap - -cdef extern from "include/cef_request.h": - # This types won't be visible in pyx files! - ctypedef cpp_multimap[CefString, CefString] HeaderMap - ctypedef cef_weburlrequest_flags_t CefRequestFlags - - cdef CefRefPtr[CefRequest] CefRequest_Create "CefRequest::CreateRequest"() - cdef cppclass CefRequest(CefBase): - CefString GetURL() - void SetURL(CefString& url) - CefString GetMethod() - void SetMethod(CefString& method) - CefRefPtr[CefPostData] GetPostData() - void SetPostData(CefRefPtr[CefPostData] postData) - void GetHeaderMap(HeaderMap& headerMap) - void SetHeaderMap(HeaderMap& headerMap) - void Set(CefString& url, - CefString& method, - CefRefPtr[CefPostData] postData, - HeaderMap& headerMap) - CefRequestFlags GetFlags() - void SetFlags(CefRequestFlags flags) - CefString GetFirstPartyForCookies() - void SetFirstPartyForCookies(CefString& url) - - ctypedef cpp_vector[CefRefPtr[CefPostDataElement]] ElementVector - - cdef CefRefPtr[CefPostData] CefPostData_Create \ - "CefPostData::CreatePostData"() - cdef cppclass CefPostData(CefBase): - size_t GetElementCount() - void GetElements(ElementVector& elements) - cpp_bool RemoveElement(CefRefPtr[CefPostDataElement] element) - cpp_bool AddElement(CefRefPtr[CefPostDataElement] element) - void RemoveElements() - - ctypedef cef_postdataelement_type_t ElementType - - cdef CefRefPtr[CefPostDataElement] CefPostDataElement_Create \ - "CefPostDataElement::CreatePostDataElement"() - cdef cppclass CefPostDataElement(CefBase): - void SetToEmpty() - void SetToFile(CefString& fileName) - void SetToBytes(size_t size, void* bytes) - ElementType GetType() - CefString GetFile() - size_t GetBytesCount() - size_t GetBytes(size_t size, void* bytes) diff --git a/cefpython/cython_includes/cef_response_cef1.pxd b/cefpython/cython_includes/cef_response_cef1.pxd deleted file mode 100644 index affa85d6..00000000 --- a/cefpython/cython_includes/cef_response_cef1.pxd +++ /dev/null @@ -1,22 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from cef_base cimport CefBase -from cef_string cimport CefString -from multimap cimport multimap as cpp_multimap - -cdef extern from "include/cef_response.h": - ctypedef cpp_multimap[CefString, CefString] CefResponseHeaderMap - - cdef cppclass CefResponse(CefBase): - int GetStatus() - void SetStatus(int status) - CefString GetStatusText() - void SetStatusText(CefString& statusText) - CefString GetMimeType() - void SetMimeType(CefString& mimeType) - CefString GetHeader(CefString& name) - void GetHeaderMap(CefResponseHeaderMap& headerMap) - void SetHeaderMap(CefResponseHeaderMap& headerMap) - diff --git a/cefpython/cython_includes/cef_types_cef1.pxd b/cefpython/cython_includes/cef_types_cef1.pxd deleted file mode 100644 index afb086be..00000000 --- a/cefpython/cython_includes/cef_types_cef1.pxd +++ /dev/null @@ -1,162 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -include "compile_time_constants.pxi" -from libcpp cimport bool as cpp_bool -from libc.stddef cimport wchar_t - -cdef extern from "include/internal/cef_types.h": - cdef enum cef_log_severity_t: - LOGSEVERITY_VERBOSE = -1, - LOGSEVERITY_INFO, - LOGSEVERITY_WARNING, - LOGSEVERITY_ERROR, - LOGSEVERITY_ERROR_REPORT, - LOGSEVERITY_DISABLE = 99, - - cdef enum cef_thread_id_t: - TID_UI = 0, - TID_IO = 1, - TID_FILE = 2, - - ctypedef long long int64 - ctypedef unsigned int uint32 - ctypedef int int32 - - IF UNAME_SYSNAME == "Windows": - ctypedef wchar_t char16 - ELSE: - ctypedef unsigned short char16 - - # LoadHandler > OnLoadError - ErrorCode. - # Some of the constants are missing, for an up to date list see: - # http://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_error_list.h?view=markup - cdef enum cef_handler_errorcode_t: - ERR_NONE = 0, - ERR_FAILED = -2, - ERR_ABORTED = -3, - ERR_INVALID_ARGUMENT = -4, - ERR_INVALID_HANDLE = -5, - ERR_FILE_NOT_FOUND = -6, - ERR_TIMED_OUT = -7, - ERR_FILE_TOO_BIG = -8, - ERR_UNEXPECTED = -9, - ERR_ACCESS_DENIED = -10, - ERR_NOT_IMPLEMENTED = -11, - ERR_CONNECTION_CLOSED = -100, - ERR_CONNECTION_RESET = -101, - ERR_CONNECTION_REFUSED = -102, - ERR_CONNECTION_ABORTED = -103, - ERR_CONNECTION_FAILED = -104, - ERR_NAME_NOT_RESOLVED = -105, - ERR_INTERNET_DISCONNECTED = -106, - ERR_SSL_PROTOCOL_ERROR = -107, - ERR_ADDRESS_INVALID = -108, - ERR_ADDRESS_UNREACHABLE = -109, - ERR_SSL_CLIENT_AUTH_CERT_NEEDED = -110, - ERR_TUNNEL_CONNECTION_FAILED = -111, - ERR_NO_SSL_VERSIONS_ENABLED = -112, - ERR_SSL_VERSION_OR_CIPHER_MISMATCH = -113, - ERR_SSL_RENEGOTIATION_REQUESTED = -114, - ERR_CERT_COMMON_NAME_INVALID = -200, - ERR_CERT_DATE_INVALID = -201, - ERR_CERT_AUTHORITY_INVALID = -202, - ERR_CERT_CONTAINS_ERRORS = -203, - ERR_CERT_NO_REVOCATION_MECHANISM = -204, - ERR_CERT_UNABLE_TO_CHECK_REVOCATION = -205, - ERR_CERT_REVOKED = -206, - ERR_CERT_INVALID = -207, - ERR_CERT_END = -208, - ERR_INVALID_URL = -300, - ERR_DISALLOWED_URL_SCHEME = -301, - ERR_UNKNOWN_URL_SCHEME = -302, - ERR_TOO_MANY_REDIRECTS = -310, - ERR_UNSAFE_REDIRECT = -311, - ERR_UNSAFE_PORT = -312, - ERR_INVALID_RESPONSE = -320, - ERR_INVALID_CHUNKED_ENCODING = -321, - ERR_METHOD_NOT_SUPPORTED = -322, - ERR_UNEXPECTED_PROXY_AUTH = -323, - ERR_EMPTY_RESPONSE = -324, - ERR_RESPONSE_HEADERS_TOO_BIG = -325, - ERR_CACHE_MISS = -400, - ERR_INSECURE_RESPONSE = -501, - - # KeyboardHandler > OnKeyEvent - KeyEventType. - cdef enum cef_handler_keyevent_type_t: - KEYEVENT_RAWKEYDOWN = 0, - KEYEVENT_KEYDOWN, - KEYEVENT_KEYUP, - KEYEVENT_CHAR - cdef enum cef_handler_keyevent_modifiers_t: - KEY_SHIFT = 1 << 0, - KEY_CTRL = 1 << 1, - KEY_ALT = 1 << 2, - KEY_META = 1 << 3, - KEY_KEYPAD = 1 << 4, # Only used on Mac OS-X - - # V8 api - cdef enum cef_v8_propertyattribute_t: - V8_PROPERTY_ATTRIBUTE_NONE = 0, # Writeable, Enumerable, - # Configurable - V8_PROPERTY_ATTRIBUTE_READONLY = 1 << 0, # Not writeable - V8_PROPERTY_ATTRIBUTE_DONTENUM = 1 << 1, # Not enumerable - V8_PROPERTY_ATTRIBUTE_DONTDELETE = 1 << 2 # Not configurable - - # CefRequestHandler > OnBeforeBrowse > NavType - cdef enum cef_handler_navtype_t: - NAVTYPE_LINKCLICKED = 0, - NAVTYPE_FORMSUBMITTED, - NAVTYPE_BACKFORWARD, - NAVTYPE_RELOAD, - NAVTYPE_FORMRESUBMITTED, - NAVTYPE_OTHER, - NAVTYPE_LINKDROPPED - - # CefDisplayHandler > StatusType - cdef enum cef_handler_statustype_t: - STATUSTYPE_TEXT = 0, - STATUSTYPE_MOUSEOVER_URL, - STATUSTYPE_KEYBOARD_FOCUS_URL, - - # Browser > GetImage(), RenderHandler > OnPaint(). - ctypedef enum cef_paint_element_type_t: - PET_VIEW = 0, - PET_POPUP, - - # Browser > SendKeyEvent(). - ctypedef enum cef_key_type_t: - KT_KEYUP = 0, - KT_KEYDOWN, - KT_CHAR, - - # Browser > SendMouseClickEvent(). - ctypedef enum cef_mouse_button_type_t: - MBT_LEFT = 0, - MBT_MIDDLE, - MBT_RIGHT, - - # CefRequest - enum cef_postdataelement_type_t: - PDE_TYPE_EMPTY = 0, - PDE_TYPE_BYTES, - PDE_TYPE_FILE, - - enum cef_weburlrequest_flags_t: - WUR_FLAG_NONE = 0, - WUR_FLAG_SKIP_CACHE = 0x1, - WUR_FLAG_ALLOW_CACHED_CREDENTIALS = 0x2, - WUR_FLAG_ALLOW_COOKIES = 0x4, - WUR_FLAG_REPORT_UPLOAD_PROGRESS = 0x8, - WUR_FLAG_REPORT_LOAD_TIMING = 0x10, - WUR_FLAG_REPORT_RAW_HEADERS = 0x20 - - enum cef_weburlrequest_state_t: - WUR_STATE_UNSENT = 0, - WUR_STATE_STARTED = 1, - WUR_STATE_HEADERS_RECEIVED = 2, - WUR_STATE_LOADING = 3, - WUR_STATE_DONE = 4, - WUR_STATE_ERROR = 5, - WUR_STATE_ABORT = 6, diff --git a/cefpython/cython_includes/cef_web_urlrequest_cef1.pxd b/cefpython/cython_includes/cef_web_urlrequest_cef1.pxd deleted file mode 100644 index 3b38e414..00000000 --- a/cefpython/cython_includes/cef_web_urlrequest_cef1.pxd +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from cef_base cimport CefBase -from cef_ptr cimport CefRefPtr -cimport cef_types -from cef_request_cef1 cimport CefRequest - -cdef extern from "include/cef_web_urlrequest.h": - cdef cppclass CefWebURLRequest(CefBase): - void Cancel() - cef_types.cef_weburlrequest_state_t GetState() - - cdef cppclass CefWebURLRequestClient(CefBase): - pass diff --git a/cefpython/cython_includes/cef_web_urlrequest_static_cef1.pxd b/cefpython/cython_includes/cef_web_urlrequest_static_cef1.pxd deleted file mode 100644 index db981dcf..00000000 --- a/cefpython/cython_includes/cef_web_urlrequest_static_cef1.pxd +++ /dev/null @@ -1,12 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from cef_ptr cimport CefRefPtr -from cef_web_urlrequest cimport CefWebURLRequest, CefWebURLRequestClient -from cef_request_cef1 cimport CefRequest - -cdef extern from "include/cef_web_urlrequest.h" namespace "CefWebURLRequest": - cdef CefRefPtr[CefWebURLRequest] CreateWebURLRequest( - CefRefPtr[CefRequest] request, - CefRefPtr[CefWebURLRequestClient] client) diff --git a/cefpython/cython_includes/http_authentication.pxd b/cefpython/cython_includes/http_authentication.pxd deleted file mode 100644 index be5bfcf2..00000000 --- a/cefpython/cython_includes/http_authentication.pxd +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from windows cimport HWND -from libcpp.string cimport string as c_string - -cdef extern from "http_authentication/AuthCredentials.h": - - ctypedef struct AuthCredentialsData: - c_string username - c_string password - -cdef extern from "http_authentication/AuthDialog.h": - - cdef AuthCredentialsData* AuthDialog(HWND parent) nogil diff --git a/cefpython/cython_includes/web_request_client_cef1.pxd b/cefpython/cython_includes/web_request_client_cef1.pxd deleted file mode 100644 index 6769a664..00000000 --- a/cefpython/cython_includes/web_request_client_cef1.pxd +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -from cef_base cimport CefBase - -cdef extern from "client_handler/web_request_client.h": - cdef cppclass WebRequestClient(CefBase): - WebRequestClient(int webRequestId) diff --git a/cefpython/display_handler_cef1.pyx b/cefpython/display_handler_cef1.pyx deleted file mode 100644 index 0fd2df18..00000000 --- a/cefpython/display_handler_cef1.pyx +++ /dev/null @@ -1,157 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -STATUSTYPE_TEXT = cef_types.STATUSTYPE_TEXT -STATUSTYPE_MOUSEOVER_URL = cef_types.STATUSTYPE_MOUSEOVER_URL -STATUSTYPE_KEYBOARD_FOCUS_URL = cef_types.STATUSTYPE_KEYBOARD_FOCUS_URL - -cdef public void DisplayHandler_OnAddressChange( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - CefString& cefURL - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef str pyUrl - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - pyUrl = CefToPyString(cefURL) - callback = pyBrowser.GetClientCallback("OnAddressChange") - if callback: - callback(pyBrowser, pyFrame, pyUrl) - return - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool DisplayHandler_OnConsoleMessage( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefMessage, - CefString& cefSource, - int line - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyMessage - cdef str pySource - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyMessage = CefToPyString(cefMessage) - pySource = CefToPyString(cefSource) - callback = pyBrowser.GetClientCallback("OnConsoleMessage") - if callback: - return bool(callback(pyBrowser, pyMessage, pySource, line)) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void DisplayHandler_OnContentsSizeChange( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - int width, - int height - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - callback = pyBrowser.GetClientCallback("OnContentsSizeChange") - if callback: - callback(pyBrowser, pyFrame, width, height) - return - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void DisplayHandler_OnNavStateChange( - CefRefPtr[CefBrowser] cefBrowser, - cpp_bool canGoBack, - cpp_bool canGoForward - ) except * with gil: - cdef PyBrowser pyBrowser - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("OnNavStateChange") - if callback: - callback(pyBrowser, canGoBack, canGoForward) - return - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void DisplayHandler_OnStatusMessage( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefText, - cef_types.cef_handler_statustype_t statusType - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyText - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyText = CefToPyString(cefText) - callback = pyBrowser.GetClientCallback("OnStatusMessage") - if callback: - callback(pyBrowser, pyText, statusType) - return - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void DisplayHandler_OnTitleChange( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefTitle - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyTitle - cdef object callback - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyTitle = CefToPyString(cefTitle) - callback = pyBrowser.GetClientCallback("OnTitleChange") - if callback: - ret = bool(callback(pyBrowser, pyTitle)) - IF UNAME_SYSNAME == "Windows": - if ret: - WindowUtils.SetTitle(pyBrowser, pyTitle) - WindowUtils.SetIcon(pyBrowser, icon="inherit") - return - else: - IF UNAME_SYSNAME == "Windows": - WindowUtils.SetTitle(pyBrowser, pyTitle) - WindowUtils.SetIcon(pyBrowser, icon="inherit") - return - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool DisplayHandler_OnTooltip( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefText - ) except * with gil: - cdef PyBrowser pyBrowser - cdef list pyText - cdef object callback - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyText = [CefToPyString(cefText)] # In/Out - callback = pyBrowser.GetClientCallback("OnTooltip") - if callback: - ret = callback(pyBrowser, pyText) - PyToCefString(pyText[0], cefText); - return bool(ret) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/http_authentication_win.pyx b/cefpython/http_authentication_win.pyx deleted file mode 100644 index 8cfbfcc9..00000000 --- a/cefpython/http_authentication_win.pyx +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef cpp_bool HttpAuthenticationDialog( - browser, isProxy, host, port, realm, scheme, username, password - ) except *: - cdef AuthCredentialsData* credentialsData - cdef int innerWindowHandle = browser.GetWindowHandle() - cdef HWND hwnd = innerWindowHandle - with nogil: - credentialsData = AuthDialog(hwnd) - if credentialsData == NULL: - return False - else: - username[0] = CharToPyString(credentialsData.username.c_str()) - password[0] = CharToPyString(credentialsData.password.c_str()) - return True diff --git a/cefpython/javascript_callback_cef1.pyx b/cefpython/javascript_callback_cef1.pyx deleted file mode 100644 index 95e2a719..00000000 --- a/cefpython/javascript_callback_cef1.pyx +++ /dev/null @@ -1,123 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef cpp_map[int, CefRefPtr[CefV8Value]] g_v8JavascriptCallbacks -cdef cpp_map[int, CefRefPtr[CefV8Context]] g_v8JavascriptCallbackContexts -# Next callbackId. -cdef int g_v8JavascriptCallbackCount = 0 - -cdef int PutV8JavascriptCallback( - CefRefPtr[CefV8Value] v8Value, - CefRefPtr[CefV8Context] v8Context) except *: - global g_v8JavascriptCallbacks - global g_v8JavascriptCallbackContexts - global g_v8JavascriptCallbackCount - g_v8JavascriptCallbackCount += 1 - cdef int callbackId = g_v8JavascriptCallbackCount - g_v8JavascriptCallbacks[callbackId] = v8Value - g_v8JavascriptCallbackContexts[callbackId] = v8Context - return callbackId - -cdef CefRefPtr[CefV8Value] GetV8JavascriptCallback( - int callbackId) except *: - global g_v8JavascriptCallbacks - if g_v8JavascriptCallbacks.find(callbackId) == g_v8JavascriptCallbacks.end(): - raise Exception("GetV8JavascriptCallback() failed: invalid callbackId: %s" - % callbackId) - return g_v8JavascriptCallbacks[callbackId] - -cdef CefRefPtr[CefV8Context] GetV8JavascriptCallbackContext( - int callbackId) except *: - global g_v8JavascriptCallbackContexts - if g_v8JavascriptCallbackContexts.find(callbackId) == g_v8JavascriptCallbackContexts.end(): - raise Exception("GetV8JavascriptCallbackContext() failed: invalid callbackId: %s" - % callbackId) - return g_v8JavascriptCallbackContexts[callbackId] - -cdef void DelV8JavascriptCallback( - int callbackId) except *: - global g_v8JavascriptCallbacks - global g_v8JavascriptCallbackContexts - g_v8JavascriptCallbacks.erase(callbackId) - g_v8JavascriptCallbackContexts.erase(callbackId) - -cdef class JavascriptCallback: - cdef int callbackId - - def __init__(self, int callbackId): - assert callbackId, "JavascriptCallback.__init__() failed: callbackId is empty" - self.callbackId = callbackId - - def __dealloc__(self): - DelV8JavascriptCallback(self.callbackId) - - def Call(self, *args): - cdef CefRefPtr[CefV8Value] v8Value = GetV8JavascriptCallback(self.callbackId) - cdef CefRefPtr[CefV8Context] v8Context = GetV8JavascriptCallbackContext(self.callbackId) - cdef CefV8ValueList v8Arguments - cdef CefRefPtr[CefV8Value] v8Retval - cdef CefRefPtr[CefV8Exception] v8Exception - cdef CefV8Exception* v8ExceptionPtr - cdef int i - - # Javascript callback may be kept somewhere and later called from - # a different v8 frame context. Need to enter js v8 context before - # calling PyToV8Value(). - - cdef cpp_bool sameContext = v8Context.get().IsSame(cef_v8_static.GetCurrentContext()) - - if not sameContext: - Debug("JavascriptCallback.Call(): inside a different context, calling v8Context.Enter()") - assert v8Context.get().Enter(), "v8Context.Enter() failed" - - for i in range(0, len(args)): - v8Arguments.push_back(PyToV8Value(args[i], v8Context)) - - if not sameContext: - assert v8Context.get().Exit(), "v8Context.Exit() failed" - - v8Retval = v8Value.get().ExecuteFunctionWithContext( - v8Context, - NULL, - v8Arguments) - - cdef int lineNumber - cdef str message - cdef str scriptResourceName - cdef str sourceLine - cdef str stackTrace - - # This exception should be first caught by V8ContextHandler::OnUncaughtException(). - if v8Value.get().HasException(): - v8Exception = v8Value.get().GetException() - v8ExceptionPtr = v8Exception.get() - lineNumber = v8ExceptionPtr.GetLineNumber() - message = CefToPyString(v8ExceptionPtr.GetMessage()) - scriptResourceName = CefToPyString(v8ExceptionPtr.GetScriptResourceName()) - sourceLine = CefToPyString(v8ExceptionPtr.GetSourceLine()) - stackTrace = FormatJavascriptStackTrace(GetJavascriptStackTrace(100)) - - # TODO: throw exceptions according to execution context (Issue 11), - # TODO: should we call v8ExceptionPtr.ClearException()? What if python - # code does try: except: to catch the exception below, if it's catched then - # js should execute further, like it never happened, and is ClearException() - # for that? - - raise Exception("JavascriptCallback.Call() failed: javascript exception:\n" - "%s.\nOn line %s in %s.\n" - "Source of that line: %s\n\n%s" - % (message, lineNumber, scriptResourceName, sourceLine, stackTrace)) - - if v8Retval == NULL: - raise Exception("JavascriptCallback.Call() failed: ExecuteFunctionWithContext() " - "called incorrectly") - - pyRet = V8ToPyValue(v8Retval, v8Context) - return pyRet - - def GetName(self): - cdef CefRefPtr[CefV8Value] v8Value = GetV8JavascriptCallback(self.callbackId) - cdef CefString cefFuncName - cefFuncName = v8Value.get().GetFunctionName() - return CefToPyString(cefFuncName) diff --git a/cefpython/keyboard_handler_cef1.pyx b/cefpython/keyboard_handler_cef1.pyx deleted file mode 100644 index adcc5178..00000000 --- a/cefpython/keyboard_handler_cef1.pyx +++ /dev/null @@ -1,42 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -KEYEVENT_RAWKEYDOWN = cef_types.KEYEVENT_RAWKEYDOWN -KEYEVENT_KEYDOWN = cef_types.KEYEVENT_KEYDOWN -KEYEVENT_KEYUP = cef_types.KEYEVENT_KEYUP -KEYEVENT_CHAR = cef_types.KEYEVENT_CHAR - -KEY_NONE = 0 -KEY_SHIFT = cef_types.KEY_SHIFT -KEY_CTRL = cef_types.KEY_CTRL -KEY_ALT = cef_types.KEY_ALT -KEY_META = cef_types.KEY_META -KEY_KEYPAD = cef_types.KEY_KEYPAD - -cdef public cpp_bool KeyboardHandler_OnKeyEvent( - CefRefPtr[CefBrowser] cefBrowser, - cef_types.cef_handler_keyevent_type_t eventType, - int code, - int modifiers, - cpp_bool isSystemKey, - cpp_bool isAfterJavascript - ) except * with gil: - cdef PyBrowser pyBrowser - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("OnKeyEvent") - if callback: - return bool(callback( - pyBrowser, - eventType, - code, - modifiers, - isSystemKey, - isAfterJavascript)) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/lifespan_handler_cef1.pyx b/cefpython/lifespan_handler_cef1.pyx deleted file mode 100644 index 8edee66d..00000000 --- a/cefpython/lifespan_handler_cef1.pyx +++ /dev/null @@ -1,64 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef public cpp_bool LifespanHandler_DoClose( - CefRefPtr[CefBrowser] cefBrowser - ) except * with gil: - cdef PyBrowser pyBrowser - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("DoClose") - if callback: - return bool(callback(pyBrowser)) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void LifespanHandler_OnAfterCreated( - CefRefPtr[CefBrowser] cefBrowser - ) except * with gil: - cdef PyBrowser pyBrowser - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - # Popup windows has no mouse/keyboard focus (Issue 14). - pyBrowser.SetFocus(True) - callback = pyBrowser.GetClientCallback("OnAfterCreated") - if callback: - callback(pyBrowser) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void LifespanHandler_OnBeforeClose( - CefRefPtr[CefBrowser] cefBrowser - ) except * with gil: - cdef PyBrowser pyBrowser - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("OnBeforeClose") - if callback: - callback(pyBrowser) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool LifespanHandler_RunModal( - CefRefPtr[CefBrowser] cefBrowser - ) except * with gil: - cdef PyBrowser pyBrowser - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("RunModal") - if callback: - return bool(callback(pyBrowser)) - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/load_handler_cef1.pyx b/cefpython/load_handler_cef1.pyx deleted file mode 100644 index cdefc65b..00000000 --- a/cefpython/load_handler_cef1.pyx +++ /dev/null @@ -1,69 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef public void LoadHandler_OnLoadEnd( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - int httpStatusCode - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - callback = pyBrowser.GetClientCallback("OnLoadEnd") - if callback: - callback(pyBrowser, pyFrame, httpStatusCode) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void LoadHandler_OnLoadStart( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - callback = pyBrowser.GetClientCallback("OnLoadStart") - if callback: - callback(pyBrowser, pyFrame) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool LoadHandler_OnLoadError( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - cef_types.cef_handler_errorcode_t cefErrorCode, - CefString& cefFailedUrl, - CefString& cefErrorText - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef str pyFailedUrl - cdef object callback - cdef list errorText - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - pyFailedUrl = CefToPyString(cefFailedUrl) - callback = pyBrowser.GetClientCallback("OnLoadError") - if callback: - errorText = [""] - ret = callback( - pyBrowser, pyFrame, cefErrorCode, pyFailedUrl, errorText) - if ret: - PyToCefString(errorText[0], cefErrorText) - return bool(ret) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/network_error_cef1.pyx b/cefpython/network_error_cef1.pyx deleted file mode 100644 index 332c2a4d..00000000 --- a/cefpython/network_error_cef1.pyx +++ /dev/null @@ -1,54 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -# Network error constants. -ERR_NONE = 0 -ERR_FAILED = cef_types.ERR_FAILED -ERR_ABORTED = cef_types.ERR_ABORTED -ERR_INVALID_ARGUMENT = cef_types.ERR_INVALID_ARGUMENT -ERR_INVALID_HANDLE = cef_types.ERR_INVALID_HANDLE -ERR_FILE_NOT_FOUND = cef_types.ERR_FILE_NOT_FOUND -ERR_TIMED_OUT = cef_types.ERR_TIMED_OUT -ERR_FILE_TOO_BIG = cef_types.ERR_FILE_TOO_BIG -ERR_UNEXPECTED = cef_types.ERR_UNEXPECTED -ERR_ACCESS_DENIED = cef_types.ERR_ACCESS_DENIED -ERR_NOT_IMPLEMENTED = cef_types.ERR_NOT_IMPLEMENTED -ERR_CONNECTION_CLOSED = cef_types.ERR_CONNECTION_CLOSED -ERR_CONNECTION_RESET = cef_types.ERR_CONNECTION_RESET -ERR_CONNECTION_REFUSED = cef_types.ERR_CONNECTION_REFUSED -ERR_CONNECTION_ABORTED = cef_types.ERR_CONNECTION_ABORTED -ERR_CONNECTION_FAILED = cef_types.ERR_CONNECTION_FAILED -ERR_NAME_NOT_RESOLVED = cef_types.ERR_NAME_NOT_RESOLVED -ERR_INTERNET_DISCONNECTED = cef_types.ERR_INTERNET_DISCONNECTED -ERR_SSL_PROTOCOL_ERROR = cef_types.ERR_SSL_PROTOCOL_ERROR -ERR_ADDRESS_INVALID = cef_types.ERR_ADDRESS_INVALID -ERR_ADDRESS_UNREACHABLE = cef_types.ERR_ADDRESS_UNREACHABLE -ERR_SSL_CLIENT_AUTH_CERT_NEEDED = cef_types.ERR_SSL_CLIENT_AUTH_CERT_NEEDED -ERR_TUNNEL_CONNECTION_FAILED = cef_types.ERR_TUNNEL_CONNECTION_FAILED -ERR_NO_SSL_VERSIONS_ENABLED = cef_types.ERR_NO_SSL_VERSIONS_ENABLED -ERR_SSL_VERSION_OR_CIPHER_MISMATCH = cef_types.ERR_SSL_VERSION_OR_CIPHER_MISMATCH -ERR_SSL_RENEGOTIATION_REQUESTED = cef_types.ERR_SSL_RENEGOTIATION_REQUESTED -ERR_CERT_COMMON_NAME_INVALID = cef_types.ERR_CERT_COMMON_NAME_INVALID -ERR_CERT_DATE_INVALID = cef_types.ERR_CERT_DATE_INVALID -ERR_CERT_AUTHORITY_INVALID = cef_types.ERR_CERT_AUTHORITY_INVALID -ERR_CERT_CONTAINS_ERRORS = cef_types.ERR_CERT_CONTAINS_ERRORS -ERR_CERT_NO_REVOCATION_MECHANISM = cef_types.ERR_CERT_NO_REVOCATION_MECHANISM -ERR_CERT_UNABLE_TO_CHECK_REVOCATION = cef_types.ERR_CERT_UNABLE_TO_CHECK_REVOCATION -ERR_CERT_REVOKED = cef_types.ERR_CERT_REVOKED -ERR_CERT_INVALID = cef_types.ERR_CERT_INVALID -ERR_CERT_END = cef_types.ERR_CERT_END -ERR_INVALID_URL = cef_types.ERR_INVALID_URL -ERR_DISALLOWED_URL_SCHEME = cef_types.ERR_DISALLOWED_URL_SCHEME -ERR_UNKNOWN_URL_SCHEME = cef_types.ERR_UNKNOWN_URL_SCHEME -ERR_TOO_MANY_REDIRECTS = cef_types.ERR_TOO_MANY_REDIRECTS -ERR_UNSAFE_REDIRECT = cef_types.ERR_UNSAFE_REDIRECT -ERR_UNSAFE_PORT = cef_types.ERR_UNSAFE_PORT -ERR_INVALID_RESPONSE = cef_types.ERR_INVALID_RESPONSE -ERR_INVALID_CHUNKED_ENCODING = cef_types.ERR_INVALID_CHUNKED_ENCODING -ERR_METHOD_NOT_SUPPORTED = cef_types.ERR_METHOD_NOT_SUPPORTED -ERR_UNEXPECTED_PROXY_AUTH = cef_types.ERR_UNEXPECTED_PROXY_AUTH -ERR_EMPTY_RESPONSE = cef_types.ERR_EMPTY_RESPONSE -ERR_RESPONSE_HEADERS_TOO_BIG = cef_types.ERR_RESPONSE_HEADERS_TOO_BIG -ERR_CACHE_MISS = cef_types.ERR_CACHE_MISS -ERR_INSECURE_RESPONSE = cef_types.ERR_INSECURE_RESPONSE diff --git a/cefpython/paint_buffer_cef1.pyx b/cefpython/paint_buffer_cef1.pyx deleted file mode 100644 index 9f43b709..00000000 --- a/cefpython/paint_buffer_cef1.pyx +++ /dev/null @@ -1,50 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef PaintBuffer CreatePaintBuffer(void* buffer, int width, int height): - cdef PaintBuffer paintBuffer = PaintBuffer() - paintBuffer.buffer = buffer - paintBuffer.width = width - paintBuffer.height = height - paintBuffer.length = width*height*4 - return paintBuffer - -cdef class PaintBuffer: - cdef void* buffer - cdef int width - cdef int height - cdef Py_ssize_t length - - cpdef long long GetIntPointer(self) except *: - return self.buffer - - cpdef object GetString(self, str mode="bgra", str origin="top-left"): - cdef void* dest - cdef py_bool dest_alloced = False - cdef object ret - - origin = origin.lower() - mode = mode.lower() - assert origin in ("top-left", "bottom-left"), "Invalid origin" - assert mode in ("bgra", "rgba"), "Invalid mode" - - if mode == "rgba": - if not dest_alloced: - dest = malloc(self.length) - dest_alloced = True - SwapBufferFromBgraToRgba(dest, self.buffer, self.width, - self.height) - - if origin == "bottom-left": - if not dest_alloced: - dest = malloc(self.length) - dest_alloced = True - FlipBufferUpsideDown(dest, self.buffer, self.width, self.height) - - if dest_alloced: - ret = (dest)[:self.length] - free(dest) - return ret - else: - return (self.buffer)[:self.length] diff --git a/cefpython/python_callback_cef1.pyx b/cefpython/python_callback_cef1.pyx deleted file mode 100644 index 602d0f4d..00000000 --- a/cefpython/python_callback_cef1.pyx +++ /dev/null @@ -1,32 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef dict g_PythonCallbacks = {} -# Next callbackId. -cdef int g_PythonCallbackCount = 0 - -cpdef int PutPythonCallback( - object pythonCallback - ) except *: - # Called from v8utils.pyx > PyToV8Value(). - global g_PythonCallbacks - global g_PythonCallbackCount - g_PythonCallbackCount += 1 - callbackId = g_PythonCallbackCount - g_PythonCallbacks[callbackId] = pythonCallback - return callbackId - -cpdef object GetPythonCallback(int callbackId): - global g_PythonCallbacks - if callbackId not in g_PythonCallbacks: - raise Exception("GetPythonCallback() failed: invalid callbackId: %s" % callbackId) - return g_PythonCallbacks[callbackId] - -cdef void RemovePythonCallback( - int callbackId - ) except * with gil: - # Called from v8function_handler.h > ~V8FunctionHandler(). - # Added "with gil" as it's called from C++. - global g_PythonCallbacks - del g_PythonCallbacks[callbackId] diff --git a/cefpython/render_handler_cef1.pyx b/cefpython/render_handler_cef1.pyx deleted file mode 100644 index 8fc37103..00000000 --- a/cefpython/render_handler_cef1.pyx +++ /dev/null @@ -1,169 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -# cef_paint_element_type_t, PaintElementType -PET_VIEW = cef_types.PET_VIEW -PET_POPUP = cef_types.PET_POPUP - -cdef public cpp_bool RenderHandler_GetViewRect( - CefRefPtr[CefBrowser] cefBrowser, - CefRect& cefRect - ) except * with gil: - cdef PyBrowser pyBrowser - cdef list pyRect = [] - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("GetViewRect") - if callback: - ret = callback(pyBrowser, pyRect) - if ret: - assert (pyRect and len(pyRect) == 4), "rectangle not provided" - cefRect.x = pyRect[0] - cefRect.y = pyRect[1] - cefRect.width = pyRect[2] - cefRect.height = pyRect[3] - return True - else: - return False - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool RenderHandler_GetScreenRect( - CefRefPtr[CefBrowser] cefBrowser, - CefRect& cefRect - ) except * with gil: - cdef PyBrowser pyBrowser - cdef list pyRect = [] - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("GetScreenRect") - if callback: - ret = callback(pyBrowser, pyRect) - if ret: - assert (pyRect and len(pyRect) == 4), ( - "rectangle not provided or invalid") - cefRect.x = pyRect[0] - cefRect.y = pyRect[1] - cefRect.width = pyRect[2] - cefRect.height = pyRect[3] - return True - else: - return False - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool RenderHandler_GetScreenPoint( - CefRefPtr[CefBrowser] cefBrowser, - int viewX, int viewY, - int& screenX, int& screenY - ) except * with gil: - cdef PyBrowser pyBrowser - cdef list screenCoordinates = [] - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("GetScreenPoint") - if callback: - ret = callback(pyBrowser, viewX, viewY, screenCoordinates) - if ret: - assert (screenCoordinates and len(screenCoordinates) == 2), ( - "screenCoordinates not provided or invalid") - (&screenX)[0] = int(screenCoordinates[0]) - (&screenY)[0] = int(screenCoordinates[1]) - return True - else: - return False - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void RenderHandler_OnPopupShow( - CefRefPtr[CefBrowser] cefBrowser, - cpp_bool show - ) except * with gil: - cdef PyBrowser pyBrowser - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("OnPopupShow") - if callback: - callback(pyBrowser, show) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void RenderHandler_OnPopupSize( - CefRefPtr[CefBrowser] cefBrowser, - CefRect& cefRect - ) except * with gil: - cdef PyBrowser pyBrowser - cdef list pyRect - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("OnPopupSize") - if callback: - pyRect = [cefRect.x, cefRect.y, cefRect.width, cefRect.height] - callback(pyBrowser, pyRect) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void RenderHandler_OnPaint( - CefRefPtr[CefBrowser] cefBrowser, - cef_types.cef_paint_element_type_t paintElementType, - cpp_vector[CefRect]& cefDirtyRects, - void* cefBuffer - ) except * with gil: - cdef PyBrowser pyBrowser - cdef list pyDirtyRects = [] - cdef list pyRect - cdef cpp_vector[CefRect].iterator iterator - cdef CefRect cefRect - cdef PaintBuffer paintBuffer - cdef int width - cdef int height - try: - pyBrowser = GetPyBrowser(cefBrowser) - - iterator = cefDirtyRects.begin() - while iterator != cefDirtyRects.end(): - cefRect = deref(iterator) - pyRect = [cefRect.x, cefRect.y, cefRect.width, cefRect.height] - pyDirtyRects.append(pyRect) - preinc(iterator) - - (width, height) = pyBrowser.GetSize(paintElementType) - paintBuffer = CreatePaintBuffer(cefBuffer, width, height) - - callback = pyBrowser.GetClientCallback("OnPaint") - if callback: - callback(pyBrowser, paintElementType, pyDirtyRects, paintBuffer) - else: - return - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void RenderHandler_OnCursorChange( - CefRefPtr[CefBrowser] cefBrowser, - CefCursorHandle cursor - ) except * with gil: - cdef PyBrowser pyBrowser - try: - pyBrowser = GetPyBrowser(cefBrowser) - callback = pyBrowser.GetClientCallback("OnCursorChange") - if callback: - callback(pyBrowser, cursor) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/request_cef1.pyx b/cefpython/request_cef1.pyx deleted file mode 100644 index e06bcf2a..00000000 --- a/cefpython/request_cef1.pyx +++ /dev/null @@ -1,208 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -class Request: - Flags = { - "None": cef_types.WUR_FLAG_NONE, - "SkipCache": cef_types.WUR_FLAG_SKIP_CACHE, - "AllowCachedCredentials": cef_types.WUR_FLAG_ALLOW_CACHED_CREDENTIALS, - "AllowCookies": cef_types.WUR_FLAG_ALLOW_COOKIES, - "ReportUploadProgress": cef_types.WUR_FLAG_REPORT_UPLOAD_PROGRESS, - "ReportLoadTiming": cef_types.WUR_FLAG_REPORT_LOAD_TIMING, - "ReportRawHeaders": cef_types.WUR_FLAG_REPORT_RAW_HEADERS, - } - - def __init__(self): - # Request object is just a public API wrapper, - # the real Request object is named PyRequest. - raise Exception("Request object cannot be instantiated directly, " - "use static method Request.CreateRequest()") - - @staticmethod - def CreateRequest(): - cdef CefRefPtr[CefRequest] cefRequest = CefRequest_Create() - cdef PyRequest pyRequest = CreatePyRequest(cefRequest) - return pyRequest - -cdef PyRequest CreatePyRequest(CefRefPtr[CefRequest] cefRequest): - # This can't be named "GetPyRequest()" as CefRequest has - # no unique identifier, so each time a different python object - # must be returned. - cdef PyRequest pyRequest = PyRequest() - pyRequest.cefRequest = cefRequest - return pyRequest - -cdef class PyRequest: - cdef CefRefPtr[CefRequest] cefRequest - - cdef CefRefPtr[CefRequest] GetCefRequest(self) except *: - if self.cefRequest != NULL and self.cefRequest.get(): - return self.cefRequest - raise Exception("PyRequest.GetCefRequest() failed: " - "CefRequest was destroyed") - - cpdef str GetUrl(self): - return CefToPyString(self.GetCefRequest().get().GetURL()) - - cpdef py_void SetUrl(self, py_string url): - cdef CefString cefUrl - PyToCefString(url, cefUrl) - self.GetCefRequest().get().SetURL(cefUrl) - - cpdef str GetMethod(self): - return CefToPyString(self.GetCefRequest().get().GetMethod()) - - cpdef py_void SetMethod(self, py_string method): - cdef CefString cefMethod - PyToCefString(method, cefMethod) - self.GetCefRequest().get().SetMethod(cefMethod) - - cpdef object GetPostData(self): - if self.GetMethod() != "POST": - return {} - cdef cpp_vector[CefRefPtr[CefPostDataElement]] elementVector - cdef CefRefPtr[CefPostData] postData = ( - self.GetCefRequest().get().GetPostData()) - if postData.get().GetElementCount() == 0: - return {} - postData.get().GetElements(elementVector) - cdef cpp_vector[CefRefPtr[CefPostDataElement]].iterator iterator = ( - elementVector.begin()) - cdef CefRefPtr[CefPostDataElement] postDataElement - cdef list retMultipart = [] - cdef dict retUrlEncoded = {} - # pyData is really of type "str", but Cython will throw - # an error if we use that type: "Cannot convert 'bytes' - # object to str implicitly. This is not portable to Py3." - cdef object pyData - cdef size_t bytesCount - cdef void* voidData - cdef str pyFile - while iterator != elementVector.end(): - postDataElement = deref(iterator) - if postDataElement.get().GetType() == cef_types.PDE_TYPE_EMPTY: - # May return an empty dict - retUrlEncoded. - pass - elif postDataElement.get().GetType() == cef_types.PDE_TYPE_BYTES: - bytesCount = postDataElement.get().GetBytesCount() - voidData = malloc(bytesCount) - postDataElement.get().GetBytes(bytesCount, voidData) - pyData = VoidPtrToString(voidData, bytesCount) - free(voidData) - if (pyData.startswith('--') or retMultipart): - # Content-Type: multipart/form-data - retMultipart.append(pyData) - else: - # Content-Type: application/x-www-form-urlencoded - retUrlEncoded.update(urlparse.parse_qsl(qs=pyData, - keep_blank_values=True)) - elif postDataElement.get().GetType() == cef_types.PDE_TYPE_FILE: - pyFile = CefToPyString(postDataElement.get().GetFile()) - retMultipart.append("@"+pyFile) - else: - raise Exception("Invalid type of CefPostDataElement") - preinc(iterator) - if retMultipart: - return retMultipart - else: - return retUrlEncoded - - cpdef py_void SetPostData(self, object pyPostData): - cdef CefRefPtr[CefPostData] postData = ( - self.GetCefRequest().get().GetPostData()) - postData.get().RemoveElements() - cdef CefRefPtr[CefPostDataElement] postDataElement - cdef py_string pyElement - cdef CefString sfile - if type(pyPostData) == list: - for pyElement in pyPostData: - if pyElement.startswith('--'): - postDataElement = CefPostDataElement_Create() - postDataElement.get().SetToBytes(len(pyElement), - pyElement) - elif pyElement.startswith('@'): - postDataElement = CefPostDataElement_Create() - PyToCefString(pyElement[1:], sfile) - postDataElement.get().SetToFile(sfile) - elif not pyElement: - postDataElement = CefPostDataElement_Create() - postDataElement.get().SetToEmpty() - else: - raise Exception("Invalid element in postData: %s" % ( - pyElement)) - postData.get().AddElement(postDataElement) - elif type(pyPostData) == dict: - pyElement = urllib.urlencode(pyPostData) - pyElement = str(pyElement) - postDataElement = CefPostDataElement_Create() - postDataElement.get().SetToBytes(len(pyElement), pyElement) - postData.get().AddElement(postDataElement) - else: - raise Exception("Invalid type of postData, only dict|list allowed") - - cpdef dict GetHeaderMap(self): - cdef list headerMultimap = self.GetHeaderMultimap() - cdef dict headerMap = {} - cdef tuple headerTuple - for headerTuple in headerMultimap: - key = headerTuple[0] - value = headerTuple[1] - headerMap[key] = value - return headerMap - - cpdef list GetHeaderMultimap(self): - cdef cpp_multimap[CefString, CefString] cefHeaderMap - self.GetCefRequest().get().GetHeaderMap(cefHeaderMap) - cdef list pyHeaderMultimap = [] - cdef cpp_multimap[CefString, CefString].iterator iterator = ( - cefHeaderMap.begin()) - cdef CefString cefKey - cdef CefString cefValue - cdef str pyKey - cdef str pyValue - while iterator != cefHeaderMap.end(): - cefKey = deref(iterator).first - cefValue = deref(iterator).second - pyKey = CefToPyString(cefKey) - pyValue = CefToPyString(cefValue) - pyHeaderMultimap.append((pyKey, pyValue)) - preinc(iterator) - return pyHeaderMultimap - - cpdef py_void SetHeaderMap(self, dict headerMap): - assert len(headerMap) > 0, "headerMap param is empty" - cpdef list headerMultimap = [] - cdef object key - for key in headerMap: - headerMultimap.append((str(key), str(headerMap[key]))) - self.SetHeaderMultimap(headerMultimap) - - cpdef py_void SetHeaderMultimap(self, list headerMultimap): - assert len(headerMultimap) > 0, "headerMultimap param is empty" - cdef cpp_multimap[CefString, CefString] cefHeaderMap - cdef CefString cefKey - cdef CefString cefValue - cdef cpp_pair[CefString, CefString] pair - cdef tuple headerTuple - for headerTuple in headerMultimap: - PyToCefString(str(headerTuple[0]), cefKey) - PyToCefString(str(headerTuple[1]), cefValue) - pair.first, pair.second = cefKey, cefValue - cefHeaderMap.insert(pair) - self.GetCefRequest().get().SetHeaderMap(cefHeaderMap) - - cpdef int GetFlags(self) except *: - return self.GetCefRequest().get().GetFlags() - - cpdef py_void SetFlags(self, int flags): - self.GetCefRequest().get().SetFlags( - flags) - - cpdef str GetFirstPartyForCookies(self): - return CefToPyString( - self.GetCefRequest().get().GetFirstPartyForCookies()) - - cpdef py_void SetFirstPartyForCookies(self, py_string url): - self.GetCefRequest().get().SetFirstPartyForCookies( - PyToCefStringValue(url)) diff --git a/cefpython/request_handler_cef1.pyx b/cefpython/request_handler_cef1.pyx deleted file mode 100644 index 0415cc3a..00000000 --- a/cefpython/request_handler_cef1.pyx +++ /dev/null @@ -1,271 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -NAVTYPE_LINKCLICKED = cef_types.NAVTYPE_LINKCLICKED -NAVTYPE_FORMSUBMITTED = cef_types.NAVTYPE_FORMSUBMITTED -NAVTYPE_BACKFORWARD = cef_types.NAVTYPE_BACKFORWARD -NAVTYPE_RELOAD = cef_types.NAVTYPE_RELOAD -NAVTYPE_FORMRESUBMITTED = cef_types.NAVTYPE_FORMRESUBMITTED -NAVTYPE_OTHER = cef_types.NAVTYPE_OTHER -NAVTYPE_LINKDROPPED = cef_types.NAVTYPE_LINKDROPPED - -cdef public cpp_bool RequestHandler_OnBeforeBrowse( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - CefRefPtr[CefRequest] cefRequest, - cef_types.cef_handler_navtype_t navType, - cpp_bool isRedirect - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef PyRequest pyRequest - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - pyRequest = CreatePyRequest(cefRequest) - callback = pyBrowser.GetClientCallback("OnBeforeBrowse") - if callback: - return bool(callback( - pyBrowser, pyFrame, pyRequest, navType, isRedirect)) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool RequestHandler_OnBeforeResourceLoad( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefRequest] cefRequest, - CefString& cefRedirectUrl, - CefRefPtr[CefStreamReader]& cefStreamReader, - CefRefPtr[CefResponse] cefResponse, - int loadFlags - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyRequest pyRequest - cdef list pyRedirectUrl - cdef PyStreamReader pyStreamReader - cdef PyResponse pyResponse - cdef object callback - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyRequest = CreatePyRequest(cefRequest) - pyRedirectUrl = [""] - pyStreamReader = PyStreamReader() - pyResponse = CreatePyResponse(cefResponse) - callback = pyBrowser.GetClientCallback("OnBeforeResourceLoad") - if callback: - ret = callback(pyBrowser, pyRequest, pyRedirectUrl, - pyStreamReader, pyResponse, loadFlags) - assert type(pyRedirectUrl) == list - assert type(pyRedirectUrl[0]) == str - if pyRedirectUrl[0]: - PyToCefString(pyRedirectUrl[0], cefRedirectUrl) - if pyStreamReader.HasCefStreamReader(): - cefStreamReader.swap(pyStreamReader.GetCefStreamReader()) - return bool(ret) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void RequestHandler_OnResourceRedirect( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefOldUrl, - CefString& cefNewUrl - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyOldUrl - cdef list pyNewUrl # = [""] pass by reference (out). - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyOldUrl = CefToPyString(cefOldUrl) - pyNewUrl = [CefToPyString(cefNewUrl)] - callback = pyBrowser.GetClientCallback("OnResourceRedirect") - if callback: - callback(pyBrowser, pyOldUrl, pyNewUrl) - if pyNewUrl[0]: - PyToCefString(pyNewUrl[0], cefNewUrl) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void RequestHandler_OnResourceResponse( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefUrl, - CefRefPtr[CefResponse] cefResponse, - CefRefPtr[CefContentFilter]& cefContentFilter - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyUrl - cdef PyResponse pyResponse - cdef PyContentFilter pyContentFilter - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyUrl = CefToPyString(cefUrl) - pyResponse = CreatePyResponse(cefResponse) - pyContentFilter = PyContentFilter() - callback = pyBrowser.GetClientCallback("OnResourceResponse") - if callback: - callback(pyBrowser, pyUrl, pyResponse, pyContentFilter) - if pyContentFilter.HasHandler(): - cefContentFilter.swap(pyContentFilter.GetCefContentFilter()) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool RequestHandler_OnProtocolExecution( - CefRefPtr[CefBrowser] cefBrowser, - CefString& cefUrl, - cpp_bool& cefAllowOSExecution - ) except * with gil: - # TODO: needs testing. - cdef PyBrowser pyBrowser - cdef str pyUrl - cdef list pyAllowOSExecution # = [True] pass by reference (out). - cdef object callback - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyUrl = CefToPyString(cefUrl) - pyAllowOSExecution = [bool(cefAllowOSExecution)] - callback = pyBrowser.GetClientCallback("OnProtocolExecution") - if callback: - ret = callback( - pyBrowser, pyUrl, pyAllowOSExecution) - # Since Cython 0.17.4 assigning a value to an argument - # passed by reference will throw an error, the fix is to - # to use "(&arg)[0] =" instead of "arg =", see this topic: - # https://groups.google.com/forum/#!msg/cython-users/j58Sp3QMrD4/y9vJy9YBi_kJ - # For CefRefPtr you should use swap() method instead. - (&cefAllowOSExecution)[0] = bool(pyAllowOSExecution[0]) - return bool(ret) - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool RequestHandler_GetDownloadHandler( - CefRefPtr[CefBrowser] cefBrowser, - const CefString& cefMimeType, - const CefString& cefFilename, - cef_types.int64 cefContentLength, - CefRefPtr[CefDownloadHandler]& cefDownloadHandler - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyMimeType - cdef str pyFilename - cdef long pyContentLength - cdef object callback - cdef object userDownloadHandler - cdef CefRefPtr[CefDownloadHandler] downloadHandler - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyMimeType = CefToPyString(cefMimeType) - pyFilename = CefToPyString(cefFilename) - pyContentLength = cefContentLength - callback = pyBrowser.GetClientCallback("GetDownloadHandler") - if callback: - userDownloadHandler = callback(pyBrowser, pyMimeType, pyFilename, - pyContentLength) - if userDownloadHandler: - downloadHandler = StoreUserDownloadHandler(userDownloadHandler) - cefDownloadHandler.swap(downloadHandler) - return True - else: - return False - else: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public cpp_bool RequestHandler_GetAuthCredentials( - CefRefPtr[CefBrowser] cefBrowser, - cpp_bool cefIsProxy, - CefString& cefHost, - int cefPort, - CefString& cefRealm, - CefString& cefScheme, - CefString& cefUsername, - CefString& cefPassword - ) except * with gil: - cdef PyBrowser pyBrowser - cdef py_bool pyIsProxy - cdef str pyHost - cdef int pyPort - cdef str pyRealm - cdef str pyScheme - cdef list pyUsername # = [""] pass by reference (out). - cdef list pyPassword - cdef object callback - cdef py_bool ret - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyIsProxy = bool(cefIsProxy) - pyHost = CefToPyString(cefHost) - pyPort = int(cefPort) - pyRealm = CefToPyString(cefRealm) - pyScheme = CefToPyString(cefScheme) - pyUsername = [""] - pyPassword = [""] - callback = pyBrowser.GetClientCallback("GetAuthCredentials") - if callback: - ret = callback( - pyBrowser, - pyIsProxy, pyHost, pyPort, pyRealm, pyScheme, - pyUsername, pyPassword) - if ret: - PyToCefString(pyUsername[0], cefUsername) - PyToCefString(pyPassword[0], cefPassword) - return bool(ret) - else: - # Default implementation. - IF UNAME_SYSNAME == "Windows": - ret = HttpAuthenticationDialog( - pyBrowser, - pyIsProxy, pyHost, pyPort, pyRealm, pyScheme, - pyUsername, pyPassword) - if ret: - PyToCefString(pyUsername[0], cefUsername) - PyToCefString(pyPassword[0], cefPassword) - return bool(ret) - ELSE: - return False - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public CefRefPtr[CefCookieManager] RequestHandler_GetCookieManager( - CefRefPtr[CefBrowser] cefBrowser, - CefString& mainUrl - ) except * with gil: - cdef PyBrowser pyBrowser - cdef str pyMainUrl - cdef object callback - cdef PyCookieManager ret - try: - assert IsThread(TID_IO), "Must be called on the IO thread" - pyBrowser = GetPyBrowser(cefBrowser) - pyMainUrl = CefToPyString(mainUrl) - callback = pyBrowser.GetClientCallback("GetCookieManager") - if callback: - ret = callback(pyBrowser, pyMainUrl) - if ret: - if isinstance(ret, PyCookieManager): - return ret.cefCookieManager - else: - raise Exception("Expected CookieManager object") - return NULL - else: - return NULL - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/response_cef1.pyx b/cefpython/response_cef1.pyx deleted file mode 100644 index fd7ee7ee..00000000 --- a/cefpython/response_cef1.pyx +++ /dev/null @@ -1,102 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef PyResponse CreatePyResponse(CefRefPtr[CefResponse] cefResponse): - cdef PyResponse pyResponse = PyResponse() - pyResponse.cefResponse = cefResponse - return pyResponse - -cdef class PyResponse: - cdef CefRefPtr[CefResponse] cefResponse - - cdef CefRefPtr[CefResponse] GetCefResponse(self - ) except *: - if self.cefResponse != NULL and self.cefResponse.get(): - return self.cefResponse - raise Exception("CefResponse was destroyed, you cannot use this object anymore") - - cpdef int GetStatus(self) except *: - return self.GetCefResponse().get().GetStatus() - - cpdef py_void SetStatus(self, int status): - assert type(status) == int, ("Response.SetStatus() failed: status param is not an int") - self.GetCefResponse().get().SetStatus(status) - - cpdef str GetStatusText(self): - return CefToPyString(self.GetCefResponse().get().GetStatusText()) - - cpdef py_void SetStatusText(self, py_string statusText): - assert type(statusText) in (str, unicode, bytes), ( - "Response.SetStatusText() failed: statusText param is not a string") - cdef CefString cefStatusText - PyToCefString(statusText, cefStatusText) - self.GetCefResponse().get().SetStatusText(cefStatusText) - - cpdef str GetMimeType(self): - return CefToPyString(self.GetCefResponse().get().GetMimeType()) - - cpdef py_void SetMimeType(self, py_string mimeType): - assert type(mimeType) in (str, unicode, bytes), ( - "Response.SetMimeType() failed: mimeType param is not a string") - cdef CefString cefMimeType - PyToCefString(mimeType, cefMimeType) - self.GetCefResponse().get().SetMimeType(cefMimeType) - - cpdef str GetHeader(self, py_string name): - assert type(name) in (str, unicode, bytes), ( - "Response.GetHeader() failed: name param is not a string") - cdef CefString cefName - PyToCefString(name, cefName) - return CefToPyString(self.GetCefResponse().get().GetHeader(cefName)) - - cpdef dict GetHeaderMap(self): - cdef list headerMultimap = self.GetHeaderMultimap() - cdef dict headerMap = {} - cdef tuple headerTuple - for headerTuple in headerMultimap: - key = headerTuple[0] - value = headerTuple[1] - headerMap[key] = value - return headerMap - - cpdef list GetHeaderMultimap(self): - cdef cpp_multimap[CefString, CefString] cefHeaderMap - self.GetCefResponse().get().GetHeaderMap(cefHeaderMap) - cdef list pyHeaderMultimap = [] - cdef cpp_multimap[CefString, CefString].iterator iterator = ( - cefHeaderMap.begin()) - cdef CefString cefKey - cdef CefString cefValue - cdef str pyKey - cdef str pyValue - while iterator != cefHeaderMap.end(): - cefKey = deref(iterator).first - cefValue = deref(iterator).second - pyKey = CefToPyString(cefKey) - pyValue = CefToPyString(cefValue) - pyHeaderMultimap.append((pyKey, pyValue)) - preinc(iterator) - return pyHeaderMultimap - - cpdef py_void SetHeaderMap(self, dict headerMap): - assert len(headerMap) > 0, "headerMap param is empty" - cpdef list headerMultimap = [] - cdef object key - for key in headerMap: - headerMultimap.append((str(key), str(headerMap[key]))) - self.SetHeaderMultimap(headerMultimap) - - cpdef py_void SetHeaderMultimap(self, list headerMultimap): - assert len(headerMultimap) > 0, "headerMultimap param is empty" - cdef cpp_multimap[CefString, CefString] cefHeaderMap - cdef CefString cefKey - cdef CefString cefValue - cdef cpp_pair[CefString, CefString] pair - cdef tuple headerTuple - for headerTuple in headerMultimap: - PyToCefString(str(headerTuple[0]), cefKey) - PyToCefString(str(headerTuple[1]), cefValue) - pair.first, pair.second = cefKey, cefValue - cefHeaderMap.insert(pair) - self.GetCefResponse().get().SetHeaderMap(cefHeaderMap) diff --git a/cefpython/v8context_handler_cef1.pyx b/cefpython/v8context_handler_cef1.pyx deleted file mode 100644 index fe399446..00000000 --- a/cefpython/v8context_handler_cef1.pyx +++ /dev/null @@ -1,172 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -V8_PROPERTY_ATTRIBUTE_NONE = cef_types.V8_PROPERTY_ATTRIBUTE_NONE -V8_PROPERTY_ATTRIBUTE_READONLY = cef_types.V8_PROPERTY_ATTRIBUTE_READONLY -V8_PROPERTY_ATTRIBUTE_DONTENUM = cef_types.V8_PROPERTY_ATTRIBUTE_DONTENUM -V8_PROPERTY_ATTRIBUTE_DONTDELETE = cef_types.V8_PROPERTY_ATTRIBUTE_DONTDELETE - -cdef public void V8ContextHandler_OnContextCreated( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - CefRefPtr[CefV8Context] cefContext - ) except * with gil: - # This handler may also be called by JavascriptBindings.Rebind(). - # This handler may be called multiple times for the same frame - rebinding. - - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - - cdef JavascriptBindings javascriptBindings - cdef dict javascriptFunctions - cdef dict javascriptProperties - cdef dict javascriptObjects - - cdef CefRefPtr[V8FunctionHandler] functionHandler - cdef CefRefPtr[CefV8Handler] v8Handler - cdef CefRefPtr[CefV8Value] v8Window - cdef CefRefPtr[CefV8Value] v8Function - cdef CefRefPtr[CefV8Value] v8Object - cdef CefRefPtr[CefV8Value] v8Method - - cdef CefString cefFunctionName - cdef CefString cefPropertyName - cdef CefString cefMethodName - cdef CefString cefObjectName - - cdef object key - cdef object value - cdef py_string functionName - cdef py_string objectName - - cdef object clientCallback - - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyBrowser.SetUserData("__v8ContextCreated", True) - pyFrame = GetPyFrame(cefFrame) - - javascriptBindings = pyBrowser.GetJavascriptBindings() - if not javascriptBindings: - return - - javascriptFunctions = javascriptBindings.GetFunctions() - javascriptProperties = javascriptBindings.GetProperties() - javascriptObjects = javascriptBindings.GetObjects() - - if not javascriptFunctions and not javascriptProperties and not javascriptObjects: - return - - # This checks GetBindToFrames/GetBindToPopups must also be made in both: - # FunctionHandler_Execute() and OnContextCreated(), so that calling - # a non-existent property on window object throws an error. - - if not pyFrame.IsMain() and not javascriptBindings.GetBindToFrames(): - return - - # This check is probably not needed, as GetPyBrowser() will already pass bindings=None, - # if this is a popup window and bindToPopups is False. - - if pyBrowser.IsPopup() and not javascriptBindings.GetBindToPopups(): - return - - v8Window = cefContext.get().GetGlobal() - - if javascriptProperties: - for key,value in javascriptProperties.items(): - key = str(key) - PyToCefString(key, cefPropertyName) - v8Window.get().SetValue( - cefPropertyName, - PyToV8Value(value, cefContext), - V8_PROPERTY_ATTRIBUTE_NONE) - - if javascriptFunctions or javascriptObjects: - functionHandler = new V8FunctionHandler() - functionHandler.get().SetContext(cefContext) - v8Handler = functionHandler.get() - - if javascriptFunctions: - for functionName in javascriptFunctions: - functionName = str(functionName) - PyToCefString(functionName, cefFunctionName) - v8Function = cef_v8_static.CreateFunction(cefFunctionName, v8Handler) - v8Window.get().SetValue(cefFunctionName, v8Function, V8_PROPERTY_ATTRIBUTE_NONE) - - if javascriptObjects: - for objectName in javascriptObjects: - v8Object = cef_v8_static.CreateObject(NULL) - PyToCefString(objectName, cefObjectName) - v8Window.get().SetValue( - cefObjectName, v8Object, V8_PROPERTY_ATTRIBUTE_NONE) - - for methodName in javascriptObjects[objectName]: - methodName = str(methodName) - # cefMethodName = "myobject.someMethod" - PyToCefString(objectName+"."+methodName, cefMethodName) - v8Method = cef_v8_static.CreateFunction(cefMethodName, v8Handler) - # cefMethodName = "someMethod" - PyToCefString(methodName, cefMethodName) - v8Object.get().SetValue( - cefMethodName, v8Method, V8_PROPERTY_ATTRIBUTE_NONE) - - # User defined callback. - clientCallback = pyBrowser.GetClientCallback("OnContextCreated") - if clientCallback: - clientCallback(pyBrowser, pyFrame) - - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void V8ContextHandler_OnContextReleased( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - CefRefPtr[CefV8Context] cefContext - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - # User defined callback. - clientCallback = pyBrowser.GetClientCallback("OnContextReleased") - if clientCallback: - clientCallback(pyBrowser, pyFrame) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void V8ContextHandler_OnUncaughtException( - CefRefPtr[CefBrowser] cefBrowser, - CefRefPtr[CefFrame] cefFrame, - CefRefPtr[CefV8Context] cefContext, - CefRefPtr[CefV8Exception] cefException, - CefRefPtr[CefV8StackTrace] cefStackTrace - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef CefRefPtr[CefV8Exception] v8Exception - cdef CefV8Exception* v8ExceptionPointer - cdef object callback - try: - pyBrowser = GetPyBrowser(cefBrowser) - pyFrame = GetPyFrame(cefFrame) - - v8ExceptionPointer = cefException.get() - pyException = {} - pyException["lineNumber"] = v8ExceptionPointer.GetLineNumber() - pyException["message"] = CefToPyString(v8ExceptionPointer.GetMessage()) - pyException["scriptResourceName"] = CefToPyString( - v8ExceptionPointer.GetScriptResourceName()) - pyException["sourceLine"] = CefToPyString(v8ExceptionPointer.GetSourceLine()) - - pyStackTrace = CefV8StackTraceToPython(cefStackTrace) - - callback = pyBrowser.GetClientCallback("OnUncaughtException") - if callback: - callback(pyBrowser, pyFrame, pyException, pyStackTrace) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/v8function_handler_cef1.pyx b/cefpython/v8function_handler_cef1.pyx deleted file mode 100644 index 98d72df3..00000000 --- a/cefpython/v8function_handler_cef1.pyx +++ /dev/null @@ -1,89 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef public cpp_bool V8FunctionHandler_Execute( - CefRefPtr[CefV8Context] v8Context, - int pythonCallbackId, - CefString& cefFuncName, - CefRefPtr[CefV8Value] cefObject, # receiver ('this' object) of the function. - CefV8ValueList& v8Arguments, - CefRefPtr[CefV8Value]& cefReturnValue, - CefString& cefException - ) except * with gil: - cdef PyBrowser pyBrowser - cdef PyFrame pyFrame - cdef JavascriptBindings javascriptBindings - cdef cpp_vector[CefRefPtr[CefV8Value]].iterator iterator - cdef CefRefPtr[CefV8Value] cefValue - cdef object pythonCallback - cdef list arguments - cdef str functionName - cdef object pyReturnValue - cdef object pyFunction - cdef str objectName - cdef str objectMethod - - try: - if pythonCallbackId: - pythonCallback = GetPythonCallback(pythonCallbackId) - - arguments = [] - iterator = v8Arguments.begin() - while iterator != v8Arguments.end(): - cefValue = deref(iterator) - arguments.append(V8ToPyValue(cefValue, v8Context)) - preinc(iterator) - - pyReturnValue = pythonCallback(*arguments) - # Can't use "arg = " for a referenced argument, bug in Cython, - # see comment in RequestHandler_OnProtocolExecution() for - # more details. - cefReturnValue.swap(PyToV8Value(pyReturnValue, v8Context)) - - return True - else: - pyBrowser = GetPyBrowser(v8Context.get().GetBrowser()) - pyFrame = GetPyFrame(v8Context.get().GetFrame()) - functionName = CefToPyString(cefFuncName) - - javascriptBindings = pyBrowser.GetJavascriptBindings() - if not javascriptBindings: - return False - - if functionName.find(".") == -1: - pyFunction = javascriptBindings.GetFunction(functionName) - if not pyFunction: - return False - else: - # functionName == "myobject.someMethod" - (objectName, methodName) = functionName.split(".") - pyFunction = javascriptBindings.GetObjectMethod(objectName, methodName) - if not pyFunction: - return False - - # GetBindToFrames/GetBindToPopups must also be checked in: - # V8FunctionHandler_Execute() and OnContextCreated(), so that calling - # a non-existent property on window object throws an error. - - if not pyFrame.IsMain() and not javascriptBindings.GetBindToFrames(): - return False - - if pyBrowser.IsPopup() and not javascriptBindings.GetBindToPopups(): - return False - - arguments = [] - iterator = v8Arguments.begin() - while iterator != v8Arguments.end(): - cefValue = deref(iterator) - arguments.append(V8ToPyValue(cefValue, v8Context)) - preinc(iterator) - - pyReturnValue = pyFunction(*arguments) - cefReturnValue.swap(PyToV8Value(pyReturnValue, v8Context)) - - return True - - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/v8utils_cef1.pyx b/cefpython/v8utils_cef1.pyx deleted file mode 100644 index 864f5761..00000000 --- a/cefpython/v8utils_cef1.pyx +++ /dev/null @@ -1,223 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -# CefV8 Objects, Arrays and Functions can be created or modified only -# inside V8 context, you need to call CefV8Context::Enter() and -# CefV8Context::Exit(), see: -# http://code.google.com/p/chromiumembedded/issues/detail?id=203 - -cdef list CefV8StackTraceToPython(CefRefPtr[CefV8StackTrace] cefTrace): - cdef int frameNumber - cdef int frameCount = cefTrace.get().GetFrameCount() - cdef CefRefPtr[CefV8StackFrame] cefFrame - cdef CefV8StackFrame* framePtr - cdef list pyTrace = [] - - for frameNumber in range(0, frameCount): - cefFrame = cefTrace.get().GetFrame(frameNumber) - framePtr = cefFrame.get() - pyFrame = {} - pyFrame["script"] = CefToPyString(framePtr.GetScriptName()) - pyFrame["scriptOrSourceUrl"] = CefToPyString( - framePtr.GetScriptNameOrSourceURL()) - pyFrame["function"] = CefToPyString(framePtr.GetFunctionName()) - pyFrame["line"] = framePtr.GetLineNumber() - pyFrame["column"] = framePtr.GetColumn() - pyFrame["isEval"] = framePtr.IsEval() - pyFrame["isConstructor"] = framePtr.IsConstructor() - pyTrace.append(pyFrame) - - return pyTrace - -cpdef list GetJavascriptStackTrace(int frameLimit=100): - assert IsThread(TID_UI), ( - "cefpython.GetJavascriptStackTrace() may only be called on the UI thread") - cdef CefRefPtr[CefV8StackTrace] cefTrace = ( - cef_v8_stack_trace.GetCurrent(frameLimit)) - return CefV8StackTraceToPython(cefTrace) - -cpdef str FormatJavascriptStackTrace(list stackTrace): - cdef str formatted = "" - cdef dict frame - for frameNumber, frame in enumerate(stackTrace): - formatted += "\t[%s] %s() in %s on line %s (col:%s)\n" % ( - frameNumber, - frame["function"], - frame["scriptOrSourceUrl"], - frame["line"], - frame["column"]) - return formatted - -cdef object V8ToPyValue( - CefRefPtr[CefV8Value] v8Value, - CefRefPtr[CefV8Context] v8Context, - int nestingLevel=0): - - # With nestingLevel > 10 we get system exceptions. - if nestingLevel > 8: - raise Exception("V8ToPyValue() failed: data passed from Javascript to " - "Python has more than 8 levels of nesting, this is probably an infinite " - "recursion, stopping.") - - cdef CefV8Value* v8ValuePtr = v8Value.get() - cdef CefString cefString - cdef CefString cefFuncName - cdef cpp_vector[CefString] keys - cdef cpp_vector[CefString].iterator iterator - - cdef list pyArray - cdef int callbackId - cdef dict pyDict - - # A test against IsArray should be done before IsObject(). - if v8ValuePtr.IsArray(): - pyArray = [] - for key in range(0, v8ValuePtr.GetArrayLength()): - pyArray.append(V8ToPyValue( - v8ValuePtr.GetValue(int(key)), - v8Context, - nestingLevel+1)) - return pyArray - elif v8ValuePtr.IsBool(): - return v8ValuePtr.GetBoolValue() - elif v8ValuePtr.IsDate(): - # TODO: convert it to string with no error. - raise Exception("V8ToPyValue() failed: Date object is not supported, " - "you are not allowed to pass it from Javascript to Python.") - elif v8ValuePtr.IsInt(): - # A check against IsInt() must be done before IsDouble(), as any js integer - # returns true when calling IsDouble(). - return v8ValuePtr.GetIntValue() - elif v8ValuePtr.IsUInt(): - return v8ValuePtr.GetUIntValue() - elif v8ValuePtr.IsDouble(): - return v8ValuePtr.GetDoubleValue() - elif v8ValuePtr.IsFunction(): - callbackId = PutV8JavascriptCallback(v8Value, v8Context) - return JavascriptCallback(callbackId) - elif v8ValuePtr.IsNull(): - return None - elif v8ValuePtr.IsObject(): - # A test against IsObject() should be done after IsArray(). - # Remember about increasing the nestingLevel. - v8ValuePtr.GetKeys(keys) - iterator = keys.begin() - pyDict = {} - while iterator != keys.end(): - cefString = deref(iterator) - key = CefToPyString(cefString) - value = V8ToPyValue( - v8ValuePtr.GetValue(cefString), - v8Context, - nestingLevel+1) - pyDict[key] = value - preinc(iterator) - return pyDict - elif v8ValuePtr.IsString(): - return CefToPyString(v8ValuePtr.GetStringValue()) - elif v8ValuePtr.IsUndefined(): - return None - else: - raise Exception("V8ToPyValue() failed: unknown type of CefV8Value.") - -# Any function calling PyToV8Value must be inside that v8Context, -# check current context and call Enter if required otherwise exception is -# thrown while trying to create an array, object or function. - -cdef CefRefPtr[CefV8Value] PyToV8Value( - object pyValue, - CefRefPtr[CefV8Context] v8Context, - int nestingLevel=0) except *: - - # With nestingLevel > 10 we get system exceptions. - if nestingLevel > 8: - raise Exception("PyToV8Value() failed: data passed from Python " - "to Javascript has more than 8 levels of nesting, this is probably " - "an infinite recursion, stopping.") - - cdef cpp_bool sameContext - if g_debug: - sameContext = v8Context.get().IsSame(cef_v8_static.GetCurrentContext()) - if not sameContext: - raise Exception("PyToV8Value() called in wrong v8 context") - - cdef CefString cefString - cdef CefRefPtr[CefV8Value] v8Value - cdef CefString cefFuncName - cdef type pyValueType = type(pyValue) - - if pyValueType == tuple: - pyValue = list(pyValue) - - # Check type again, as code above may have changed it. - pyValueType = type(pyValue) - - cdef int index - cdef object value - cdef CefRefPtr[V8FunctionHandler] v8FunctionHandler - cdef CefRefPtr[CefV8Handler] v8Handler - cdef int callbackId - cdef object key - - if pyValueType == list: - v8Value = cef_v8_static.CreateArray(len(pyValue)) - for index,value in enumerate(pyValue): - v8Value.get().SetValue( - index, - PyToV8Value(value, v8Context, nestingLevel+1)) - return v8Value - elif pyValueType == bool: - return cef_v8_static.CreateBool(bool(pyValue)) - elif pyValueType == int: - return cef_v8_static.CreateInt(int(pyValue)) - elif pyValueType == long: - # Int32 range is -2147483648..2147483647, we've increased the - # minimum size by one as Cython was throwing a warning: - # "unary minus operator applied to unsigned type, result still - # unsigned". - if pyValue <= 2147483647 and pyValue >= -2147483647: - return cef_v8_static.CreateInt(int(pyValue)) - else: - PyToCefString(str(pyValue), cefString) - return cef_v8_static.CreateString(cefString) - elif pyValueType == float: - return cef_v8_static.CreateDouble(float(pyValue)) - elif pyValueType == types.FunctionType or pyValueType == types.MethodType: - v8FunctionHandler = new V8FunctionHandler() - v8FunctionHandler.get().SetContext(v8Context) - v8Handler = v8FunctionHandler.get() - PyToCefString(pyValue.__name__, cefFuncName) - # V8PythonCallback. - v8Value = cef_v8_static.CreateFunction(cefFuncName, v8Handler) - callbackId = PutPythonCallback(pyValue) - v8FunctionHandler.get().SetCallback_RemovePythonCallback( - RemovePythonCallback) - v8FunctionHandler.get().SetPythonCallbackID(callbackId) - return v8Value - elif pyValueType == type(None): - return cef_v8_static.CreateNull() - elif pyValueType == dict: - v8Value = cef_v8_static.CreateObject(NULL) - for key, value in pyValue.items(): - # A dict may have an int key, a string key or even a tuple key: - # {0: 12, '0': 12, (0, 1): 123} - # Remember about increasing nestingLevel. - PyToCefString(str(key), cefString) - v8Value.get().SetValue( - cefString, - PyToV8Value(value, v8Context, nestingLevel+1), - V8_PROPERTY_ATTRIBUTE_NONE) - return v8Value - elif pyValueType == bytes or pyValueType == str \ - or (PY_MAJOR_VERSION < 3 and pyValueType == unicode): - # The unicode type is not defined in Python 3. - PyToCefString(pyValue, cefString) - return cef_v8_static.CreateString(cefString) - elif pyValueType == type: - PyToCefString(str(pyValue), cefString) - return cef_v8_static.CreateString(cefString) - else: - raise Exception("PyToV8Value() failed: an unsupported python type " - "was passed from python to javascript: %s, value: %s" - % (pyValueType.__name__, pyValue)) diff --git a/cefpython/web_request_cef1.pyx b/cefpython/web_request_cef1.pyx deleted file mode 100644 index 04ea3592..00000000 --- a/cefpython/web_request_cef1.pyx +++ /dev/null @@ -1,209 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -# TODO: fix CefWebURLRequest memory corruption and restore weakrefs -# for PyWebRequest object. Right now getting memory corruption -# when CefRefPtr[CefWebURLRequest] is released after the request -# is completed. The memory corruption manifests itself with the -# "Segmentation Fault" error message or the strange "C function -# name could not be determined in the current C stack frame". -# See this topic on cython-users group: -# https://groups.google.com/d/topic/cython-users/FJZwHhqaCSI/discussion -# After CefWebURLRequest memory corruption is fixed restore weakrefs: -# 1. cdef object g_pyWebRequests = weakref.WeakValueDictionary() -# 2. Add property "cdef object __weakref__" in PyWebRequest -# When using normal dictionary for g_pyWebRequest then the memory -# corruption doesn't occur, but the PyWebRequest and CefWebURLRequest -# objects are never released, thus you have memory leaks, for now -# there is no other solution. See this topic on the CEF Forum: -# http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10710 -cdef object g_pyWebRequests = {} -cdef int g_webRequestMaxId = 0 - -# ------------------------------------------------------------------------------ -# WebRequest -# ------------------------------------------------------------------------------ - -# Static methods are not allowed in cdef classes, -# that's why we need a wrapper for PyWebRequest. - -class WebRequest: - State = { - "Unsent": cef_types.WUR_STATE_UNSENT, - "Started": cef_types.WUR_STATE_STARTED, - "HeadersReceived": cef_types.WUR_STATE_HEADERS_RECEIVED, - "Loading": cef_types.WUR_STATE_LOADING, - "Done": cef_types.WUR_STATE_DONE, - "Error": cef_types.WUR_STATE_ERROR, - "Abort": cef_types.WUR_STATE_ABORT, - } - - def __init__(self): - raise Exception("You cannot instantiate WebRequest directly, " - "use WebRequest.CreateWebRequest() static method") - - @staticmethod - def CreateWebRequest(request, webRequestClient): - if not isinstance(request, PyRequest): - raise Exception("Invalid request object") - return CreatePyWebRequest(request, webRequestClient) - -# ------------------------------------------------------------------------------ -# PyWebRequest -# ------------------------------------------------------------------------------ - -cdef PyWebRequest CreatePyWebRequest(PyRequest request, - object webRequestClient): - global g_pyWebRequests - cdef PyWebRequest webRequest = PyWebRequest(request, webRequestClient) - assert webRequest.webRequestId, "webRequest.webRequestId empty" - g_pyWebRequests[webRequest.webRequestId] = webRequest - return webRequest - -cdef PyWebRequest GetPyWebRequest(int webRequestId): - global g_pyWebRequests - if webRequestId in g_pyWebRequests: - return g_pyWebRequests[webRequestId] - return None - -cdef class PyWebRequest: - # cdef object __weakref__ # see g_pyWebRequests - cdef int webRequestId - cdef CefRefPtr[CefWebURLRequest] requester - cdef object pyWebRequestClient - - def __init__(self, PyRequest pyRequest, object pyWebRequestClient): - global g_webRequestMaxId - g_webRequestMaxId += 1 - self.webRequestId = g_webRequestMaxId - cdef CefRefPtr[WebRequestClient] cppWebRequestClient = ( - new WebRequestClient( - self.webRequestId)) - self.pyWebRequestClient = pyWebRequestClient - self.requester = ( - cef_web_urlrequest_static.CreateWebURLRequest( - pyRequest.cefRequest, - ( - cppWebRequestClient))) - - cdef object GetCallback(self, str funcName): - if hasattr(self.pyWebRequestClient, funcName) and ( - callable(getattr(self.pyWebRequestClient, funcName))): - return getattr(self.pyWebRequestClient, funcName) - - cpdef py_void Cancel(self): - self.requester.get().Cancel() - - cpdef int GetState(self) except *: - return self.requester.get().GetState() - -# ------------------------------------------------------------------------------ -# WebRequestClient -# ------------------------------------------------------------------------------ - -cdef public void WebRequestClient_OnStateChange( - int webRequestId, - CefRefPtr[CefWebURLRequest] requester, - cef_types.cef_weburlrequest_state_t state - ) except * with gil: - cdef PyWebRequest webRequest - cdef object callback - try: - webRequest = GetPyWebRequest(webRequestId) - if webRequest: - callback = webRequest.GetCallback("OnStateChange") - if callback: - callback(webRequest, state) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void WebRequestClient_OnRedirect( - int webRequestId, - CefRefPtr[CefWebURLRequest] requester, - CefRefPtr[CefRequest] request, - CefRefPtr[CefResponse] response - ) except * with gil: - cdef PyWebRequest webRequest - cdef object callback - try: - webRequest = GetPyWebRequest(webRequestId) - if webRequest: - callback = webRequest.GetCallback("OnRedirect") - if callback: - callback(webRequest, webRequest.pyRequest, - CreatePyResponse(response)) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void WebRequestClient_OnHeadersReceived( - int webRequestId, - CefRefPtr[CefWebURLRequest] requester, - CefRefPtr[CefResponse] response - ) except * with gil: - cdef PyWebRequest webRequest - cdef object callback - try: - webRequest = GetPyWebRequest(webRequestId) - if webRequest: - callback = webRequest.GetCallback("OnHeadersReceived") - if callback: - callback(webRequest, CreatePyResponse(response)) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void WebRequestClient_OnProgress( - int webRequestId, - CefRefPtr[CefWebURLRequest] requester, - uint64_t bytesSent, - uint64_t totalBytesToBeSent - ) except * with gil: - cdef PyWebRequest webRequest - cdef object callback - try: - webRequest = GetPyWebRequest(webRequestId) - if webRequest: - callback = webRequest.GetCallback("OnProgress") - if callback: - callback(webRequest, bytesSent, totalBytesToBeSent) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void WebRequestClient_OnData( - int webRequestId, - CefRefPtr[CefWebURLRequest] requester, - void* data, - int dataLength - ) except * with gil: - cdef PyWebRequest webRequest - cdef object callback - try: - webRequest = GetPyWebRequest(webRequestId) - if webRequest: - callback = webRequest.GetCallback("OnData") - if callback: - callback(webRequest, VoidPtrToString(data, dataLength)) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) - -cdef public void WebRequestClient_OnError( - int webRequestId, - CefRefPtr[CefWebURLRequest] requester, - int errorCode - ) except * with gil: - cdef PyWebRequest webRequest - cdef object callback - try: - webRequest = GetPyWebRequest(webRequestId) - if webRequest: - callback = webRequest.GetCallback("OnError") - if callback: - callback(webRequest, errorCode) - except: - (exc_type, exc_value, exc_trace) = sys.exc_info() - sys.excepthook(exc_type, exc_value, exc_trace) diff --git a/cefpython/window_info_cef1.pyx b/cefpython/window_info_cef1.pyx deleted file mode 100644 index f7946ec9..00000000 --- a/cefpython/window_info_cef1.pyx +++ /dev/null @@ -1,105 +0,0 @@ -# Copyright (c) 2012-2014 The CEF Python authors. All rights reserved. -# License: New BSD License. -# Website: http://code.google.com/p/cefpython/ - -cdef void SetCefWindowInfo( - CefWindowInfo& cefWindowInfo, - WindowInfo windowInfo - ) except *: - if not windowInfo.windowType: - raise Exception("WindowInfo: windowType is not set") - - # It is allowed to pass 0 as parentWindowHandle in OSR mode, but then - # some things like context menus and plugins may not display correctly. - if windowInfo.windowType != "offscreen": - if not windowInfo.parentWindowHandle: - raise Exception("WindowInfo: parentWindowHandle is not set") - - IF UNAME_SYSNAME == "Windows": - cdef RECT rect - cdef CefString cefString - - if windowInfo.windowType == "child": - IF UNAME_SYSNAME == "Windows": - if windowInfo.windowRect: - rect.left = int(windowInfo.windowRect[0]) - rect.top = int(windowInfo.windowRect[1]) - rect.right = int(windowInfo.windowRect[2]) - rect.bottom = int(windowInfo.windowRect[3]) - else: - GetClientRect( - windowInfo.parentWindowHandle, &rect) - cefWindowInfo.SetAsChild( - windowInfo.parentWindowHandle, rect) - ELIF UNAME_SYSNAME == "Darwin": - raise Exception("WindowInfo.SetAsChild() not implemented on Mac") - ELIF UNAME_SYSNAME == "Linux": - cefWindowInfo.SetAsChild( - windowInfo.parentWindowHandle) - - IF UNAME_SYSNAME == "Windows": - if windowInfo.windowType == "popup": - PyToCefString(windowInfo.windowName, cefString) - cefWindowInfo.SetAsPopup( - windowInfo.parentWindowHandle, cefString) - - IF not (CEF_VERSION == 1 and UNAME_SYSNAME == "Linux"): - if windowInfo.windowType == "offscreen": - cefWindowInfo.SetAsOffScreen( - windowInfo.parentWindowHandle) - cefWindowInfo.SetTransparentPainting( - int(windowInfo.transparentPainting)) - -cdef class WindowInfo: - cdef public str windowType - cdef public WindowHandle parentWindowHandle - cdef public list windowRect - cdef public py_string windowName - cdef public py_bool transparentPainting - - def __init__(self): - self.transparentPainting = False - - cpdef py_void SetAsChild(self, WindowHandle parentWindowHandle, - list windowRect=None): - if not WindowUtils.IsWindowHandle(parentWindowHandle): - raise Exception("Invalid parentWindowHandle: %s" \ - % parentWindowHandle) - self.windowType = "child" - self.parentWindowHandle = parentWindowHandle - IF UNAME_SYSNAME == "Darwin": - if not windowRect: - raise Exception("WindowInfo.SetAsChild() failed: " \ - "windowRect is required") - if windowRect: - if type(windowRect) == list and len(windowRect) == 4: - self.windowRect = [windowRect[0], windowRect[1], - windowRect[2], windowRect[3]] - else: - raise Exception("WindowInfo.SetAsChild() failed: " \ - "windowRect: invalid value") - - IF UNAME_SYSNAME == "Windows": - cpdef py_void SetAsPopup(self, WindowHandle parentWindowHandle, - py_string windowName): - if not WindowUtils.IsWindowHandle(parentWindowHandle): - raise Exception("Invalid parentWindowHandle: %s" \ - % parentWindowHandle) - self.parentWindowHandle = parentWindowHandle - self.windowType = "popup" - self.windowName = str(windowName) - - IF not (CEF_VERSION == 1 and UNAME_SYSNAME == "Linux"): - cpdef py_void SetAsOffscreen(self, - WindowHandle parentWindowHandle): - # It is allowed to pass 0 as parentWindowHandle. - if parentWindowHandle and \ - not WindowUtils.IsWindowHandle(parentWindowHandle): - raise Exception("Invalid parentWindowHandle: %s" \ - % parentWindowHandle) - self.parentWindowHandle = parentWindowHandle - self.windowType = "offscreen" - - cpdef py_void SetTransparentPainting(self, - py_bool transparentPainting): - self.transparentPainting = transparentPainting