include "__version__.pyx"

include "compile_time_constants.pxi"

import os

import sys

import cython

import platform

import traceback

import time

import types

import re

import copy

import inspect # used by JavascriptBindings.__SetObjectMethods()

import urllib

import json

import datetime

import random

if sys.version_info.major == 2:

# noinspection PyUnresolvedReferences

import urlparse

else:

# noinspection PyUnresolvedReferences

from urllib import parse as urlparse

if sys.version_info.major == 2:

# noinspection PyUnresolvedReferences

from urllib import pathname2url as urllib_pathname2url

else:

# noinspection PyUnresolvedReferences

from urllib.request import pathname2url as urllib_pathname2url

from cpython.version cimport PY_MAJOR_VERSION

import weakref

ctypedef object py_string

ctypedef object py_void

ctypedef long long WindowHandle

from cpython cimport PyLong_FromVoidPtr

from cpython cimport bool as py_bool

from libcpp cimport bool as cpp_bool

from libcpp.map cimport map as cpp_map

from multimap cimport multimap as cpp_multimap

from libcpp.pair cimport pair as cpp_pair

from libcpp.vector cimport vector as cpp_vector

from libcpp.string cimport string as cpp_string

from wstring cimport wstring as cpp_wstring

from libc.string cimport strlen

from libc.string cimport memcpy

from cython.operator cimport preincrement as preinc, dereference as deref

from libc.stdlib cimport calloc, malloc, free

from libc.stdlib cimport atoi

from libc.stdint cimport uint64_t

from libc.stdint cimport uintptr_t

cimport ctime

IF UNAME_SYSNAME == "Windows":

from windows cimport *

from dpi_aware_win cimport *

ELIF UNAME_SYSNAME == "Linux":

from linux cimport *

ELIF UNAME_SYSNAME == "Darwin":

from mac cimport *

from cpp_utils cimport *

from task cimport *

from cef_string cimport *

cdef extern from *:

# noinspection PyUnresolvedReferences

ctypedef CefString ConstCefString "const CefString"

from cef_types cimport (

CefSettings, CefBrowserSettings, CefRect, CefPoint,

CefRequestContextSettings,

CefKeyEvent, CefMouseEvent, CefScreenInfo,

PathKey, PK_DIR_EXE, PK_DIR_MODULE

)

from cef_task cimport *

from cef_platform cimport *

from cef_ptr cimport *

from cef_app cimport *

from cef_browser cimport *

cimport cef_browser_static

from cef_client cimport *

from client_handler cimport *

from cef_frame cimport *

from cef_time cimport *

from cef_values cimport *

from cefpython_app cimport *

from cef_process_message cimport *

from cef_web_plugin cimport *

from cef_request_handler cimport *

from cef_request cimport *

from cef_cookie cimport *

from cef_string_visitor cimport *

cimport cef_cookie_manager_namespace

from cookie_visitor cimport *

from string_visitor cimport *

from cef_callback cimport *

from cef_response cimport *

from cef_resource_handler cimport *

from resource_handler cimport *

from cef_urlrequest cimport *

from web_request_client cimport *

from cef_command_line cimport *

from cef_request_context cimport *

from cef_request_context_handler cimport *

from request_context_handler cimport *

from cef_jsdialog_handler cimport *

from cef_path_util cimport *

g_debug = False

g_debugFile = "debug.log"

g_applicationSettings = {}

g_commandLineSwitches = {}

cdef cpp_bool _MessageLoopWork_wasused = False

cdef dict g_globalClientCallbacks = {}

cdef CefRefPtr[CefRequestContext] g_sharedRequestContext

include "utils.pyx"

include "string_utils.pyx"

IF UNAME_SYSNAME == "Windows":

include "string_utils_win.pyx"

include "time_utils.pyx"

include "browser.pyx"

include "frame.pyx"

include "settings.pyx"

IF UNAME_SYSNAME == "Windows":

include "window_utils_win.pyx"

include "dpi_aware_win.pyx"

ELIF UNAME_SYSNAME == "Linux":

include "window_utils_linux.pyx"

ELIF UNAME_SYSNAME == "Darwin":

include "window_utils_mac.pyx"

include "task.pyx"

include "javascript_bindings.pyx"

include "virtual_keys.pyx"

include "window_info.pyx"

include "process_message_utils.pyx"

include "v8context_handler.pyx"

include "v8function_handler.pyx"

include "javascript_callback.pyx"

include "python_callback.pyx"

include "lifespan_handler.pyx"

include "display_handler.pyx"

include "keyboard_handler.pyx"

include "web_plugin_info.pyx"

include "request.pyx"

include "request_handler.pyx"

include "cookie.pyx"

include "string_visitor.pyx"

include "load_handler.pyx"

include "network_error.pyx"

include "browser_process_handler.pyx"

include "paint_buffer.pyx"

include "render_handler.pyx"

include "callback.pyx"

include "resource_handler.pyx"

include "response.pyx"

include "web_request.pyx"

include "command_line.pyx"

include "app.pyx"

include "javascript_dialog_handler.pyx"

cdef public void cefpython_GetDebugOptions(

cpp_bool* debug,

cpp_string* debugFile

) except * with gil:

# Called from subprocess/cefpython_app.cpp -> CefPythonApp constructor.

cdef cpp_string cppString = g_debugFile

try:

debug[0] = <cpp_bool>bool(g_debug)

debugFile.assign(cppString)

except:

(exc_type, exc_value, exc_trace) = sys.exc_info()

sys.excepthook(exc_type, exc_value, exc_trace)

cdef public cpp_bool ApplicationSettings_GetBool(const char* key

) except * with gil:

# Called from client_handler/client_handler.cpp for example

cdef py_string pyKey = CharToPyString(key)

if pyKey in g_applicationSettings:

return bool(g_applicationSettings[pyKey])

return False

cdef public cpp_bool ApplicationSettings_GetBoolFromDict(const char* key1,

const char* key2) except * with gil:

cdef py_string pyKey1 = CharToPyString(key1)

cdef py_string pyKey2 = CharToPyString(key2)

cdef object dictValue # Yet to be checked whether it is `dict`

if pyKey1 in g_applicationSettings:

dictValue = g_applicationSettings[pyKey1]

if type(dictValue) != dict:

return False

if pyKey2 in dictValue:

return bool(dictValue[pyKey2])

return False

cdef public cpp_string ApplicationSettings_GetString(const char* key

) except * with gil:

cdef py_string pyKey = CharToPyString(key)

cdef cpp_string cppString

if pyKey in g_applicationSettings:

cppString = AnyToPyString(g_applicationSettings[pyKey])

return cppString

cdef public int CommandLineSwitches_GetInt(const char* key) except * with gil:

cdef py_string pyKey = CharToPyString(key)

if pyKey in g_commandLineSwitches:

return int(g_commandLineSwitches[pyKey])

return 0

def Initialize(applicationSettings=None, commandLineSwitches=None):

# Fix Issue #231 - Discovery of the "icudtl.dat" file fails on Linux.

# Apply patch for all platforms just in case.

cdef str py_module_dir = GetModuleDirectory()

cdef CefString module_dir

PyToCefString(py_module_dir, module_dir)

CefOverridePath(PK_DIR_EXE, module_dir)\

or Debug("ERROR: CefOverridePath failed")

CefOverridePath(PK_DIR_MODULE, module_dir)\

or Debug("ERROR: CefOverridePath failed")

if not applicationSettings:

applicationSettings = {}

# Debug settings need to be set before Debug() is called

# and before the CefPythonApp class is instantiated.

global g_debug

global g_debugFile

if "debug" in applicationSettings:

g_debug = bool(applicationSettings["debug"])

if "log_file" in applicationSettings:

g_debugFile = applicationSettings["log_file"]

Debug("Initialize() called")

# Mac initialization. Need to call NSApplication.sharedApplication()

# and do NSApplication methods swizzling to implement

# CrAppControlProtocol. See Issue 156.

IF UNAME_SYSNAME == "Darwin":

MacInitialize()

# -------------------------------------------------------------------------

# CEF Python only options - default values

if "debug" not in applicationSettings:

applicationSettings["debug"] = False

if "string_encoding" not in applicationSettings:

applicationSettings["string_encoding"] = "utf-8"

if "unique_request_context_per_browser" not in applicationSettings:

applicationSettings["unique_request_context_per_browser"] = False

if "downloads_enabled" not in applicationSettings:

applicationSettings["downloads_enabled"] = True

if "remote_debugging_port" not in applicationSettings:

applicationSettings["remote_debugging_port"] = 0

if "auto_zooming" not in applicationSettings:

IF UNAME_SYSNAME == "Windows":

if DpiAware.IsProcessDpiAware():

applicationSettings["auto_zooming"] = "system_dpi"

# Mouse context menu

if "context_menu" not in applicationSettings:

applicationSettings["context_menu"] = {}

menuItems = ["enabled", "navigation", "print", "view_source",

"external_browser", "devtools"]

for item in menuItems:

if item not in applicationSettings["context_menu"]:

applicationSettings["context_menu"][item] = True

# Remote debugging port. If value is 0 we will generate a random

# port. To disable remote debugging set value to -1.

if applicationSettings["remote_debugging_port"] == 0:

# Generate a random port.

applicationSettings["remote_debugging_port"] =\

random.randint(49152, 65535)

elif applicationSettings["remote_debugging_port"] == -1:

# Disable remote debugging

applicationSettings["remote_debugging_port"] = 0

# -------------------------------------------------------------------------

# CEF options - default values.

if not "multi_threaded_message_loop" in applicationSettings:

applicationSettings["multi_threaded_message_loop"] = False

if not "single_process" in applicationSettings:

applicationSettings["single_process"] = False

cdef CefRefPtr[CefApp] cefApp = <CefRefPtr[CefApp]?>new CefPythonApp()

IF UNAME_SYSNAME == "Windows":

cdef HINSTANCE hInstance = GetModuleHandle(NULL)

cdef CefMainArgs cefMainArgs = CefMainArgs(hInstance)

ELIF UNAME_SYSNAME == "Linux":

# TODO: use the CefMainArgs(int argc, char** argv) constructor.

cdef CefMainArgs cefMainArgs

ELIF UNAME_SYSNAME == "Darwin":

# TODO: use the CefMainArgs(int argc, char** argv) constructor.

cdef CefMainArgs cefMainArgs

cdef int exitCode = 1

with nogil:

exitCode = CefExecuteProcess(cefMainArgs, cefApp, NULL)

Debug("CefExecuteProcess(): exitCode = %s" % exitCode)

if exitCode >= 0:

sys.exit(exitCode)

# Make a copy as applicationSettings is a reference only

# that might get destroyed later.

global g_applicationSettings

for key in applicationSettings:

g_applicationSettings[key] = copy.deepcopy(applicationSettings[key])

cdef CefSettings cefApplicationSettings

# No sandboxing for the subprocesses

cefApplicationSettings.no_sandbox = 1

SetApplicationSettings(applicationSettings, &cefApplicationSettings)

if commandLineSwitches:

# Make a copy as commandLineSwitches is a reference only

# that might get destroyed later.

global g_commandLineSwitches

for key in commandLineSwitches:

g_commandLineSwitches[key] = copy.deepcopy(

commandLineSwitches[key])

Debug("CefInitialize()")

cdef cpp_bool ret

with nogil:

ret = CefInitialize(cefMainArgs, cefApplicationSettings, cefApp, NULL)

if not ret:

Debug("CefInitialize() failed")

return ret

def CreateBrowserSync(windowInfo, browserSettings, navigateUrl, requestContext=None):

Debug("CreateBrowserSync() called")

assert IsThread(TID_UI), (

"cefpython.CreateBrowserSync() may only be called on the UI thread")

if not isinstance(windowInfo, WindowInfo):

raise Exception("CreateBrowserSync() failed: windowInfo: invalid object")

cdef CefBrowserSettings cefBrowserSettings

SetBrowserSettings(browserSettings, &cefBrowserSettings)

cdef CefWindowInfo cefWindowInfo

SetCefWindowInfo(cefWindowInfo, windowInfo)

navigateUrl = GetNavigateUrl(navigateUrl)

Debug("navigateUrl: %s" % navigateUrl)

cdef CefString cefNavigateUrl

PyToCefString(navigateUrl, cefNavigateUrl)

Debug("CefBrowser::CreateBrowserSync()")

cdef CefRefPtr[ClientHandler] clientHandler =\

<CefRefPtr[ClientHandler]?>new ClientHandler()

cdef CefRefPtr[CefBrowser] cefBrowser

# Request context - part 1/2.

createSharedRequestContext = bool(not g_sharedRequestContext.get())

cdef CefRequestContextSettings requestContextSettings

cdef CefRefPtr[CefRequestContext] cefRequestContext

cdef CefRefPtr[RequestContextHandler] requestContextHandler =\

<CefRefPtr[RequestContextHandler]?>new RequestContextHandler(

cefBrowser)

if g_applicationSettings["unique_request_context_per_browser"]:

cefRequestContext = CefRequestContext_CreateContext(

requestContextSettings,

<CefRefPtr[CefRequestContextHandler]?>requestContextHandler)

else:

if createSharedRequestContext:

cefRequestContext = CefRequestContext_CreateContext(

requestContextSettings,

<CefRefPtr[CefRequestContextHandler]?>\

requestContextHandler)

g_sharedRequestContext.Assign(cefRequestContext.get())

else:

cefRequestContext.Assign(g_sharedRequestContext.get())

# CEF browser creation.

with nogil:

cefBrowser = cef_browser_static.CreateBrowserSync(

cefWindowInfo, <CefRefPtr[CefClient]?>clientHandler,

cefNavigateUrl, cefBrowserSettings,

cefRequestContext)

if <void*>cefBrowser == NULL or not cefBrowser.get():

Debug("CefBrowser::CreateBrowserSync() failed")

return None

else:

Debug("CefBrowser::CreateBrowserSync() succeeded")

# Request context - part 2/2.

if g_applicationSettings["unique_request_context_per_browser"]:

requestContextHandler.get().SetBrowser(cefBrowser)

else:

if createSharedRequestContext:

requestContextHandler.get().SetBrowser(cefBrowser)

cdef PyBrowser pyBrowser = GetPyBrowser(cefBrowser)

pyBrowser.SetUserData("__outerWindowHandle", int(windowInfo.parentWindowHandle))

return pyBrowser

def MessageLoop():

Debug("MessageLoop()")

with nogil:

CefRunMessageLoop()

def MessageLoopWork():

# Perform a single iteration of CEF message loop processing.

# This function is used to integrate the CEF message loop

# into an existing application message loop.

# Anything that can block for a significant amount of time

# and is thread-safe should release the GIL:

# https://groups.google.com/d/msg/cython-users/jcvjpSOZPp0/KHpUEX8IhnAJ

# GIL must be released here otherwise we will get dead lock

# when calling from c++ to python.

if not _MessageLoopWork_wasused:

global _MessageLoopWork_wasused

_MessageLoopWork_wasused = True

with nogil:

CefDoMessageLoopWork()

def SingleMessageLoop():

# @deprecated, use MessageLoopWork() instead

MessageLoopWork()

def QuitMessageLoop():

Debug("QuitMessageLoop()")

with nogil:

CefQuitMessageLoop()

def Shutdown():

if g_sharedRequestContext.get():

# A similar release is done in RemovePyBrowser and CloseBrowser.

# This one is probably redundant. Additional testing should be done.

Debug("Shutdown: releasing shared request context")

g_sharedRequestContext.Assign(NULL)

Debug("Shutdown()")

with nogil:

# Temporary fix for possible errors on shutdown. See this post:

# https://magpcss.org/ceforum/viewtopic.php?p=30858#p30858

# May be fixed by host owned message loop, see Issue 1805:

# https://bitbucket.org/chromiumembedded/cef/issues/1805/

if _MessageLoopWork_wasused:

for i in range(10):

CefDoMessageLoopWork()

CefShutdown()

if _MessageLoopWork_wasused:

for i in range(10):

CefDoMessageLoopWork()

def SetOsModalLoop(py_bool modalLoop):

cdef cpp_bool cefModalLoop = bool(modalLoop)

with nogil:

CefSetOSModalLoop(cefModalLoop)

cpdef py_void SetGlobalClientCallback(py_string name, object callback):

global g_globalClientCallbacks

if name in ["OnCertificateError", "OnBeforePluginLoad", "OnAfterCreated"]:

g_globalClientCallbacks[name] = callback

else:

raise Exception("SetGlobalClientCallback() failed: "\

"invalid callback name = %s" % name)

cpdef object GetGlobalClientCallback(py_string name):

global g_globalClientCallbacks

if name in g_globalClientCallbacks:

return g_globalClientCallbacks[name]

else:

return None