30771 2009-10-26 06:13:12 -0700 [Qt] Make qwebpage's createWindow not qwebview dependent 2009-11-11 13:52:19 -0800 1 1 1 Unclassified WebKit WebKit Qt 528+ (Nightly build) PC All RESOLVED FIXED Qt P2 Normal --- 1 tonikitoo tonikitoo ariya.hidayat benjamin hausmann kenneth laszlo.gombos vestbo oldest_to_newest 157745 0 tonikitoo 2009-10-26 06:13:12 -0700 Currently, qwebpage's createWindow virtual is totatly dependent on qwebview, which is wrong by design, now that we have PageClient. QWebPage *QWebPage::createWindow(WebWindowType type) { QWebView *webView = qobject_cast<QWebView *>(view()); if (webView) { QWebView *newView = webView->createWindow(type); if (newView) return newView->page(); } return 0; } Attached patch (coming) changes that for qwebpage+qwebview and implements it for qwebpage+qgraphicswebview createWindow. 157747 1 41862 tonikitoo 2009-10-26 06:18:37 -0700 Created attachment 41862 patch 0.1 Patch does: 1) makes qwebpage::createWindow widget independent (pageClient used now). 2) adds a pure virtual createWindow method to qwebpageclient. 3) fixes some minor nits ("*" position and such) 157826 2 kenneth 2009-10-26 10:55:01 -0700 Generally, I dont like much the original method. First of all, the method is called by webkit, but the API user can call it as well (not very well explained in the documentation). It returns a reference to QWebView and now you introduced a verson returning QGraphicsWebView. That seems very limiting to me. Maybe I want to return a more real widget (like a BrowerWindow) or even a QWebView from a QGraphicsWebView implementation. Thus, shouldn't we make the new QGraphicsWebView version return a QObject instead? +QGraphicsWebView *QGraphicsWebView::createWindow(QWebPage::WebWindowType type) +{ + Q_UNUSED(type) + return 0; the Q_UNUSED is not needed, just leave out "type". Is it possible to make this work without adding these specialized methods to QWebPageClient. We need to consider very much what we add there, and whether it really makes sense. 157828 3 tonikitoo 2009-10-26 11:05:33 -0700 thx for commenting. (In reply to comment #2) > Generally, I dont like much the original method. First of all, the method is > called by webkit, but the API user can call it as well (not very well explained in the documentation). hum, it is protected, so it should not be totally callable, unless you are re-implementing the class (and then knows what you are doing). > It returns a reference to QWebView and now you > introduced a verson returning QGraphicsWebView. That seems very limiting to me. > Maybe I want to return a more real widget (like a BrowerWindow) or even a > QWebView from a QGraphicsWebView implementation. Thus, shouldn't we make the > new QGraphicsWebView version return a QObject instead? i am particularly ok w/ that. > +QGraphicsWebView *QGraphicsWebView::createWindow(QWebPage::WebWindowType type) > +{ > + Q_UNUSED(type) > + return 0; > > the Q_UNUSED is not needed, just leave out "type". will do. as per ariya's request, i will check some autotests for it. > Is it possible to make this work without adding these specialized methods to > QWebPageClient. We need to consider very much what we add there, and whether it > really makes sense. pageClient is meant to be an interface to add widget specific methods, or to abstract the widget (either qwebview or qgraphicswebview for now) from the internal classes. that is why i extended it. 157829 4 kenneth 2009-10-26 11:13:22 -0700 > hum, it is protected, so it should not be totally callable, unless you are > re-implementing the class (and then knows what you are doing). Then there is not much sense is having it return something, is there? What is the use-case? > pageClient is meant to be an interface to add widget specific methods, or to > abstract the widget (either qwebview or qgraphicswebview for now) from the > internal classes. that is why i extended it. I know what it is for, as I actually implemented it. What I'm trying to say here is that we should only add very generic and needed things, as I don't want this to end up as a dumping ground. 157840 5 tonikitoo 2009-10-26 11:44:24 -0700 thx for commenting again. > > hum, it is protected, so it should not be totally callable, unless you are > > re-implementing the class (and then knows what you are doing). > > Then there is not much sense is having it return something, is there? What is > the use-case? not sure if i get you correct here. For new window we do not need a new widget (e.g. qwebview or qgraphicswebview) ? I think we do and usecases are simple: popups, JS open-in-another-window, etc. again, method createWindow is already there for qwebview. logic backtrace: 1) ChromeClientQt::createWindow (WebCore needs a Page object) - calls 2) QWebPage::createWindow - calls pageClient's createWindow, abstracting the widget. 3) QXXXWebView::createWindow - creates a new widget, and retuns *internally* to the application whom maybe want to attach the widget to TAB or what ever ( again it is protected +- internal) 4) qXXXwebview has a qwebpage that has a Page , which is needed to WebCore for a new window. > What I'm trying to say > here is that we should only add very generic and needed things, as I don't want > this to end up as a dumping ground. do you think is it not generic enough to be there? i am open to suggestions. > I know what it is for, as I actually implemented it. i know, i know ... great contrib btw :) 157845 6 tonikitoo 2009-10-26 11:52:10 -0700 > Then there is not much sense is having it return something, is there? What is > the use-case? maybe i am seeing a problem: when user implements qwebpage::createWindow but not qXXXwebview::createWindow ... checking 157851 7 kenneth 2009-10-26 11:58:46 -0700 (In reply to comment #5) > thx for commenting again. > > > > hum, it is protected, so it should not be totally callable, unless you are > > > re-implementing the class (and then knows what you are doing). > > > > Then there is not much sense is having it return something, is there? What > 3) QXXXWebView::createWindow - creates a new widget, and retuns *internally* to > the application whom maybe want to attach the widget to TAB or what ever ( > again it is protected +- internal) The reimplemented can easily do this internally without needing it to return anything. I guess this was only done for being able to return the page (QWebPage) which is needed by WebCore. I guess QWebPage* createWindow() might make more sense. 157853 8 kenneth 2009-10-26 11:59:24 -0700 (In reply to comment #5) > thx for commenting again. > > > > hum, it is protected, so it should not be totally callable, unless you are > > > re-implementing the class (and then knows what you are doing). > > > > Then there is not much sense is having it return something, is there? What > 3) QXXXWebView::createWindow - creates a new widget, and retuns *internally* to > the application whom maybe want to attach the widget to TAB or what ever ( > again it is protected +- internal) The reimplemented can easily do this internally without needing it to return anything. I guess this was only done for being able to return the page (QWebPage) which is needed by WebCore. I guess QWebPage* createWindow() might make more sense for QGraphicsWebView. 157874 9 kenneth 2009-10-26 12:43:21 -0700 Btw, with your change the documentation for QWebPage::createWindow is wrong. The patch needs to update that as well :-) 157878 10 tonikitoo 2009-10-26 12:54:32 -0700 ok, all confuse bits come from the fact that both qwebview and qwebpage have this virtual createWindow method to be re-implemented. kenneth and I agree on IRC that if there is not a good reason for also duplicate into QGraphicsWebView then it should be avoided. thoughts? 157879 11 kenneth 2009-10-26 12:59:32 -0700 The problem is that I can reimplement the createWindow in QWebView and in the associated QWebPage. If it is reimplemented in the latter, the version reimplemented in QWebView derived class, will never be used. This is not detailed in the documentation and is outright confusing :-) Also, a worse problem: If I use a special page class (derived from QWebPage) together with QWebView and do not reimplement QWebPage::createWindow, then all new windows will be created by QWebView::createWindow and use the normal QWebPage class and not my derived one! Ups! 157881 12 kenneth 2009-10-26 13:04:12 -0700 > If I use a special page class (derived from QWebPage) together with QWebView > and do not reimplement QWebPage::createWindow, then all new windows will be > created by QWebView::createWindow and use the normal QWebPage class and not my > derived one! Ups! or put differently you need to make sure that your QWebView::createWindow creates pages of the right kind. If doing anything like a web browser you need to reimplement the QWebPage anyway, so I'm not sure that the Q(GraphicsView)WebView::createWindow helps much, except creating all these confusing situations. So, I would say, let's fix the docs to explain the current behaviour with QWebView::createWindow and let's think a bit more before adding this method to QGraphicsWebView. 157895 13 tonikitoo 2009-10-26 13:45:40 -0700 (In reply to comment #12) > > If I use a special page class (derived from QWebPage) together with QWebView > > and do not reimplement QWebPage::createWindow, then all new windows will be > > created by QWebView::createWindow and use the normal QWebPage class and not my > > derived one! Ups! > > or put differently you need to make sure that your QWebView::createWindow > creates pages of the right kind. > > If doing anything like a web browser you need to reimplement the QWebPage > anyway, so I'm not sure that the Q(GraphicsView)WebView::createWindow helps > much, except creating all these confusing situations. > > So, I would say, let's fix the docs to explain the current behaviour with > QWebView::createWindow and let's think a bit more before adding this method to > QGraphicsWebView. hum, another problem w/ current patch: suppose we have one qgraphicswebview and two qwebpages swapped as apropriated. if i swap page_1 to page_2, page_1's client will '0' then in the default implementation a page wont be able to create a window if it is not the one attached to the current qgraphicswebview. QWebPage *QWebPage::createWindow(WebWindowType type) { if (d->client) //<------- this will only work for current viewed pages. return d->client->createWindow(type); return 0; } 158091 14 41862 tonikitoo 2009-10-26 21:46:05 -0700 Comment on attachment 41862 patch 0.1 i am clearing r? flag for now, as the wanted behavior is yet to be defined here. 159942 15 benjamin 2009-11-02 16:20:19 -0800 Are you planning to make the patch to update the documentation? This task is still blocking #29799, it would be nice to close it. 161651 16 kenneth 2009-11-09 11:08:06 -0800 (In reply to comment #15) > Are you planning to make the patch to update the documentation? > This task is still blocking #29799, it would be nice to close it. I can change the documentation tomorrow. I will add it to my TODO 162033 17 hausmann 2009-11-10 06:50:02 -0800 I agree with the earlier comments not _not_ have a createWindow implementation QGWV. Initially I liked the idea, but what convinced me was the point that adding it is only going to _create_ confusion, apart from the convenience it adds. So I'm all for not adding it. 162034 18 hausmann 2009-11-10 06:54:21 -0800 Removed from the API block bug, as it's not an API issue anymore but a documentation issue. 162116 19 kenneth 2009-11-10 11:01:08 -0800 (In reply to comment #18) > Removed from the API block bug, as it's not an API issue anymore but a > documentation issue. OK, I have updated the documentation of QWebView::createWindow. 162182 20 hausmann 2009-11-10 13:00:31 -0800 (In reply to comment #19) > (In reply to comment #18) > > Removed from the API block bug, as it's not an API issue anymore but a > > documentation issue. > > OK, I have updated the documentation of QWebView::createWindow. Thanks! Now we just need to cherry-pick the fixes into the qtwebkit-4.6 branch :) 162558 21 hausmann 2009-11-11 10:44:13 -0800 Landed in svn and cherry-picked into qtwebkit-4.6. Closing this bug 162578 22 tonikitoo 2009-11-11 11:16:11 -0800 simon, kenneth, although I agree that documentation is improved for createWindow, the original problem is not fixed. see comment #1. it is just not possible for browsers using qgraphicswebview to open new window. I will reopen and make it a not 4.6 blocker. 162653 23 hausmann 2009-11-11 13:30:27 -0800 (In reply to comment #22) > simon, kenneth, although I agree that documentation is improved for > createWindow, the original problem is not fixed. see comment #1. > > it is just not possible for browsers using qgraphicswebview to open new window. > > I will reopen and make it a not 4.6 blocker. I don't understand why it's not possible for browsers using QGraphicsWebView to handle the creation of new windows. Comment #1 doesn't explain that either and the bug description merely says that the current default implementation in QWebPage is tailored towards QWebView. That is correct. However given that QWebPage::createWindow is virtual shouldn't browsers be able to use their QWebPage subclass together with QGraphicsWebView and intercept the window creation? The main argument I see in favour of _not_ adding it to QGraphicsWebView is that adding it adds to the API confusion. Two virtual functions in related classes with the same name make it easy for developers to shake their head and wonder: "Which one do I have to deal with now?" 162658 24 kenneth 2009-11-11 13:36:41 -0800 I fully agree and think we should close this bug (In reply to comment #23) > (In reply to comment #22) > > simon, kenneth, although I agree that documentation is improved for > > createWindow, the original problem is not fixed. see comment #1. > > > > it is just not possible for browsers using qgraphicswebview to open new window. > > > > I will reopen and make it a not 4.6 blocker. > > I don't understand why it's not possible for browsers using QGraphicsWebView to > handle the creation of new windows. Comment #1 doesn't explain that either and > the bug description merely says that the current default implementation in > QWebPage is tailored towards QWebView. That is correct. > > However given that QWebPage::createWindow is virtual shouldn't browsers be able > to use their QWebPage subclass together with QGraphicsWebView and intercept the > window creation? > > > The main argument I see in favour of _not_ adding it to QGraphicsWebView is > that adding it adds to the API confusion. Two virtual functions in related > classes with the same name make it easy for developers to shake their head and > wonder: "Which one do I have to deal with now?" 162661 25 tonikitoo 2009-11-11 13:52:19 -0800 > However given that QWebPage::createWindow is virtual shouldn't browsers be able to use their QWebPage subclass together with QGraphicsWebView and intercept the window creation? Yes, re-implementing it makes it possible to create windows. However the initial goal of this bug was to make the default implementation of qwebpage::createWindow to not depend on qwebview at all, but instead qwebpageclient, which i still think is a good think to do. > The main argument I see in favour of _not_ adding it to QGraphicsWebView is > that adding it adds to the API confusion. Two virtual functions in related > classes with the same name make it easy for developers to shake their head and > wonder: "Which one do I have to deal with now?" right, the original API is not good imho, and that is the problem. But i agree we have to keep ABI compatible. ok, lets close it then. 41862 2009-10-26 06:18:37 -0700 2009-10-26 21:46:04 -0700 patch 0.1 0001--Qt-Make-qwebpage-s-createWindow-not-qwebview-depen.patch text/plain 9796 tonikitoo RnJvbSBhYTA3NzkxZTIwZmVhMzRmNTM0ZDFmMWYyMTY5YjNmMDc3YmMzMmRjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4K RGF0ZTogU3VuLCAyNSBPY3QgMjAwOSAwNzo0Mjo0NCAtMDQwMApTdWJqZWN0OiBbUEFUQ0hdIFtR dF0gTWFrZSBxd2VicGFnZSdzIGNyZWF0ZVdpbmRvdyBub3QgcXdlYnZpZXcgZGVwZW5kZW50CiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzA3NzEKCldlYkNvcmU6IEFk ZGVkIGNyZWF0ZVdpbmRvdyBwdXJlIHZpcnR1YWwgbWV0aG9kIHRvIFFXZWJQYWdlQ2xpZW50IGlu dGVyZmFjZS4KClBhdGNoIGJ5IEFudG9uaW8gR29tZXMgPHRvbmlraXRvb0B3ZWJraXQub3JnPiBv biAyMDA5LTEwLTI2ClJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKKiBwbGF0Zm9ybS9xdC9R V2ViUGFnZUNsaWVudC5oOgoKV2ViS2l0L3F0OiBNYWtlIFFHcmFwaGljc1dlYlZpZXcgdG8gc3Vw cG9ydCA6OmNyZWF0ZVdpbmRvdyBtZXRob2QuCgpQYXRjaCBieSBBbnRvbmlvIEdvbWVzIDx0b25p a2l0b29Ad2Via2l0Lm9yZz4gb24gMjAwOS0xMC0yNgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KCkZvciB0aGF0IHRvIGhhcHBlbiwgaXQgd2FzIG5lZWRlZCB0byByZW1vdmUgUVdlYlBhZ2Un cyBjcmVhdGVXaW5kb3coKQpleHBsaWNpdCBkZXBlbmRlbmN5IG9uIFFXZWJWaWV3LiBOb3csIGlu c3RlYWQgaXQgY2FsbHMgUGFnZUNsaWVudCdzCmNyZWF0ZVdpbmRvdywgYW5kIHRha2VzIGNhcmUg b2YgdGFsa2luZyB0byB0aGUgcmlnaHQgd2lkZ2V0IChlaXRoZXIKUVdlYlZpZXcgb3IgUUdyYXBo aWNzV2ViVmlldykuCgpQYXRjaCBhbHNvIGZpeGVzIHNvbWUgbml0cyBsaWtlOgoKLSBXcm9uZyAi KiIgcG9zaXRpb24gaW4gc29tZSBwb2ludGVyIGRlY2xhcmF0aW9ucy4KLSBSZW1vdmVkIHVubmVl ZGVkIFFXZWJQYWdlIGZyaWVuZCBjbGFzcyBkZWNsYXJhdGlvbiBpbiBxd2Vidmlldy5oLgoKKiBB cGkvcWdyYXBoaWNzd2Vidmlldy5jcHA6CihRR3JhcGhpY3NXZWJWaWV3UHJpdmF0ZTo6Y3JlYXRl V2luZG93KToKKFFHcmFwaGljc1dlYlZpZXc6OmNyZWF0ZVdpbmRvdyk6CiogQXBpL3FncmFwaGlj c3dlYnZpZXcuaDoKKiBBcGkvcXdlYnBhZ2UuY3BwOgooUVdlYlBhZ2U6OmNyZWF0ZVdpbmRvdyk6 CiogQXBpL3F3ZWJ2aWV3LmNwcDoKKFFXZWJWaWV3UHJpdmF0ZTo6Y3JlYXRlV2luZG93KToKKFFX ZWJWaWV3OjpjcmVhdGVXaW5kb3cpOgoqIEFwaS9xd2Vidmlldy5oOgotLS0KIFdlYkNvcmUvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICB8ICAgMTEgKysrKysrKysrKysKIFdlYkNvcmUvcGxh dGZvcm0vcXQvUVdlYlBhZ2VDbGllbnQuaCB8ICAgIDMgKysrCiBXZWJLaXQvcXQvQXBpL3FncmFw aGljc3dlYnZpZXcuY3BwICAgfCAgIDIxICsrKysrKysrKysrKysrKysrKysrKwogV2ViS2l0L3F0 L0FwaS9xZ3JhcGhpY3N3ZWJ2aWV3LmggICAgIHwgICAgNyArKysrLS0tCiBXZWJLaXQvcXQvQXBp L3F3ZWJwYWdlLmNwcCAgICAgICAgICAgfCAgIDEwICsrKystLS0tLS0KIFdlYktpdC9xdC9BcGkv cXdlYnZpZXcuY3BwICAgICAgICAgICB8ICAgMTEgKysrKysrKysrKy0KIFdlYktpdC9xdC9BcGkv cXdlYnZpZXcuaCAgICAgICAgICAgICB8ICAgIDQgKystLQogV2ViS2l0L3F0L0NoYW5nZUxvZyAg ICAgICAgICAgICAgICAgIHwgICAyOSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogOCBm aWxlcyBjaGFuZ2VkLCA4NCBpbnNlcnRpb25zKCspLCAxMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDliZmFjNjIu LjI5ODUxYjkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMTAtMjYgQW50b25pbyBHb21lcyAgPHRvbmlr aXRvb0B3ZWJraXQub3JnPgorCisgICAgICAgIFtRdF0gTWFrZSBxd2VicGFnZSdzIGNyZWF0ZVdp bmRvdyBub3QgcXdlYnZpZXcgZGVwZW5kZW50CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0zMDc3MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIGNyZWF0ZVdpbmRvdyBwdXJlIHZpcnR1YWwgbWV0aG9k IHRvIFFXZWJQYWdlQ2xpZW50IGludGVyZmFjZS4KKworICAgICAgICogcGxhdGZvcm0vcXQvUVdl YlBhZ2VDbGllbnQuaDoKKwogMjAwOS0xMC0yMCAgTWlraGFpbCBOYWdhbm92ICA8bW5hZ2Fub3ZA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFBhdmVsIEZlbGRtYW4uCmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL3F0L1FXZWJQYWdlQ2xpZW50LmggYi9XZWJDb3JlL3Bs YXRmb3JtL3F0L1FXZWJQYWdlQ2xpZW50LmgKaW5kZXggMjhlZjcyNC4uYTRlNDRlNyAxMDA2NDQK LS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9xdC9RV2ViUGFnZUNsaWVudC5oCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vcXQvUVdlYlBhZ2VDbGllbnQuaApAQCAtMjYsNiArMjYsOCBAQAogI2lmbmRlZiBR V2ViUGFnZUNsaWVudF9oCiAjZGVmaW5lIFFXZWJQYWdlQ2xpZW50X2gKIAorI2luY2x1ZGUgInF3 ZWJwYWdlLmgiCisKICNpbmNsdWRlIDxRUmVjdD4KIAogY2xhc3MgUVdlYlBhZ2VDbGllbnQgewpA QCAtMzMsNiArMzUsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHNjcm9sbChpbnQgZHgs IGludCBkeSwgY29uc3QgUVJlY3QmKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHVwZGF0ZShjb25z dCBRUmVjdCYpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2V0SW5wdXRNZXRob2RFbmFibGVkKGJv b2wgZW5hYmxlKSA9IDA7CisgICAgdmlydHVhbCBRV2ViUGFnZSogY3JlYXRlV2luZG93KFFXZWJQ YWdlOjpXZWJXaW5kb3dUeXBlIHR5cGUpID0gMDsKICNpZiBRVF9WRVJTSU9OID49IDB4MDQwNjAw CiAgICAgdmlydHVhbCB2b2lkIHNldElucHV0TWV0aG9kSGludChRdDo6SW5wdXRNZXRob2RIaW50 IGhpbnQsIGJvb2wgZW5hYmxlKSA9IDA7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9B cGkvcWdyYXBoaWNzd2Vidmlldy5jcHAgYi9XZWJLaXQvcXQvQXBpL3FncmFwaGljc3dlYnZpZXcu Y3BwCmluZGV4IDUwYTA5ODYuLjNjMjRmOTYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcWdy YXBoaWNzd2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xZ3JhcGhpY3N3ZWJ2aWV3LmNw cApAQCAtNDYsNiArNDYsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHNjcm9sbChpbnQg ZHgsIGludCBkeSwgY29uc3QgUVJlY3QmKTsKICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlKGNvbnN0 IFFSZWN0JiBkaXJ0eVJlY3QpOwogICAgIHZpcnR1YWwgdm9pZCBzZXRJbnB1dE1ldGhvZEVuYWJs ZWQoYm9vbCBlbmFibGUpOworICAgIHZpcnR1YWwgUVdlYlBhZ2UqIGNyZWF0ZVdpbmRvdyhRV2Vi UGFnZTo6V2ViV2luZG93VHlwZSB0eXBlKTsKICNpZiBRVF9WRVJTSU9OID49IDB4MDQwNjAwCiAg ICAgdmlydHVhbCB2b2lkIHNldElucHV0TWV0aG9kSGludChRdDo6SW5wdXRNZXRob2RIaW50IGhp bnQsIGJvb2wgZW5hYmxlKTsKICNlbmRpZgpAQCAtOTIsNiArOTMsMTQgQEAgdm9pZCBRR3JhcGhp Y3NXZWJWaWV3UHJpdmF0ZTo6X3FfZG9Mb2FkRmluaXNoZWQoYm9vbCBzdWNjZXNzKQogICAgIGVt aXQgcS0+bG9hZEZpbmlzaGVkKHN1Y2Nlc3MpOwogfQogCitRV2ViUGFnZSogUUdyYXBoaWNzV2Vi Vmlld1ByaXZhdGU6OmNyZWF0ZVdpbmRvdyhRV2ViUGFnZTo6V2ViV2luZG93VHlwZSB0eXBlKQor eworICAgIGlmIChRR3JhcGhpY3NXZWJWaWV3ICpuZXdWaWV3ID0gcS0+Y3JlYXRlV2luZG93KHR5 cGUpKQorICAgICAgICByZXR1cm4gbmV3Vmlldy0+cGFnZSgpOworCisgICAgcmV0dXJuIDA7Cit9 CisKIHZvaWQgUUdyYXBoaWNzV2ViVmlld1ByaXZhdGU6OnNjcm9sbChpbnQgZHgsIGludCBkeSwg Y29uc3QgUVJlY3QmIHJlY3RUb1Njcm9sbCkKIHsKICAgICBxLT5zY3JvbGwocXJlYWwoZHgpLCBx cmVhbChkeSksIFFSZWN0RihyZWN0VG9TY3JvbGwpKTsKQEAgLTIzMyw2ICsyNDIsMTggQEAgUVdl YlBhZ2UqIFFHcmFwaGljc1dlYlZpZXc6OnBhZ2UoKSBjb25zdAogICAgIHJldHVybiBkLT5wYWdl OwogfQogCisvKiEKKyAgICBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3aGVuZXZlciBXZWJLaXQg d2FudHMgdG8gY3JlYXRlIGEgbmV3IHdpbmRvdyBvZiB0aGUgZ2l2ZW4gXGEgdHlwZSwgZm9yIGV4 YW1wbGUgYXMgYSByZXN1bHQgb2YKKyAgICBhIEphdmFTY3JpcHQgcmVxdWVzdCB0byBvcGVuIGEg ZG9jdW1lbnQgaW4gYSBuZXcgd2luZG93LgorCisgICAgXHNhIFFXZWJQYWdlOjpjcmVhdGVXaW5k b3coKQorKi8KK1FHcmFwaGljc1dlYlZpZXcgKlFHcmFwaGljc1dlYlZpZXc6OmNyZWF0ZVdpbmRv dyhRV2ViUGFnZTo6V2ViV2luZG93VHlwZSB0eXBlKQoreworICAgIFFfVU5VU0VEKHR5cGUpCisg ICAgcmV0dXJuIDA7Cit9CisKIC8qISBccmVpbXAKICovCiB2b2lkIFFHcmFwaGljc1dlYlZpZXc6 OnBhaW50KFFQYWludGVyKiBwYWludGVyLCBjb25zdCBRU3R5bGVPcHRpb25HcmFwaGljc0l0ZW0q IG9wdGlvbiwgUVdpZGdldCopCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3FncmFwaGljc3dl YnZpZXcuaCBiL1dlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCmluZGV4IDQzY2Y1OWEu LjkzNzFjYzUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCisr KyBiL1dlYktpdC9xdC9BcGkvcWdyYXBoaWNzd2Vidmlldy5oCkBAIC0yMSw2ICsyMSw3IEBACiAj ZGVmaW5lIFFHcmFwaGljc1dlYlZpZXdfaAogCiAjaW5jbHVkZSAicXdlYmtpdGdsb2JhbC5oIgor I2luY2x1ZGUgInF3ZWJwYWdlLmgiCiAjaW5jbHVkZSA8UXRDb3JlL3F1cmwuaD4KICNpbmNsdWRl IDxRdEd1aS9xZXZlbnQuaD4KICNpbmNsdWRlIDxRdEd1aS9xZ3JhcGhpY3N3aWRnZXQuaD4KQEAg LTI4LDEyICsyOSwxMCBAQAogI2luY2x1ZGUgPFF0R3VpL3FwYWludGVyLmg+CiAjaW5jbHVkZSA8 UXROZXR3b3JrL3FuZXR3b3JrYWNjZXNzbWFuYWdlci5oPgogCi1jbGFzcyBRV2ViUGFnZTsKK2Ns YXNzIFFHcmFwaGljc1dlYlZpZXdQcml2YXRlOwogY2xhc3MgUVdlYkhpc3Rvcnk7CiBjbGFzcyBR V2ViU2V0dGluZ3M7CiAKLWNsYXNzIFFHcmFwaGljc1dlYlZpZXdQcml2YXRlOwotCiBjbGFzcyBR V0VCS0lUX0VYUE9SVCBRR3JhcGhpY3NXZWJWaWV3IDogcHVibGljIFFHcmFwaGljc1dpZGdldCB7 CiAgICAgUV9PQkpFQ1QKIApAQCAtODIsNiArODEsOCBAQCBwdWJsaWM6CiAKICAgICBRU3RyaW5n IHN0YXR1cygpIGNvbnN0OwogCisgICAgdmlydHVhbCBRR3JhcGhpY3NXZWJWaWV3KiBjcmVhdGVX aW5kb3coUVdlYlBhZ2U6OldlYldpbmRvd1R5cGUgdHlwZSk7CisKICAgICB2aXJ0dWFsIHZvaWQg c2V0R2VvbWV0cnkoY29uc3QgUVJlY3RGJiByZWN0KTsKICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRl R2VvbWV0cnkoKTsKICAgICB2aXJ0dWFsIHZvaWQgcGFpbnQoUVBhaW50ZXIqLCBjb25zdCBRU3R5 bGVPcHRpb25HcmFwaGljc0l0ZW0qIG9wdGlvbnMsIFFXaWRnZXQqIHdpZGdldCA9IDApOwpkaWZm IC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJw YWdlLmNwcAppbmRleCBiNGM4MzY5Li43MTUwMzIyIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBp L3F3ZWJwYWdlLmNwcAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmNwcApAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgInF3ZWJpbnNwZWN0b3JfcC5oIgogI2luY2x1ZGUgInF3ZWJzZXR0 aW5ncy5oIgogI2luY2x1ZGUgInF3ZWJraXR2ZXJzaW9uLmgiCisjaW5jbHVkZSAiUVdlYlBhZ2VD bGllbnQuaCIKIAogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVUcmVlLmgiCkBA IC0xNzg0LDEyICsxNzg1LDkgQEAgYm9vbCBRV2ViUGFnZTo6c2hvdWxkSW50ZXJydXB0SmF2YVNj cmlwdCgpCiAqLwogUVdlYlBhZ2UgKlFXZWJQYWdlOjpjcmVhdGVXaW5kb3coV2ViV2luZG93VHlw ZSB0eXBlKQogewotICAgIFFXZWJWaWV3ICp3ZWJWaWV3ID0gcW9iamVjdF9jYXN0PFFXZWJWaWV3 ICo+KHZpZXcoKSk7Ci0gICAgaWYgKHdlYlZpZXcpIHsKLSAgICAgICAgUVdlYlZpZXcgKm5ld1Zp ZXcgPSB3ZWJWaWV3LT5jcmVhdGVXaW5kb3codHlwZSk7Ci0gICAgICAgIGlmIChuZXdWaWV3KQot ICAgICAgICAgICAgcmV0dXJuIG5ld1ZpZXctPnBhZ2UoKTsKLSAgICB9CisgICAgaWYgKGQtPmNs aWVudCkKKyAgICAgICAgcmV0dXJuIGQtPmNsaWVudC0+Y3JlYXRlV2luZG93KHR5cGUpOworCiAg ICAgcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnZpZXcuY3Bw IGIvV2ViS2l0L3F0L0FwaS9xd2Vidmlldy5jcHAKaW5kZXggODhmNWYwNC4uNjc1OTcwNyAxMDA2 NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9x d2Vidmlldy5jcHAKQEAgLTQ5LDYgKzQ5LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBz Y3JvbGwoaW50IGR4LCBpbnQgZHksIGNvbnN0IFFSZWN0Jik7CiAgICAgdmlydHVhbCB2b2lkIHVw ZGF0ZShjb25zdCBRUmVjdCYgZGlydHlSZWN0KTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0SW5wdXRN ZXRob2RFbmFibGVkKGJvb2wgZW5hYmxlKTsKKyAgICB2aXJ0dWFsIFFXZWJQYWdlKiBjcmVhdGVX aW5kb3coUVdlYlBhZ2U6OldlYldpbmRvd1R5cGUgdHlwZSk7CiAjaWYgUVRfVkVSU0lPTiA+PSAw eDA0MDYwMAogICAgIHZpcnR1YWwgdm9pZCBzZXRJbnB1dE1ldGhvZEhpbnQoUXQ6OklucHV0TWV0 aG9kSGludCBoaW50LCBib29sIGVuYWJsZSk7CiAjZW5kaWYKQEAgLTcyLDYgKzczLDE0IEBAIHB1 YmxpYzoKICAgICBRUGFpbnRlcjo6UmVuZGVySGludHMgcmVuZGVySGludHM7CiB9OwogCitRV2Vi UGFnZSogUVdlYlZpZXdQcml2YXRlOjpjcmVhdGVXaW5kb3coUVdlYlBhZ2U6OldlYldpbmRvd1R5 cGUgdHlwZSkKK3sKKyAgICBpZiAoUVdlYlZpZXcqIG5ld1ZpZXcgPSB2aWV3LT5jcmVhdGVXaW5k b3codHlwZSkpCisgICAgICAgIHJldHVybiBuZXdWaWV3LT5wYWdlKCk7CisKKyAgICByZXR1cm4g MDsKK30KKwogdm9pZCBRV2ViVmlld1ByaXZhdGU6OnNjcm9sbChpbnQgZHgsIGludCBkeSwgY29u c3QgUVJlY3QmIHJlY3RUb1Njcm9sbCkKIHsKICAgICB2aWV3LT5zY3JvbGwocXJlYWwoZHgpLCBx cmVhbChkeSksIHJlY3RUb1Njcm9sbCk7CkBAIC05MDQsNyArOTEzLDcgQEAgdm9pZCBRV2ViVmll dzo6cGFpbnRFdmVudChRUGFpbnRFdmVudCAqZXYpCiAKICAgICBcc2EgUVdlYlBhZ2U6OmNyZWF0 ZVdpbmRvdygpCiAqLwotUVdlYlZpZXcgKlFXZWJWaWV3OjpjcmVhdGVXaW5kb3coUVdlYlBhZ2U6 OldlYldpbmRvd1R5cGUgdHlwZSkKK1FXZWJWaWV3KiBRV2ViVmlldzo6Y3JlYXRlV2luZG93KFFX ZWJQYWdlOjpXZWJXaW5kb3dUeXBlIHR5cGUpCiB7CiAgICAgUV9VTlVTRUQodHlwZSkKICAgICBy ZXR1cm4gMDsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnZpZXcuaCBiL1dlYktpdC9x dC9BcGkvcXdlYnZpZXcuaAppbmRleCAxNWI1ODM2Li41MDcwZjFlIDEwMDY0NAotLS0gYS9XZWJL aXQvcXQvQXBpL3F3ZWJ2aWV3LmgKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2Vidmlldy5oCkBAIC0x NDEsNyArMTQxLDcgQEAgcHJvdGVjdGVkOgogICAgIHZvaWQgcmVzaXplRXZlbnQoUVJlc2l6ZUV2 ZW50Kik7CiAgICAgdm9pZCBwYWludEV2ZW50KFFQYWludEV2ZW50Kik7CiAKLSAgICB2aXJ0dWFs IFFXZWJWaWV3ICpjcmVhdGVXaW5kb3coUVdlYlBhZ2U6OldlYldpbmRvd1R5cGUgdHlwZSk7Cisg ICAgdmlydHVhbCBRV2ViVmlldyogY3JlYXRlV2luZG93KFFXZWJQYWdlOjpXZWJXaW5kb3dUeXBl IHR5cGUpOwogCiAgICAgdmlydHVhbCB2b2lkIGNoYW5nZUV2ZW50KFFFdmVudCopOwogICAgIHZp cnR1YWwgdm9pZCBtb3VzZU1vdmVFdmVudChRTW91c2VFdmVudCopOwpAQCAtMTY3LDcgKzE2Nyw3 IEBAIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIGJvb2wgZm9jdXNOZXh0UHJldkNoaWxkKGJvb2wg bmV4dCk7CiAKIHByaXZhdGU6Ci0gICAgZnJpZW5kIGNsYXNzIFFXZWJQYWdlOworICAgIGZyaWVu ZCBjbGFzcyBRV2ViVmlld1ByaXZhdGU7CiAgICAgUVdlYlZpZXdQcml2YXRlKiBkOwogICAgIFFf UFJJVkFURV9TTE9UKGQsIHZvaWQgX3FfcGFnZURlc3Ryb3llZCgpKQogfTsKZGlmZiAtLWdpdCBh L1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IGJiMTg0NWMu LjNiNjhmM2EgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0 L0NoYW5nZUxvZwpAQCAtMSw1ICsxLDM0IEBACiAyMDA5LTEwLTI2ICBBbnRvbmlvIEdvbWVzICA8 dG9uaWtpdG9vQHdlYmtpdC5vcmc+CiAKKyAgICAgICAgW1F0XSBNYWtlIHF3ZWJwYWdlJ3MgY3Jl YXRlV2luZG93IG5vdCBxd2VidmlldyBkZXBlbmRlbnQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMwNzcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBRR3JhcGhpY3NXZWJWaWV3IHRvIHN1cHBvcnQg OjpjcmVhdGVXaW5kb3cgbWV0aG9kLgorCisgICAgICAgIEZvciB0aGF0IHRvIGhhcHBlbiwgaXQg d2FzIG5lZWRlZCB0byByZW1vdmUgUVdlYlBhZ2UncyBjcmVhdGVXaW5kb3coKQorICAgICAgICBl eHBsaWNpdCBkZXBlbmRlbmN5IG9uIFFXZWJWaWV3LiBOb3csIGluc3RlYWQgaXQgY2FsbHMgUGFn ZUNsaWVudCdzCisgICAgICAgIGNyZWF0ZVdpbmRvdywgYW5kIHRha2VzIGNhcmUgb2YgdGFsa2lu ZyB0byB0aGUgcmlnaHQgd2lkZ2V0IChlaXRoZXIKKyAgICAgICAgUVdlYlZpZXcgb3IgUUdyYXBo aWNzV2ViVmlldykuCisKKyAgICAgICAgUGF0Y2ggYWxzbyBmaXhlcyBzb21lIG5pdHMgbGlrZToK KyAgICAgICAgLSBXcm9uZyAiKiIgcG9zaXRpb24gaW4gc29tZSBwb2ludGVyIGRlY2xhcmF0aW9u cy4KKyAgICAgICAgLSBSZW1vdmVkIHVubmVlZGVkIFFXZWJQYWdlIGZyaWVuZCBjbGFzcyBkZWNs YXJhdGlvbiBpbiBxd2Vidmlldy5oLgorCisgICAgICAgICogQXBpL3FncmFwaGljc3dlYnZpZXcu Y3BwOgorICAgICAgICAoUUdyYXBoaWNzV2ViVmlld1ByaXZhdGU6OmNyZWF0ZVdpbmRvdyk6Cisg ICAgICAgIChRR3JhcGhpY3NXZWJWaWV3OjpjcmVhdGVXaW5kb3cpOgorICAgICAgICAqIEFwaS9x Z3JhcGhpY3N3ZWJ2aWV3Lmg6CisgICAgICAgICogQXBpL3F3ZWJwYWdlLmNwcDoKKyAgICAgICAg KFFXZWJQYWdlOjpjcmVhdGVXaW5kb3cpOgorICAgICAgICAqIEFwaS9xd2Vidmlldy5jcHA6Cisg ICAgICAgIChRV2ViVmlld1ByaXZhdGU6OmNyZWF0ZVdpbmRvdyk6CisgICAgICAgIChRV2ViVmll dzo6Y3JlYXRlV2luZG93KToKKyAgICAgICAgKiBBcGkvcXdlYnZpZXcuaDoKKworMjAwOS0xMC0y NiAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQub3JnPgorCiAgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgogCiAgICAgICAgIG5pdDogZml4ZWQgd3JvbmcgY29tbWVu dCBpbiBRV2ViUGFnZSdzIGNvbnN0cnVjdG9yIGhlYWRlci4KLS0gCjEuNi4wLjQKCg==