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

import struct

import base64

from urllib import parse as urlparse

from urllib.parse import quote as urlparse_quote

from urllib.parse import urlencode as urllib_urlencode

from cpython.version cimport PY_MAJOR_VERSION

import weakref

ctypedef object py_string

ctypedef object py_void

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 libcpp.memory cimport unique_ptr

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

ctypedef uintptr_t WindowHandle

cimport ctime

include "platform_cimports.pxi"

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, CefSize, CefPoint,

CefKeyEvent, CefMouseEvent, CefScreenInfo,

PathKey, PK_DIR_EXE, PK_DIR_MODULE,

cef_log_severity_t,

)

from cef_ptr cimport CefRefPtr

from cef_task cimport *

from cef_platform 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_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 *

from cef_drag_data cimport *

from cef_image cimport *

from main_message_loop cimport *

from cef_views cimport *

from cef_log cimport *

from cef_file_util cimport *

g_debug = False

g_applicationSettings = {"string_encoding": "utf-8"}

g_commandLineSwitches = {}

g_browser_settings = {}

cdef CefRefPtr[CefRequestContext] g_shared_request_context

cdef unique_ptr[MainMessageLoopExternalPump] g_external_message_pump

cdef py_bool g_MessageLoop_called = False

cdef py_bool g_MessageLoopWork_called = False

cdef py_bool g_cef_initialized = False

cdef py_bool g_context_initialized = False

cdef list g_pending_browsers = []

IF UNAME_SYSNAME == "Linux":

# Keeps ctypes callback objects alive for the duration of gtk_main() and

# any pending one-shot GLib timers (Xwayland XReparentWindow scheduling).

g_linux_reparent_callbacks = []

cdef dict g_globalClientCallbacks = {}

include "cef_types.pyx"

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 "javascript_callback.pyx"

include "python_callback.pyx"

include "request.pyx"

include "cookie.pyx"

include "string_visitor.pyx"

include "network_error.pyx"

include "paint_buffer.pyx"

include "callback.pyx"

include "response.pyx"

include "web_request.pyx"

include "command_line.pyx"

include "app.pyx"

include "drag_data.pyx"

include "helpers.pyx"

include "image.pyx"

include "handlers/accessibility_handler.pyx"

include "handlers/browser_process_handler.pyx"

include "handlers/context_menu_handler.pyx"

include "handlers/cookie_access_filter.pyx"

include "handlers/display_handler.pyx"

include "handlers/focus_handler.pyx"

include "handlers/javascript_dialog_handler.pyx"

include "handlers/keyboard_handler.pyx"

include "handlers/lifespan_handler.pyx"

include "handlers/load_handler.pyx"

include "handlers/render_handler.pyx"

include "handlers/resource_handler.pyx"

include "handlers/request_handler.pyx"

include "handlers/v8context_handler.pyx"

include "handlers/v8function_handler.pyx"

cdef public void cefpython_GetDebugOptions(

cpp_bool* debug

) noexcept with gil:

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

try:

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

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 object 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 object pyKey1 = CharToPyString(key1)

cdef object 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 object pyKey = CharToPyString(key)

cdef cpp_string cppString

if pyKey in g_applicationSettings:

cppString = PyStringToChar(AnyToPyString(g_applicationSettings[pyKey]))

return cppString

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

cdef object pyKey = CharToPyString(key)

if pyKey in g_commandLineSwitches:

return int(g_commandLineSwitches[pyKey])

return 0

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

# applicationSettings and commandLineSwitches argument

# names are kept for backward compatibility.

application_settings = applicationSettings

command_line_switches = commandLineSwitches

# Alternative names for existing parameters

if "settings" in kwargs:

assert not applicationSettings, "Bad arguments"

application_settings = kwargs["settings"]

del kwargs["settings"]

if "switches" in kwargs:

assert not command_line_switches, "Bad arguments"

command_line_switches = kwargs["switches"]

del kwargs["switches"]

for kwarg in kwargs:

raise Exception("Invalid argument: "+kwarg)

if command_line_switches:

# Make a copy as commandLineSwitches is a reference only

# that might get destroyed later.

global g_commandLineSwitches

for key in command_line_switches:

g_commandLineSwitches[key] = copy.deepcopy(

command_line_switches[key])

# Use g_commandLineSwitches if you need to modify or access

# command line switches inside this function.

del command_line_switches

del commandLineSwitches

if not application_settings:

application_settings = {}

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

# and before the CefPythonApp class is instantiated.

global g_debug

if "--debug" in sys.argv:

application_settings["debug"] = True

application_settings["log_file"] = os.path.join(os.getcwd(),

"debug.log")

application_settings["log_severity"] = LOGSEVERITY_INFO

sys.argv.remove("--debug")

if "debug" in application_settings:

g_debug = bool(application_settings["debug"])

if "log_severity" in application_settings:

if application_settings["log_severity"] <= LOGSEVERITY_INFO:

g_debug = True

Debug("Initialize() called")

# Additional initialization on Mac, see util_mac.mm.

IF UNAME_SYSNAME == "Darwin":

MacInitialize()

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

# CEF Python only options

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

if "debug" not in application_settings:

application_settings["debug"] = False

if "log_severity" not in application_settings:

# By default show only errors. Don't show on Linux X server non-fatal

# errors like "WARNING:x11_util.cc(1409)] X error received".

application_settings["log_severity"] = LOGSEVERITY_ERROR

if "string_encoding" not in application_settings:

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

if "unique_request_context_per_browser" not in application_settings:

application_settings["unique_request_context_per_browser"] = False

if "downloads_enabled" not in application_settings:

application_settings["downloads_enabled"] = True

if "remote_debugging_port" not in application_settings:

application_settings["remote_debugging_port"] = 0

if "app_user_model_id" in application_settings:

g_commandLineSwitches["app-user-model-id"] =\

application_settings["app_user_model_id"]

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

# Paths

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

cdef str module_dir = GetModuleDirectory()

if platform.system() == "Darwin":

if "framework_dir_path" not in application_settings:

application_settings["framework_dir_path"] = os.path.join(

module_dir, "Chromium Embedded Framework.framework")

if "locales_dir_path" not in application_settings:

if platform.system() != "Darwin":

application_settings["locales_dir_path"] = os.path.join(

module_dir, "locales")

if "resources_dir_path" not in application_settings:

application_settings["resources_dir_path"] = module_dir

if platform.system() == "Darwin":

# "framework_dir_path" will always be set, see code above.

application_settings["resources_dir_path"] = os.path.join(

application_settings["framework_dir_path"],

"Resources")

if "browser_subprocess_path" not in application_settings:

application_settings["browser_subprocess_path"] = os.path.join(

module_dir, "subprocess")

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

# Mouse context menu

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

if "context_menu" not in application_settings:

application_settings["context_menu"] = {}

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

"external_browser", "devtools"]

for item in menuItems:

if item not in application_settings["context_menu"]:

application_settings["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 application_settings["remote_debugging_port"] == 0:

# Generate a random port.

application_settings["remote_debugging_port"] =\

random.randint(49152, 65535)

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

# Disable remote debugging

application_settings["remote_debugging_port"] = 0

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

# CEF options - default values

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

if not "multi_threaded_message_loop" in application_settings:

application_settings["multi_threaded_message_loop"] = False

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

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

# Fix GPUCache/ folder creation when using in-memory cache (Issue #419)

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

if not "cache_path" in application_settings:

application_settings["cache_path"] = ""

if not application_settings["cache_path"]:

g_commandLineSwitches["disable-gpu-shader-disk-cache"] = ""

IF UNAME_SYSNAME == "Linux":

# Detect Wayland/X11 mode and apply switches BEFORE gtk_init so we

# know whether to open a GTK/X11 display connection at all.

_linux_apply_initialize_defaults(application_settings,

g_commandLineSwitches)

# In X11/Xwayland mode, open a GDK display connection before

# CefInitialize so the Ozone X11 backend can use it.

# In native Wayland mode, no GTK/X11 connection is needed or wanted.

if not _g_linux_wayland_mode:

_linux_gtk_init()

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":

# Build a complete argv so the browser process sees all switches.

# OnBeforeChildProcessLaunch only reaches child processes; switches

# like --in-process-gpu and --single-process must be in the browser

# process's own command line to take effect.

_cefMainArgvPyList = [sys.executable.encode('utf-8')]

for _cefArgK, _cefArgV in g_commandLineSwitches.items():

if _cefArgV:

_cefMainArgvPyList.append(

("--{}={}".format(_cefArgK, _cefArgV)).encode('utf-8'))

else:

_cefMainArgvPyList.append(

("--{}".format(_cefArgK)).encode('utf-8'))

cdef int _cefMainArgc = len(_cefMainArgvPyList)

cdef char** _cefMainArgvC = \

<char**>malloc(_cefMainArgc * sizeof(char*))

cdef bytes _cefMainArgvItem

cdef int _cefMainArgvI

for _cefMainArgvI in range(_cefMainArgc):

_cefMainArgvItem = _cefMainArgvPyList[_cefMainArgvI]

_cefMainArgvC[_cefMainArgvI] = _cefMainArgvItem

cdef CefMainArgs cefMainArgs = CefMainArgs(_cefMainArgc, _cefMainArgvC)

# _cefMainArgvPyList keeps the bytes alive; freed below after

# CefInitialize() has processed the command line.

ELIF UNAME_SYSNAME == "Darwin":

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

cdef CefMainArgs cefMainArgs

cdef int exitCode = 1

# NOTE: CefExecuteProcess shall not be called here. It should

# be called only in the subprocess main.cpp.

# Make a copy as applicationSettings is a reference only

# that might get destroyed later.

global g_applicationSettings

for key in application_settings:

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

cdef CefSettings cefApplicationSettings

IF UNAME_SYSNAME == "Linux":

# On Linux, leave no_sandbox=0 so Chrome's startup code registers the

# Mojo IPC bootstrap fd (GlobalDescriptors key 7) for every subprocess.

# Setting no_sandbox=1 would cause BasicStartupComplete() to append

# --no-sandbox before fd registration, causing all subprocesses to crash

# with "Failed global descriptor lookup: 7". Sandbox behaviour is instead

# controlled via --disable-setuid-sandbox / --disable-namespace-sandbox

# command-line switches passed by the caller.

pass

ELSE:

# On Windows/macOS the sandbox helper binary is not shipped with

# cefpython, so disable sandboxing entirely.

cefApplicationSettings.no_sandbox = 1

SetApplicationSettings(application_settings, &cefApplicationSettings)

# External message pump

if GetAppSetting("external_message_pump")\

and not g_external_message_pump.get():

Debug("Create external message pump")

global g_external_message_pump

# Using .reset() here to assign new instance was causing

# MainMessageLoopExternalPump destructor to be called. Strange.

g_external_message_pump = MainMessageLoopExternalPump.Create()

Debug("CefInitialize()")

cdef cpp_bool ret

with nogil:

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

IF UNAME_SYSNAME == "Linux":

free(_cefMainArgvC)

global g_cef_initialized

g_cef_initialized = True

if not ret:

Debug("CefInitialize() failed")

# Pump the message loop until OnContextInitialized fires. This

# guarantees that CreateBrowserSync() can be called immediately after

# Initialize() without hitting the deferred-creation path or getting

# a null browser from CefBrowserHost::CreateBrowserSync().

# Use a generous ceiling (30s) for CI environments where utility

# subprocesses (storage service) crash and delay context initialization.

if ret:

# On Linux, skip this pump entirely. Empirical testing shows manual

# CefDoMessageLoopWork() *does* fire OnContextInitialized within 2-3s

# on both Ozone X11 and Ozone Wayland in the current cefpython

# configuration, so the historical "needs gtk_main()" claim is no

# longer accurate — but we still skip it deliberately to keep

# Initialize() non-blocking on Linux. The user enters

# cef.MessageLoop() (gtk_main on X11, GLib loop on Wayland) right

# after Initialize() returns; OnContextInitialized fires there and

# BrowserProcessHandler_OnContextInitialized drains

# g_pending_browsers. This avoids a 2-3s startup latency hit on

# the common case and a 30s block in edge cases.

# On Windows/macOS, pump up to 30s as before.

IF UNAME_SYSNAME != "Linux":

for _ in range(3000):

with nogil:

CefDoMessageLoopWork()

if g_context_initialized:

break

time.sleep(0.01)

if not g_context_initialized:

Debug("CefInitialize() WARNING: OnContextInitialized not received"

" within 30 seconds")

# Compile-time Linux guard: _g_linux_wayland_mode is defined in

# window_utils_linux.pyx, which is only included in the Linux build,

# so this whole block must be excluded on Windows/macOS or Cython

# fails with "undeclared name not builtin: _g_linux_wayland_mode".

IF UNAME_SYSNAME == "Linux":

if not _g_linux_wayland_mode:

WindowUtils.InstallX11ErrorHandlers()

return ret

def CreateBrowser(**kwargs):

"""Create browser asynchronously. TODO. """

CreateBrowserSync(**kwargs)

def CreateBrowserSync(windowInfo=None,

browserSettings=None,

navigateUrl="",

window_title="",

**kwargs):

# Alternative names for existing parameters

if "window_info" in kwargs:

windowInfo = kwargs["window_info"]

del kwargs["window_info"]

if "settings" in kwargs:

browserSettings = kwargs["settings"]

del kwargs["settings"]

if "url" in kwargs:

navigateUrl = kwargs["url"]

del kwargs["url"]

for kwarg in kwargs:

raise Exception("Invalid argument: "+kwarg)

Debug("CreateBrowserSync() called")

# No CefCurrentlyOn(TID_UI) assert here. cefpython defers the real

# browser creation until OnContextInitialized fires (see below), so

# this function is reached before BrowserThread::UI is fully

# established — at which point CefCurrentlyOn() returns false and

# logs a WARNING (libcef/common/task_impl.cc). CEF's own

# CefBrowserHost::CreateBrowserSync() runs CONTEXT_STATE_VALID()

# plus its own thread checks internally, so a Python-side assert

# would only catch the same condition with a worse error message.

# Defer browser creation until OnContextInitialized fires.

#

# CefBrowserContext initialization is asynchronous: it is not finished

# when CefInitialize() returns, especially when external_message_pump

# is in use (our default — see _linux_apply_initialize_defaults). The

# OnContextInitialized callback is the documented signal that the

# browser context is ready (see upstream CEF commit 691c9c2 "Wait for

# CefBrowserContext initialization", 2021-04-14, issue #2969 — added

# the explicit wait when Chrome runtime introduced async Profile init).

#

# Calling CefBrowserHost::CreateBrowserSync before that point lets the

# renderer come up before its host bindings are wired, and the

# browser-process side then rejects the renderer's first IPC message

# with a "blink.mojom.WidgetHost" / "Message N rejected by interface"

# mojo error. The visible symptom is a blank page.

#

# Strategy:

# * Windows / macOS: cefpython.Initialize() already pumps up to 30s

# waiting for OnContextInitialized. If a caller reaches

# CreateBrowserSync earlier anyway (slow CI, custom Initialize

# override), pump another 30s here before giving up.

# * Linux (X11 and Wayland Ozone backends): skip the local pump,

# mirroring Initialize(). The deferred path always works: queue

# the request and let BrowserProcessHandler_OnContextInitialized

# drain it once cef.MessageLoop() starts the GLib loop.

# When this falls through still uninitialised, queue the request in

# g_pending_browsers for the OnContextInitialized handler to drain

# once the loop is actually running.

if not g_context_initialized:

Debug("CreateBrowserSync(): OnContextInitialized not yet received,"

" pumping message loop")

IF UNAME_SYSNAME != "Linux":

for _ in range(3000):

with nogil:

CefDoMessageLoopWork()

if g_context_initialized:

break

time.sleep(0.01)

if not g_context_initialized:

Debug("CreateBrowserSync() deferred until OnContextInitialized")

g_pending_browsers.append({

"windowInfo": windowInfo,

"browserSettings": browserSettings,

"navigateUrl": navigateUrl,

"window_title": window_title,

})

return None

"""

# Only title was set in hello_world.py example

if windowInfo and not windowInfo.windowType:

windowInfo.SetAsChild(0)

# No window info provided

if not windowInfo:

windowInfo = WindowInfo()

windowInfo.SetAsChild(0)

elif not isinstance(windowInfo, WindowInfo):

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

# On Linux, when no parent window is given, provide a top-level window

# so callers need no toolkit-specific code (same API as Windows/Mac).

_linux_toplevel_state = None

IF UNAME_SYSNAME == "Linux":

if windowInfo.windowType == "child" and windowInfo.parentWindowHandle == 0:

if _g_linux_wayland_mode:

# Native Wayland: CEF creates its own xdg_toplevel surface.

# Pass parent=0 with default bounds; no GTK window is needed.

_linux_toplevel_state = {'wayland': True}

windowInfo.SetAsChild(0, [0, 0, _LINUX_DEFAULT_WIDTH,

_LINUX_DEFAULT_HEIGHT])

else:

_linux_toplevel_state = _linux_create_toplevel(

window_title or "CEF Browser")

windowInfo.SetAsChild(

_linux_toplevel_state['xid'],

[0, 0, _linux_toplevel_state['width'],

_linux_toplevel_state['height']])

if window_title and windowInfo.parentWindowHandle == 0:

windowInfo.windowName = window_title

# Browser settings

if not browserSettings:

browserSettings = {}

# CEF Python only settings

if "inherit_client_handlers_for_popups" not in browserSettings:

browserSettings["inherit_client_handlers_for_popups"] = True

cdef CefBrowserSettings cefBrowserSettings

SetBrowserSettings(browserSettings, &cefBrowserSettings)

cdef CefWindowInfo cefWindowInfo

SetCefWindowInfo(cefWindowInfo, windowInfo)

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_shared_request_context.get())

cdef CefRefPtr[CefRequestContext] cefRequestContext

cdef CefRefPtr[RequestContextHandler] requestContextHandler =\

<CefRefPtr[RequestContextHandler]?>new RequestContextHandler(

cefBrowser)

if g_applicationSettings["unique_request_context_per_browser"]:

cefRequestContext = CefRequestContext.CreateContext(

CefRequestContext.GetGlobalContext(),

<CefRefPtr[CefRequestContextHandler]?>requestContextHandler)

elif createSharedRequestContext:

cefRequestContext = CefRequestContext.CreateContext(

CefRequestContext.GetGlobalContext(),

<CefRefPtr[CefRequestContextHandler]?>requestContextHandler)

g_shared_request_context.Assign(cefRequestContext.get())

else:

cefRequestContext.Assign(g_shared_request_context.get())

cdef CefRefPtr[CefDictionaryValue] extra_info

# CEF browser creation.

with nogil:

cefBrowser = cef_browser_static.CreateBrowserSync(

cefWindowInfo, <CefRefPtr[CefClient]?>clientHandler,

cefNavigateUrl, cefBrowserSettings, extra_info,

cefRequestContext)

if not cefBrowser or not cefBrowser.get():

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

return None

else:

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

Debug("CefBrowser window handle = "

+str(<uintptr_t>cefBrowser.get().GetHost().get().GetWindowHandle()))

# Make a copy as browserSettings is a reference only that might

# get destroyed later.

global g_browser_settings

cdef int browser_id = cefBrowser.get().GetIdentifier()

g_browser_settings[browser_id] = {}

for key in browserSettings:

g_browser_settings[browser_id][key] =\

copy.deepcopy(browserSettings[key])

# 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))

"""

if windowInfo.parentWindowHandle == 0\

and windowInfo.windowType == "child"\

and windowInfo.windowName:

# Set window title in hello_world.py example

IF UNAME_SYSNAME == "Linux":

# X11 title setting uses XStoreName which requires an X11 display.

# Skip on native Wayland; CEF's Ozone backend propagates the page

# title to the compositor via xdg_toplevel_set_title automatically.

if not _g_linux_wayland_mode:

x11.SetX11WindowTitle(cefBrowser,

PyStringToChar(windowInfo.windowName))

ELIF UNAME_SYSNAME == "Darwin":

MacSetWindowTitle(cefBrowser,

PyStringToChar(windowInfo.windowName))

IF UNAME_SYSNAME == "Linux":

if windowInfo._linux_embed_info:

_linux_schedule_xembed(pyBrowser, windowInfo._linux_embed_info)

if _linux_toplevel_state is not None:

if _linux_toplevel_state.get('wayland'):

# Native Wayland top-level: register a DoClose callback that

# quits the GLib loop. On Wayland, CloseHostWindow() is a

# compile-time no-op, so we must exit the loop ourselves when

# DoClose fires (either from CloseBrowser() or xdg_toplevel.close).

_linux_register_wayland_close_handler(pyBrowser)

# When SUPPORTS_OZONE_X11 is compiled, CreateHostWindow() creates

# both an X11/XWayland shell window (empty) and a Wayland

# xdg_toplevel with the actual browser content. Hide the empty

# X11 shell so only the content-bearing Wayland window is visible.

x11.HideX11ShellWindow(cefBrowser)

else:

# X11/XWayland top-level: attach GTK resize and close callbacks.

_linux_register_window_callbacks(pyBrowser, _linux_toplevel_state)

return pyBrowser

def MessageLoop():

Debug("MessageLoop()")

if not g_MessageLoop_called:

global g_MessageLoop_called

g_MessageLoop_called = True

IF UNAME_SYSNAME == "Linux":

_linux_message_loop()

ELSE:

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 g_MessageLoopWork_called:

global g_MessageLoopWork_called

g_MessageLoopWork_called = True

with nogil: