# Copyright (c) 2012 CEF Python, see the Authors file.
# All rights reserved. Licensed under BSD 3-clause license.
# Project website: https://github.com/cztomczak/cefpython

# IMPORTANT notes:
#
# - cdef/cpdef functions returning something other than a Python object
#   should have in its declaration "except *", otherwise exceptions are
#   ignored. Those cdef/cpdef that return "object" have "except *" by
#   default. The setup/compile.py script will check for functions missing
#   "except *" and will display an error message about that, but it's
#   not perfect and won't detect all cases.
#
# - TODO: add checking for "except * with gil" in functions with the
#   "public" keyword
#
# - about acquiring/releasing GIL lock, see discussion here:
#   https://groups.google.com/forum/?fromgroups=#!topic/cython-users/jcvjpSOZPp0
#
# - <CefRefPtr[ClientHandler]?>new ClientHandler()
#   <...?> means to throw an error if the cast is not allowed
#
# - in client handler callbacks (or others that are called from C++ and
#   use "except * with gil") must embrace all code in try..except otherwise
#   the error will  be ignored, only printed to the output console, this is the
#   default behavior of Cython, to remedy this you are supposed to add "except *"
#   in function declaration, unfortunately it does not work, some conflict with
#   CEF threading, see topic at cython-users for more details:
#   https://groups.google.com/d/msg/cython-users/CRxWoX57dnM/aufW3gXMhOUJ.
#
# -  Note that acquiring the GIL is a blocking thread-synchronising operation,
#    and therefore potentially costly. It might not be worth releasing the GIL
#    for minor calculations. Usually, I/O operations and substantial
#    computations in parallel code will benefit from it.
#
# -  In regards to GIL locks see Issue #102 "Remove GIL to avoid deadlocks when
#    calling CEF functions".
#
# - CTags requires all functions/methods imported in .pxd files to be preceded with "cdef",
#   otherwise they are not indexed.
#
# - __del__ method does not exist in Extension Types (cdef class),
#   you have to use __dealloc__ instead, try to remember that as
#   defining __del__ will not raise any warning and could lead to
#   memory leaks.
#
# - CefString.c_str() is safe to use only on Windows, on Ubuntu 64bit
#   for a "Pers" string it returns: "P\x00e\x00r\x00s\x00", which is
#   most probably not what you expected.
#
# - You can rename methods when importing in pxd files:
#   | cdef cppclass _Object "Object":
#
# - Supporting operators that are not yet supported:
#   | RetValue& Assign "operator="(T* p)
#   | object.Assign(T*)
#   In the same way you can import function with a different name, this one
#   imports a static method Create() while adding a prefix "CefSome_":
#   | cdef extern from "..":
#   |   static CefRefPtr[CefSome] CefSome_Create "CefSome::Create"()
#
# - Declaring C++ classes in Cython. Storing python callbacks
#   in a C++ class using Py_INCREF, Py_DECREF. Calling from
#   C++ using PyObject_CallMethod.
#   | http://stackoverflow.com/a/17070382/623622
#   Disadvantage: when calling python callback from the C++ class
#   declared in Cython there is no easy way to propagate the python
#   exceptions when they occur during execution of the callback.
#
# - | cdef char* other_c_string = py_string
#   This is a very fast operation after which other_c_string points
#   to the byte string buffer of the Python string itself. It is
#   tied to the life time of the Python string. When the Python
#   string is garbage collected, the pointer becomes invalid.
#
# - When defining cpdef functions returning "cpp_bool":
#   | cpdef cpp_bool myfunc() except *:
#   Always do an additional cast when returning value, even when
#   variable is defined as py_bool:
#   | cdef py_bool returnValue
#   | return bool(returnValue)
#   Otherwise compiler warnings appear:
#   | cefpython.cpp(26533) : warning C4800: 'int' : forcing value
#   | to bool 'true' or 'false' (performance warning)
#   Lots of these warnings results in ignoring them, but sometimes
#   they are shown for a good reason. For example when you forget
#   to return a value in a function.
#
# - Always import bool from libcpp as cpp_bool, if you import it as
#   "bool" in a pxd file, then Cython will complain about bool casts
#   like "bool(1)" being invalid, in pyx files.
#
# - malloc example code:
#   from libc.stdlib cimport malloc, free
#   cdef RECT* rect = <RECT*>malloc(sizeof(RECT))
#   free(rect)
#

# All .pyx files need to be included in this file.
# Includes being made in other .pyx files are allowed to help
# IDE completion, but will be removed during cython compilation.

include "compile_time_constants.pxi"

# -----------------------------------------------------------------------------
# IMPORTS

# noinspection PyUnresolvedReferences
import os
import sys
# noinspection PyUnresolvedReferences
import cython
# noinspection PyUnresolvedReferences
import platform
# noinspection PyUnresolvedReferences
import traceback
# noinspection PyUnresolvedReferences
import time
# noinspection PyUnresolvedReferences
import types
# noinspection PyUnresolvedReferences
import re
# noinspection PyUnresolvedReferences
import copy
# noinspection PyUnresolvedReferences
import inspect # used by JavascriptBindings.__SetObjectMethods()
# noinspection PyUnresolvedReferences
import urllib
# noinspection PyUnresolvedReferences
import json
# noinspection PyUnresolvedReferences
import datetime
# noinspection PyUnresolvedReferences
import random
# noinspection PyUnresolvedReferences
import struct
# noinspection PyUnresolvedReferences
import base64

# Must use compile-time condition instead of checking sys.version_info.major
# otherwise results in "ImportError: cannot import name urlencode" strange
# error in Python 3.6.
IF PY_MAJOR_VERSION == 2:
    # noinspection PyUnresolvedReferences
    import urlparse
    # noinspection PyUnresolvedReferences
    from urllib import urlencode as urllib_urlencode
    from urllib import quote as urlparse_quote
ELSE:
    # noinspection PyUnresolvedReferences
    from urllib import parse as urlparse
    from urllib.parse import quote as urlparse_quote
    # noinspection PyUnresolvedReferences
    from urllib.parse import urlencode as urllib_urlencode

# noinspection PyUnresolvedReferences
from cpython.version cimport PY_MAJOR_VERSION
# noinspection PyUnresolvedReferences
import weakref

# We should allow multiple string types: str, unicode, bytes.
# PyToCefString() can handle them all.
# Important:
#   If you set it to basestring, Cython will accept exactly(!)
#   str/unicode in Py2 and str in Py3. This won't work in Py3
#   as we might want to pass bytes as well. Also it will
#   reject string subtypes, so using it in publi API functions
#   would be a bad idea.
ctypedef object py_string

# You can't use "void" along with cpdef function returning None, it is
# planned to be added to Cython in the future, creating this virtual
# type temporarily. If you change it later to "void" then don't forget
# to add "except *".
ctypedef object py_void

# noinspection PyUnresolvedReferences
from cpython cimport PyLong_FromVoidPtr
# noinspection PyUnresolvedReferences
from cpython cimport bool as py_bool
# noinspection PyUnresolvedReferences
from libcpp cimport bool as cpp_bool
# noinspection PyUnresolvedReferences
from libcpp.map cimport map as cpp_map
# noinspection PyUnresolvedReferences
from multimap cimport multimap as cpp_multimap
# noinspection PyUnresolvedReferences
from libcpp.pair cimport pair as cpp_pair
# noinspection PyUnresolvedReferences
from libcpp.vector cimport vector as cpp_vector
# noinspection PyUnresolvedReferences
from libcpp.string cimport string as cpp_string
# noinspection PyUnresolvedReferences
from wstring cimport wstring as cpp_wstring
# noinspection PyUnresolvedReferences
from libc.string cimport strlen
# noinspection PyUnresolvedReferences
from libc.string cimport memcpy
# preincrement and dereference must be "as" otherwise not seen.
# noinspection PyUnresolvedReferences
from cython.operator cimport preincrement as preinc, dereference as deref
# noinspection PyUnresolvedReferences

# from cython.operator cimport address as addr # Address of an c++ object?

# noinspection PyUnresolvedReferences
from libc.stdlib cimport calloc, malloc, free
# noinspection PyUnresolvedReferences
from libc.stdlib cimport atoi

# When pyx file cimports * from a pxd file and that pxd cimports * from another pxd
# then these names will be visible in pyx file.

# Circular imports are allowed in form "cimport ...", but won't work if you do
# "from ... cimport *", this is important to know in pxd files.

# noinspection PyUnresolvedReferences
from libc.stdint cimport uint64_t
# noinspection PyUnresolvedReferences
from libc.stdint cimport uintptr_t

# noinspection PyUnresolvedReferences
ctypedef uintptr_t WindowHandle

# noinspection PyUnresolvedReferences
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 *

IF UNAME_SYSNAME == "Linux":
    cimport x11

from cef_string cimport *
cdef extern from *:
    # noinspection PyUnresolvedReferences
    ctypedef CefString ConstCefString "const CefString"

# cannot cimport *, that would cause name conflicts with constants
# noinspection PyUnresolvedReferences
from cef_types cimport (
    CefSettings, CefBrowserSettings, CefRect, CefSize, CefPoint,
    CefKeyEvent, CefMouseEvent, CefScreenInfo,
    PathKey, PK_DIR_EXE, PK_DIR_MODULE,
    int32, uint32, int64, uint64,
    cef_log_severity_t,
)

# noinspection PyUnresolvedReferences
from cef_ptr cimport CefRefPtr

# noinspection PyUnresolvedReferences
from cef_scoped_ptr cimport scoped_ptr

from cef_task cimport *
from cef_platform cimport *
from cef_app cimport *
from cef_browser cimport *
# noinspection PyUnresolvedReferences
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 *
# noinspection PyUnresolvedReferences
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 *
# noinspection PyUnresolvedReferences
from cef_views cimport *
from cef_log cimport *
from cef_file_util cimport *

# -----------------------------------------------------------------------------
# GLOBAL VARIABLES

g_debug = False

# When put None here and assigned a local dictionary in Initialize(), later
# while running app this global variable was garbage collected, see topic:
# https://groups.google.com/d/topic/cython-users/0dw3UASh7HY/discussion
# The string_encoding key must be set early here and also in Initialize.
g_applicationSettings = {"string_encoding": "utf-8"}
g_commandLineSwitches = {}
g_browser_settings = {}

# If ApplicationSettings.unique_request_context_per_browser is False
# then a shared request context is used for all browsers. Otherwise
# a unique one is created for each call to CreateBrowserSync.
# noinspection PyUnresolvedReferences
cdef CefRefPtr[CefRequestContext] g_shared_request_context

cdef scoped_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 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 "web_plugin_info.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"

# Handlers
include "handlers/accessibility_handler.pyx"
include "handlers/browser_process_handler.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"

# -----------------------------------------------------------------------------
# Utility functions to provide settings to the C++ browser process code.

cdef public void cefpython_GetDebugOptions(
        cpp_bool* debug
        ) except * 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 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 = PyStringToChar(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

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

# If you've built custom binaries with tcmalloc hook enabled on
# Linux, then do not to run any of the CEF code until Initialize()
# is called. See Issue #73 in the CEF Python Issue Tracker.

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 UNAME_SYSNAME == "Linux":
        # Fix Issue #231 - Discovery of the "icudtl.dat" file fails on Linux.
        cdef str py_module_dir = GetModuleDirectory()
        cdef CefString cef_module_dir
        PyToCefString(py_module_dir, cef_module_dir)
        CefOverridePath(PK_DIR_EXE, cef_module_dir)\
                or Debug("ERROR: CefOverridePath failed")
        CefOverridePath(PK_DIR_MODULE, cef_module_dir)\
                or Debug("ERROR: CefOverridePath failed")
    # END IF UNAME_SYSNAME == "Linux":

    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
    if not "single_process" in application_settings:
        application_settings["single_process"] = 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"] = ""


    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

    # 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
    # No sandboxing for the subprocesses
    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")
        # Using .reset() here to assign new instance was causing
        # MainMessageLoopExternalPump destructor to be called. Strange.
        g_external_message_pump.Assign(
                MainMessageLoopExternalPump.Create())

    Debug("CefInitialize()")
    cdef cpp_bool ret
    with nogil:
        ret = CefInitialize(cefMainArgs, cefApplicationSettings, cefApp, NULL)

    global g_cef_initialized
    g_cef_initialized = True

    if not ret:
        Debug("CefInitialize() failed")

    IF UNAME_SYSNAME == "Linux":
        # Install by default.
        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")
    assert IsThread(TID_UI), (
            "cefpython.CreateBrowserSync() may only be called on the UI thread")

    """
    # CEF views
    # noinspection PyUnresolvedReferences
    cdef CefRefPtr[CefWindow] cef_window
    # noinspection PyUnresolvedReferences
    cdef CefRefPtr[CefBoxLayout] cef_box_layout
    cdef CefBoxLayoutSettings cef_box_layout_settings
    cdef CefRefPtr[CefPanel] cef_panel
    if not windowInfo and browserSettings \
            and "window_title" in browserSettings:
        # noinspection PyUnresolvedReferences
        cef_window = CefWindow.CreateTopLevelWindow(
                <CefRefPtr[CefWindowDelegate]?>NULL)
        Debug("CefWindow.GetChildViewCount = "
              +str(cef_window.get().GetChildViewCount()))

        cef_window.get().CenterWindow(CefSize(800, 600))
        cef_window.get().SetBounds(CefRect(0, 0, 800, 600))
        # noinspection PyUnresolvedReferences
        #cef_box_layout = cef_window.get().SetToBoxLayout(
        #        cef_box_layout_settings)
        #cef_box_layout.get().SetFlexForView(cef_window, 1)
        cef_window.get().SetToFillLayout()
        # noinspection PyUnresolvedReferences
        cef_panel = CefPanel.CreatePanel(<CefRefPtr[CefPanelDelegate]?>NULL)
        cef_window.get().AddChildView(cef_panel)
        cef_window.get().Layout()
        cef_window.get().SetVisible(True)
        cef_window.get().Show()
        cef_window.get().RequestFocus()
        windowInfo = WindowInfo()
        windowInfo.SetAsChild(cef_window.get().GetWindowHandle())
        Debug("CefWindow handle = "
              +str(<uintptr_t>cef_window.get().GetWindowHandle()))
    """

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

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

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

    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 cef_window.get():
        cef_window.get().ReorderChildView(cef_panel, -1)
        cef_window.get().Layout()
        cef_window.get().Show()
        cef_window.get().RequestFocus()
    """

    if windowInfo.parentWindowHandle == 0\
            and windowInfo.windowType == "child"\
            and windowInfo.windowName:
        # Set window title in hello_world.py example
        IF UNAME_SYSNAME == "Linux":
            x11.SetX11WindowTitle(cefBrowser,
                                  PyStringToChar(windowInfo.windowName))
        ELIF UNAME_SYSNAME == "Darwin":
            MacSetWindowTitle(cefBrowser,
                              PyStringToChar(windowInfo.windowName))

    return pyBrowser

def MessageLoop():
    Debug("MessageLoop()")

    if not g_MessageLoop_called:
        global g_MessageLoop_called
        g_MessageLoop_called = True

    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:
        CefDoMessageLoopWork()

def SingleMessageLoop():
    # @deprecated, use MessageLoopWork() instead
    MessageLoopWork()

def QuitMessageLoop():
    Debug("QuitMessageLoop()")
    with nogil:
        CefQuitMessageLoop()

def Shutdown():
    Debug("Shutdown()")

    # Run some message loop work, force closing browsers and then run
    # some message loop work again for the browsers to close cleanly.
    #
    # UPDATE: This code needs to be rechecked. There were enhancements
    #         to unrferencing globally stored Browser objects in
    #         g_pyBrowsers. See Issue #330 and its commits.
    #
    # CASE 1:
    # There might be a case when python error occured after creating
    # browser, but before any message loop was run. In such case
    # the renderer process won't be terminated unless we run some
    # message loop work here first, close browser and free
    # reference, and then run some message loop work again.
    #
    # CASE 2:
    # Application closes browser and then calls CEF shutdown. We need
    # to run some message loop work so that browser can close cleanly.
    # Looks like running message loop work is also required when
    # application runs MessageLoop() (Issue #282 and the hello_world.py
    # example).
    #
    # CASE 3:
    # Run some message loop work to fix 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/

    # This 0.2 sec message loop work should close browsers and clean
    # CEF references. Even when CloseBrowser(True) wasn't called
    # in client app, then this code below should close it cleanly.
    # Looks like CEF detects that parent window was destroyed
    # and closes browser automatically if you give it some time.
    # If the time was not enough, then there is an emergency plan,
    # the code block further down that checks len(g_pyBrowsers).
    for _ in range(20):
        for __ in range(10):
            with nogil:
                CefDoMessageLoopWork()
        time.sleep(0.01)

    # Emergency plan in case the code above didn't close browsers,
    # and neither browsers were closed in client app. This code
    # will force closing browsers by calling CloseBrowser(True)
    # and then free global g_pyBrowsers list that keeps CEF
    # references alive.
    if len(g_pyBrowsers):
        browsers_list = []
        for browserId in g_pyBrowsers:
            # Cannot close browser here otherwise error:
            # > dictionary changed size during iteration
            browsers_list.append(browserId)
        browser_close_forced = False
        for browserId in browsers_list:
            browser = GetPyBrowserById(browserId)
            if browser and browserId not in g_closed_browsers:
                Debug("WARNING: Browser was not closed with CloseBrowser call."
                      " Will close it safely now, but this will delay CEF"
                      " shutdown by 0.2 sec.")
                browser.CloseBrowser(True)
                browser_close_forced = True
            browser = None  # free reference
            RemovePyBrowser(browserId)
        if browser_close_forced:
            for _ in range(20):
                for __ in range(10):
                    with nogil:
                        CefDoMessageLoopWork()
                time.sleep(0.01)
        # Message loop work was run, so handlers callbacks might got called
        # and browsers might still be in g_pyBrowsers.
        for browserId in browsers_list:
            if browserId in g_pyBrowsers:
                RemovePyBrowser(browserId)

    # If the the two code blocks above, that tried to close browsers
    # and free CEF references, failed, then display an error about it!
    if len(g_pyBrowsers):
        NonCriticalError("Shutdown called, but there are still browser"
                         " references alive")

    # Release shared request context. In the past this was sometimes
    # causing segmentation fault. See Issue #333:
    # https://github.com/cztomczak/cefpython/issues/333
    # Debug("Free g_shared_request_context")
    # g_shared_request_context.Assign(NULL)

    # Release external message pump before CefShutdown, so that
    # message pump timer is killed.
    if g_external_message_pump.get():
        Debug("Reset external message pump")
        # Reset will set it to NULL
        g_external_message_pump.reset()

    Debug("CefShutdown()")
    with nogil:
        CefShutdown()

    # Additional cleanup on Mac, see util_mac.mm.
    IF UNAME_SYSNAME == "Darwin":
        MacShutdown()

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
    # Global callbacks are prefixed with "_" in documentation.
    # Accept both with and without a prefix.
    if name.startswith("_"):
        name = name[1:]
    if name in ["OnCertificateError", "OnBeforePluginLoad", "OnAfterCreated",
                "OnAccessibilityTreeChange", "OnAccessibilityLocationChange"]:
        g_globalClientCallbacks[name] = callback
    else:
        raise Exception("SetGlobalClientCallback() failed: "\
                "invalid callback name = %s" % name)

cpdef py_void SetGlobalClientHandler(object clientHandler):
    if not hasattr(clientHandler, "__class__"):
        raise Exception("SetGlobalClientHandler() failed: __class__ "
                        "attribute missing")
    cdef dict methods = {}
    cdef py_string key
    cdef object method
    cdef tuple value
    for value in inspect.getmembers(clientHandler,
            predicate=inspect.ismethod):
        key = value[0]
        method = value[1]
        if key and key[0:2] != '__':
            SetGlobalClientCallback(key, method)

cpdef object GetGlobalClientCallback(py_string name):
    global g_globalClientCallbacks
    if name in g_globalClientCallbacks:
        return g_globalClientCallbacks[name]
    else:
        return None

cpdef object GetAppSetting(py_string key):
    global g_applicationSettings
    if key in g_applicationSettings:
        return g_applicationSettings[key]
    return None

cpdef dict GetVersion():
    # These variable are set when building the module.
    # noinspection PyUnresolvedReferences
    return dict(
        version=__version__,
        chrome_version=__chrome_version__,
        cef_version=__cef_version__,
        cef_api_hash_platform=__cef_api_hash_platform__,
        cef_api_hash_universal=__cef_api_hash_universal__,
        cef_commit_hash=__cef_commit_hash__,
        cef_commit_number=__cef_commit_number__,
    )

cpdef LoadCrlSetsFile(py_string path):
    CefLoadCRLSetsFile(PyToCefStringValue(path))

cpdef GetDataUrl(data, mediatype="html"):
    if PY_MAJOR_VERSION >= 3:
        data = data.encode("utf-8", "replace")
    b64 = base64.b64encode(data).decode("utf-8", "replace")
    ret = "data:text/html;base64,{data}".format(data=b64)
    return ret
