dxj19831029 / cefpython Goto Github PK

When running a wxPython or PyQt example we shouldn't require pywin32 extension, 
this dependency still persits in `window_utils_win.pyx` file.

What steps will reproduce the problem?
1. Send empty string from JS to Python.
2.
3.

What is the expected output? What do you see instead?
In python I get a garbage value, instead of the empty string that was passed.

What version of the product are you using? On what operating system?
cefPython 0.33 running Python 2.7 on Windows 7

Please provide any additional information below.

Seems that OnLoadEnd is not the same as DOMContentLoaded, when testing loading 
of big image it behaves more like window.onload. We need a built-in event when 
DOM is ready. We should inject javascript to listen for DOMContentLoaded, it is 
the event used by jQuery.ready().

See this topic on CEF forum for more details:
http://magpcss.org/ceforum/viewtopic.php?f=6&t=10277

Currently in V8Contexthandler::OnContextCreated() we save frames that are being 
created to a dictionary JavascriptBindings.__frames, it is needed later when 
calling Rebind() as we need to do rebinding in all frames of all browsers. But 
when browser or frame is destroyed it will result in error when we try to do 
rebinding in this non-existing frame. So we need to remove frames that are 
destroyed from the __frames dictionary, this needs to be done in 
OnContextReleased() of v8contexthandler.

It's a random error happening on application exit. I am able to reproduce it 
right now by doing a lot of clicks in the window, then closing it. The exact 
error message below:

python.exe - Application Error
---------------------------
The instruction at "0x7ca712b7" references memory at "0x00c5fe28". The memory 
could not be "read".
Click on OK to terminate the program
---------------------------

It sometimes references to "0x00c5feb0".

I tried running WinDbg but failed even to start the script with it, getting 
some kernel errors.

I tried running Spy++ and I see something strange happening in the top window 
(top-right of the screen), a WM_CLOSE message is called after WM_NCDESTROY. 
That window is created using pywin32 extension. There are 2 other inner windows 
created by CEF, but they seem to have proper messages,  there are no more 
messages processed after WM_NCDESTROY which is a correct behavior. Attaching 
!Spy++ screenshot.

What steps will reproduce the problem?

When i use the old version, I can use DisplayHandler_OnTitleChange to fix the 
utf8 tiitle. But WindowTextA is used in the window_utils_win.pyx  , it can not 
support utf8. 

PS: I am very glad to see the 41 issues is accepted so fast.

It is required to implement CefSchemeHandler to be able to load content from 
custom scheme.

Next step is to implement AES encryption/decryption using custom key, a tool 
for encryption would be useful. For an example of AES encryption analyze  
Asterclick WBEA sources: http://asterclick.drclue.net/WBEA.html

See this post on CEF forum where I explained how it works:
http://magpcss.org/ceforum/viewtopic.php?f=6&t=3564#p7179

This function is not reliable in handlers, many callbacks may be called before 
a browser is created, then this function returns None when it is the first 
browser, later it causes error when calling pyBrowser.GetHandler().

There seems to be appearing new cases every week, just a moment ago I had an 
error in DisplayHandler_OnStatusMessage() when running wxpython example.

Maybe we should make the second parameter "ignoreError" to be True by default? 
Or change the way it works completely, so we are able to get PyBrowser even 
during initialization of a browser.

In wiki documentation there are comments about this behavior in some of the 
handlers, for example LifeSpanHandler::OnAfterCreated():

    This function does not get called during creation of a browser initiated 
    through a call to cefpython.CreateBrowser(), it is a temporary limitation in 
    current implementation of cefpython. When a browser is created through 
    javascript "window.open" then this callback gets called.

This one is rather important if user wants to load content from virtual file 
systems.
Real-life use-case: games store resources in pak archives. Game UI could be 
implemented in cef and html/css/js files need to be loaded from archive.
Now we are bound to running tiny webserver in order to serve needed files to 
cef. When OnBeforeResourceLoad gets implemented we just could slip-in data from 
archive on loading attempt.

To add offscreen rendering we will have to expose api for CefWindowInfo & 
CefRenderHandler.

CefRenderHandler has following methods: GetViewRect(), GetScreenRect(), 
GetScreenPoint(), OnPopupShow(), OnPopupSize(), OnPaint(), OnCursorChange().
http://code.google.com/p/chromiumembedded/source/browse/trunk/cef1/include/cef_r
ender_handler.h

CefWindowInfo has with following methods: SetAsOffScreen(), 
SetTransparentPainting(), SetAsChild(), SetAsPopup().
http://code.google.com/p/chromiumembedded/source/browse/trunk/cef1/include/inter
nal/cef_win.h#101

SetAsPopup() is not available on Mac.

In CEF 1 off-screen rendering is available only on Windows & Mac.
There is an issue in the CEF Issue Tracker to add support for Linux:
http://code.google.com/p/chromiumembedded/issues/detail?id=594

In CEF 3 off-screen rendering was added recently and is only available on 
Windows, see the issue in the CEF Issue Tracker for more details:
http://code.google.com/p/chromiumembedded/issues/detail?id=518

Currently cython functions that are callable from C require writing lots of 
code. We could get rid of all the types defined in clienthandler.h and 
clienthandler.pxd if we used 'public' declarations, that way cython callbacks 
would be visible in C code automatically with no additional code, it would be 
so much easier to port CEF api.

'public' declarations:
http://docs.cython.org/src/userguide/external_C_code.html#public-declarations

Version 0.16 of Cython generates an error when you try to use 'public' or 'api' 
declarations. I've also had some other problems when I tried to use it, but 
these issues have been resolved, and we should evaluate using `public` 
declarations again, it will simplify code much.

New 0.17 version will be released soon, a few days ago there was released 0.17 
beta 3 rc:

https://groups.google.com/forum/?fromgroups=#!topic/cython-users/Tutevv3cSVc

To quote:
> This is our first and hopefully last release candidate for 0.17

Create popup window using window.open(), try scolling using mouse wheel - it 
doesn't work, you need to click in that window, only after that scrolling works.

To fix that it is required to implement CefLifeSpanHandler > OnAfterCreated() 
which is called after new window is created, call Browser.SetFocus() in that 
handler or do it the same as in cefpython.wm_SetFocus proc:

cdef HWND innerHwnd = (<CefBrowser*>(cefBrowser.get())).GetWindowHandle()
PostMessage(innerHwnd, WM_SETFOCUS, 0, 0)

Currently unicode strings are not supported and passing them as an argument to 
javascript function will result in error.

What do we need to do to support them? Some conversion before we can cast them 
to <char*>?

as title says \o/

code:
print cefpython.KEYEVENT_KEYUP
print cefpython.KEYEVENT_KEYDOWN
print cefpython.KEYEVENT_CHAR

produces:
2
1
3

however output should be:
0
1
2
according to this: 
https://code.google.com/searchframe#SgTHaFLUelA/trunk/include/cef_types.h&q=KT_K
EYUP%20package:chromiumembedded%5C.googlecode%5C.com&l=334

What steps will reproduce the problem?
1. Added this line:  browserSettings["fullscreen_enabled"] = True
2.
3.

What is the expected output? What do you see instead?
Full screen, like when you press F11 in Chrome.

What version of the product are you using? On what operating system?
CEF Python 0.41, Python 2.7, Windows 7

Please provide any additional information below.

Such a script would be a nice addition, in binary zip put it to a "py2exe" 
directory.

Implement CefApp > GetProxyHandler() > CefProxyHandler > GetProxyForUrl():
- UseDirect()
- UseNamedProxy()

Currently there are some issues with custom proxy handling, issue created here:
http://code.google.com/p/chromiumembedded/issues/detail?id=600

Also seems like by default CEF1 uses the default IE proxy settings and this may 
cause some problems, see here:
http://magpcss.org/ceforum/viewtopic.php?f=6&t=2586

Another topic regarding this matter here:
http://magpcss.org/ceforum/viewtopic.php?f=6&t=2639

This is a minor issue and might only affect people which run multiple python 
installations / python installed in the default directory on windows.

What steps will reproduce the problem?
1. Install python into its default location
2. Try compiling the client_handler module using Visual Studio 2008

What is the expected output? What do you see instead?
Expected: client_handler builds without problems.
Actual output: Compiler cannot find python include files.

What version of the product are you using? On what operating system?
Windows 7 32-bit, Python 2.7.2, cefpython revision 82835379a6b2a359

Please provide any additional information below.
Attached is a patch allowing users to configure the location of their python 
include files using the PYTHON_INCLUDE_PATH environment variable.

What steps will reproduce the problem?
1.import my_modual
2.while running CEF, change my_modual.py
3.reload(my_modual) ,which I'm binding to F5

What is the expected output? What do you see instead?
The change to my_modual.py should take effect

What version of the product are you using? On what operating system?
cef_python 3.7, for Python 2.7, on Window 7

Please provide any additional information below.
This is no show stopper, but could speed up testing if it worked.

Currently you can bind object to javascript but only by using 
JavascriptBindings.SetObject(). It would be useful to be able to pass a python 
object as a parameter to javascript function, or as a return value. This can by 
achieved by using javascript extensions mechanism.

See [Response] object.

To be able to do this we need to create cython definitions for the C++ 
STL::multimap object. In cython library only STL::map is available, see 
Cython/Includes/libcpp/map.pxd. Need to create similar file called 
multimap.pxd, only some of the stuff is needed: begin(), end(), iterator, 
insert.

What steps will reproduce the problem?
1. open a url secured with basic auth

What is the expected output? What do you see instead?
User/Password dialog or Method to implement it


What version of the product are you using? On what operating system?
0.33

Currently CEF Python binaries include version 9.0.30729.6161, but python 
binaries (ActivePython) have embedded manifest with version 9.0.21022.8.

Currently http auth dialog is implemented only for windows platform, it uses 
some c++ code and calls win32 native api:

http://code.google.com/p/cefpython/source/browse/cefpython1/httpauth/

Tkinter comes by default with any python, we could use it to display that modal 
dialog on all the platforms (win, mac, linux) using the same code.

Googling "tkinter dialog example" and "tkinter modal dialog" finds us nice 
examples.

Upfront, I know this sounds quite correct, especialy since an uncaught excepton 
will kill an app in python by design, but in JS/Browser/CEF it's a bit 
different, so bare with me...

Here is a trivial example:

We bind this Python function to the browser...
---cut---

def PyFunc(a, b, c):
    return [a, b, c]


--uncut--


And use it like so:

---cut---

var lst = PyFunc(1, 2)


--uncut--

This topples the while app first raising a python exception (logical) and then 
a memory error (possibly related to Issue #2).

Here is the obvious Python error:
'''
TypeError: PyFunc() takes exactly 3 arguments (2 given)
'''

Expected behavior:
- raise a JS exception.

Portable Python is a convenient way to distribute python applications across 
Windows users, as there's no need to pre-install anything in advance (including 
PyWin32). However, CEF 0.48 doesn't run on Portable Python environment due to 
lack of some C libraries.

To reproduce: please, get a Portable Python at 
http://www.portablepython.com/wiki/PortablePython2.7.3.1, extract it and try to 
execute cefpython on it.

OS: Windows XP, Windows 7

[deleted issue]

I've been working on a patch for CEF 1 to implement global v8 exception handler 
(a patch for CEF 3 is also in progress), the issue in CEF tracker can be found 
here:

http://code.google.com/p/chromiumembedded/issues/detail?id=736

The patch has been approved, see `revision 859` of branch 1180:
http://code.google.com/p/chromiumembedded/source/detail?r=859

There is a new setting called "oncaught_exception_stack_size", by default it is 
set to 0, thus the exception handler is disabled. There is also an 
OnUncaughtException() callback in V8ContextHandler.

Let's say I have a big class with lots of methods, allow me to bind the whole 
object and all its methods with just one line.

{{{
bindings.SetProperty("myobject", myobject)
}}}

In javascript you will be able to call:

{{{
window.myobject.method1()
window.myobject.method2()
window.myobject.method3()
}}}

Also make properties accessible:

{{{
window.myobject.property1
window.myobjevt.property2
}}}

Setting python object should also be possible using Frame.SetProperty().

We can list all methods/properties of a python object using dir():

{{{
class a:
    d = 1
    e = 2
    def b():
            pass
    def c():
            pass
a1 = a()
dir(a)
}}}

Returns:

{{{
['__doc__', '__module__', 'b', 'c', 'd', 'e']
}}}

All methods and properties that do not start with _ (checking single underscore 
should be enough) are considered public and will be made accessible to 
javascript provided that their types is one of:

 * list
 * bool
 * float
 * int
 * None
 * dict
 * string
 * function
 * instancemethod

What steps will reproduce the problem?
1. Running pygtk_.py sample program included in cefpython package

What is the expected output? What do you see instead?
I expect to get the output as shown in 
https://code.google.com/p/cefpython/wiki/PyGTK
with menubar and searchentry

Instead browser window is covering other widgets in PyGTK. Image added. I 
switched of browser window resize to see whats happening

What version of the product are you using? On what operating system?
I'm Using cefpython_0.41_windows_py2.7.zip and pygtk 2.24.0 on Windows 7

Please provide any additional information below.
wxPython renders menubar and browser window correctly

What version of the product are you using? On what operating system?
cefpython1_v0.51 with wxPython
Windows 7 Professional 32bit

The steps to reproduce the problem are:
  1- Open program and load a web page
  2- Open the link in the web page with onclick="window.open()" attribute

I've tried the same page with the old version ( cefpython1_v0.41 ) and the 
window appear without problem.

Anyone can help me?

Thanks

Feature Request: Build API for OSX

1. start panda3d demo, click very first link in page, then click downloads 
section
2. click dropdown element to expand menu

Should see dropdown menu displayed but instead app crashes.

Traceback (most recent call last):

  File "X:\src\games\p3d\Panda3D-1.8.0\direct\showbase\ShowBase.py", line 1844, in __igLoop
    self.graphicsEngine.renderFrame()

AssertionError: image_ptr >= orig_image_ptr && image_ptr + view_size <= 
orig_image_ptr + tex->get_ram_mipmap_image_size(n) at line 8893 of 
c:\buildslave\release_sdk_win32\build\panda3d\panda\src\glstuff\glGraphicsStateG
uardian_src.cxx

When python function is called from javascript we don't know from which browser 
or frame it originates. We should pass the context as a first argument, a frame 
or both, browser and frame. Passing only frame would be enough if we had 
!GetBrowser() method in Frame object. Or should we pass "context" dictionary 
with "browser" and "frame" keys?

Here is the python code...

---cut---

import json

def dumpJSON(path, data):
    with open(path, 'w') as f:
        json.dump(data, f, indent=4)

def loadJSON(path):
    with open(path) as f:
        return json.load(f)


--uncut--


Basic usage example:

---cut---

dumpJSON('data.json', {
  key: 'value'
})

var o = loadJSON('data.json')


--uncut--

The above code both raises a python exceptions and kills the CEF instance 
(another bug?)...

This is how it fails:
'''
Exception: PyValueToV8Value() failed: an unsupported python type was passed 
from python to javascript: unicode
'''


The problem lies is that by default, json serializer uses utf-8 for all strings 
(and the file itself)

Versions used:
CEFPython 0.35
Python 2.7.2
OS WinXP SP3

As suggested in another bug report ( 
https://code.google.com/p/cefpython/issues/detail?id=49 ) - this seems to be 
much better option for serving files from virtual file systems. Turns out we 
can have fake domains for default http scheme therefore this would actually be 
preferred way of achieving the goal.


May i request some pointers on implementing required interfaces? At the moment 
im sort of bouncing around existing stuff trying to figure out what would be 
the best way to do this. Mind i dont have any cython experience.

At the moment my plan looks like this:
create c++ class:
class CustomSchemeHandler : public CefSchemeHandlerFactory, public 
CefSchemeHandler

This would be much like ClientHandler, calling cdef'ed functions that would 
in-turn call methods of python object.

Actual creation of custom scheme handler would look something like:
cdef py_bool RegisterSchemeHandlerFactory(str scheme_name, str domain_name, 
object factory):
    cefFactory = MakeCefFactory(factory)
    cefDomainName = PyToCefString(domain_name)
    CefRegisterSchemeHandlerFactory(PyToCefString(scheme_name), cefDomainName, cefFactory) 
there factory should be stored in c++ object cefFactory and it's functions like 
ProcessRequest would be called later.

Does that sound right?

Support for Video & Audio has been removed from CEF 1:

> Due to the loss of audio playback capability in Chromium revision 122508
> and the general lack of playback performance as compared to CEF3 we will 
> discontinue support for the HTML5 audio and video tags in CEF1. We can 
> reconsider this decision in the future if/when a new audio implementation 
> becomes available.

See this issue: http://code.google.com/p/chromiumembedded/issues/detail?id=530

It might still come back in CEF 1, but there is no know date. The solution to 
this problem is to use CEF 3, but there is no python port yet for CEF 3, though 
I plan to work on it in some future.

The solution for now is to use an older release of CEF Python, version 0.37 
should support audio & video:

http://code.google.com/p/cefpython/downloads/detail?name=cefpython_0.37_windows_
py2.7.zip

Branch 1084 (Chrome 19) of CEF 1 supports audio and video, but it would too 
much hassle for me to support 2 different branches.

The best would be to go for CEF Python 3 and have all the latest support for 
Chrome features, but it's a lot of work to do.

What steps will reproduce the problem?
1.python pyqt4.py
2.Click the close button
3.

What is the expected output? What do you see instead?
Expected is no output, instead I get this on the console.
[1127/084154]:ERROR_REPORT:browser_impl.h(181)] Check failed: 
CefThread::CurrentlyOn(CefThread::UI).

What version of the product are you using? On what operating system?
cefpython 0.45

Please provide any additional information below.
Curiously, this issue appears on my system but on another system it works 
without a problem.

1. Downloaded the 2.7 archive & extracted
2. Opened a command prompt in the cefpython directory
3. Tried the commands 'cefsimple.py' and 'cefadvanced.py'

Here's the output for cefsimple.py:
{{{
Traceback (most recent call last):
  File "cefsimple.py", line 4, in <module>
    import cefpython
ImportError: DLL load failed: %1 is not a valid Win32 application.
}}}

And cefadvanced.py:
{{{
Traceback (most recent call last):
  File "cefadvanced.py", line 5, in <module>
    import cefpython # cefpython.pyd
ImportError: DLL load failed: %1 is not a valid Win32 application.
}}}

The python version:
Python 2.7 (r27:82525, Jul  4 2010, 07:43:08) [MSC v.1500 64 bit (AMD64)] on 
win32

The OS version:
I'm running on Windows 7(x64)

Additional info:
I tried a few things first, including installing pywin32 and wxpython(x64).

After a bit of searching on Google I think I managed to figure out the issue. 
pyd files get compiled to specific architectures. So, if the one you provide in 
the archive is targeted to x32 then a x64 version is also needed. 

I tried loading the samples after deleting cefpython.pyd and the program 
executed without triggering an error but no window was shown. No surprise there 
as the cefpython.CreateBrowser() statement never gets called.

Launching the 'cefwindow.py' command also works without issue. All it loads is 
a blank window.

Hopefully this helps...

Recent releases of cefpython have DCHECKs enabled by default, it might hurt 
performance, a better way is to make it configurable through an option in 
ApplicationSettings.

There is an issue in CEF tracker for new program switches to enable DCHECKs in 
release mode:
http://code.google.com/p/chromiumembedded/issues/detail?id=790

In RequestHandler::GetCookieManager if you return NULL a global cookie manager 
will be used. If you do not want to share cookies across browsers 
CefCookieManager object should be returned here, you can create one with a call 
to:

    CefCookieManager::CreateManager(string cache_path)

If cache_path is empty then data will be stored in memory only. A global cookie 
manager also uses memory by default, unless you set 
ApplicationSettings.cache_path.

Guy's, can someone help me with ways to achieve automation testing for content 
(web pages) loaded into CEF browser instances. By Automation, I mean to say 
that if I have a CEF Client app and a page is loaded into a browser area, I 
should be able to put text into text boxes or click buttons etc within the page 
etc.

Just to give an example scenario. Lets say I click some button in the native 
client area and it opens a browser area in the client and loads a page with 
some text fields and buttons. My automation test should be able to click the 
button in the native window to open the page, enter some data in the web page 
fields and click the submit button in the page.

Feature request: remove the requirement to run it on Windows.

What steps will reproduce the problem?
1. Sync current head
2. Change the compile time constants to produce CEF3 bindings
3. Follow the build instructions

What is the expected output? What do you see instead?
Expected: Bindings for CEF3 are generated.
Actual: Some compilation errors related to things that are only available when 
CEF_VERSION==1

What version of the product are you using? On what operating system?
Git revision 82835379a6b2

Please provide any additional information below.
Note that I am not 100% certain that this is the correct fix, but it worked 
good enough for me to get the PySide and wxPython examples to run with latest 
head.

Hello!
How can I automate the filling of the search string (for example google.com) 
using cefpython?

In wxPython & PyQt when you open a popup and close it, followed by closing main 
window, then application's loop is still running. When you close the main 
window before closing the popup, then you won't be able to close the popup.

In PyGTK & PySide application crashes when opening a popup.

Implement CefDisplayHandler.OnTitleChange().

 HWND hwnd = browser->GetWindowHandle();
 SetWindowText(hwnd, CefString(title).ToWString().c_str());

What steps will reproduce the problem?
1. popup window do not  loaded parent clientHandler

when creating new PyBrowser, this need copy the parent clientHandler
    28      Debug("GetPyBrowser(): creating new PyBrowser, browserId=%s" % browserId)
    29      pyBrowser = PyBrowser()
    30      pyBrowser.cefBrowser = cefBrowser
    31      g_pyBrowsers[browserId] = pyBrowser

my cefpython version:
$git log -1
commit 57c9686ba55171e3b484b043154ef8096be795c7
Author: Czarek Tomczak <[email protected]>
Date:   Fri Dec 14 19:18:03 2012 -0800

    Removed pywin32 dependence from the PYD module (Issue 38).

Create Cookie class for the CefCookie structure.

Expose CefCookieManager methods:
- VisitAllCookies(visitor)
- VisitUrlCookies(url, httponly, visitor)
- SetCookie(url, cookie)
- DeleteCookies(url, cookie_name)

CefCookieManager methods SetCookie/VisitUrlCookies require passing an url, we 
could create a helper method in Frame called SetCookie(cookie) that uses 
frame's current url when calling CefCookieManager.SetCookie().

the title say it all: python 3 is out since quite some time, and it would be 
great if cefpython provided python 3 bindings.