212969 2020-06-09 05:12:51 -0700 [GTK] Add an internal API to run javascript without forced user gestures 2020-06-12 01:49:32 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 184845 1 cturner cturner berto bugs-noreply cgarcia clopez ews-watchlist gustavo mcatanzaro oldest_to_newest 1660664 0 cturner 2020-06-09 05:12:51 -0700 webkit_web_view_run_javascript currently calls runJavaScriptInMainFrame with forceUserGesture set to true in the RunJavaScriptParameters. This caused a problem during the development of an autoplay API https://bugs.webkit.org/show_bug.cgi?id=184845. If you deny autoplay as a web view policy, and then the page JavaScript tries to call videoElement.play() without you gesturing the video to play, it clearly should not play the video. However, if you use the GTK API to run the same JS, it will autoplay the video. It's fair to say that because API users are fully in control of what JS they send in via the API, this is a non-issue and a new public-facing API is not needed. But, to test autoplay continues to reject play() requests in "normal" cases as above, there does need to be an API for WebViewTest to run JS without user gestures forced. Given that the tests use the public API, I figured a new one is sensible. Finally, the default could be switched to always run JavaScript without forced user gestures by modifying webkit_web_view_run_javascript. This breaks the webkit/WebKitWebView/fullscreen test. It uses document.documentElement.webkitRequestFullScreen(); to go fullscreen, called via webkit_web_view_run_javascript. I have not debugged why that requires user-gestures on, only assumed it's for good reason and changing that could cause a lot of breakage. 1660665 1 cgarcia 2020-06-09 05:18:08 -0700 We simulate user interaction in other unit tests when it's required. 1660736 2 cturner 2020-06-09 10:58:55 -0700 I guess you're referring to UIClient tests and their simulateUserInteraction method. That method of focusing a hidden input element in the DOM, or artificially injecting key strokes into the event loop does not seem to help in this test, whether I do it before calling webkitRequestFullScreen or after calling it. I'll dig deeper into what going on in webkitRequestFullScreen. 1661172 3 cturner 2020-06-10 08:51:33 -0700 I still think we need this API. The fullscreen request will be denied and the test will hang without active user gestures, because document.documentElement.webkitRequestFullScreen() ends up in WebCore::FullscreenManager::requestFullscreenForElement, which early returns if no gesture tokens are installed. User gestures are kept in a static global on the main thread. webkit_web_view_run_javascript and synthetic key events both cause this global to get a gesture installed, so why doesn't it work calling it right before I run the JS without explicitly enabling user gestures? They should be sticky, no? Gestures are only active for the lifetime of the script run by webkit_web_view_run_javascript and the processing of the key event in WebCore::EventHandler::internalKeyEvent respectively. It's a tad tricksy how UserGestureIndicator keeps that static global valid only for the scope in which it's stack allocated. So, we want an API that runs JS without user gestures explicitly. Cocoa has _evaluateJavaScriptWithoutUserGesture, I think we should too after learning the above. 1661186 4 mcatanzaro 2020-06-10 09:39:15 -0700 Hm, it seems like the only use for this API is to use in our own API tests, right? Is there any case where a real-world app would want to run JS without gesture forced? 1661197 5 cturner 2020-06-10 09:59:57 -0700 (In reply to Michael Catanzaro from comment #4) > Hm, it seems like the only use for this API is to use in our own API tests, > right? Is there any case where a real-world app would want to run JS without > gesture forced? I mean, in theory yes. I don't have a compelling use case though, so maybe that alone is enough to expose instead some internal alternative. If that's what we want, I don't see prior art in WebViewTest of calling into internal WebKit APIs without going through the GTK API. Any advice on how to handle that without adding a new API? 1661202 6 mcatanzaro 2020-06-10 10:07:32 -0700 Lack of prior art is a problem indeed. In theory, any exported function *could* be used in the tests. Carlos might consider it a layering violation, but it's *possible* to do. 1661539 7 cgarcia 2020-06-11 01:46:57 -0700 We use private API from jsc tests, for example. And recently we also added private API that is used from WTR. It's not a problem. In this particular case, I would add a WebKitWebViewInternal.h header with the private api required from unit tests. 1661664 8 401661 cturner 2020-06-11 11:27:53 -0700 Created attachment 401661 Patch 1661666 9 ews-watchlist 2020-06-11 11:28:39 -0700 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 1661883 10 ews-feeder 2020-06-12 01:49:31 -0700 Committed r262940: <https://trac.webkit.org/changeset/262940> All reviewed patches have been landed. Closing bug and clearing flags on attachment 401661. 401661 2020-06-11 11:27:53 -0700 2020-06-12 01:49:32 -0700 Patch bug-212969-20200611192752.patch text/plain 5665 cturner U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyNjA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDhjODY2OTMwMDBjMjZlNDI3 NWI1MjBiZDY0YTdmMjViMmJiMzNlODguLmIxMjhhYzQ2ZmMzMDM0MjhlYjljNjE5ODFmNWQ4ZDY0 YjUxYzZiNzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMjAtMDYtMTEgIENoYXJsaWUg VHVybmVyICA8Y3R1cm5lckBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIEFkZCBhbiBpbnRl cm5hbCBBUEkgdG8gcnVuIGphdmFzY3JpcHQgd2l0aG91dCBmb3JjZWQgdXNlciBnZXN0dXJlcwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEyOTY5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVG8gYmUgdXNl ZCBieSB0ZXN0cyBpbiBhIGZvbGxvdy11cCBjb21taXQuCisKKyAgICAgICAgKiBVSVByb2Nlc3Mv QVBJL2dsaWIvV2ViS2l0V2ViVmlldy5jcHA6CisgICAgICAgICh3ZWJraXRXZWJWaWV3UnVuSmF2 YVNjcmlwdFdpdGhQYXJhbXMpOiBGYWN0b3Igb3V0IHRoZSBnbHVlIHRvIHJ1bgorICAgICAgICBK YXZhU2NyaXB0IGluIHRoZSBwYWdlLgorICAgICAgICAod2Via2l0V2ViVmlld1J1bkphdmFzY3Jp cHRXaXRob3V0Rm9yY2VkVXNlckdlc3R1cmVzKTogQWRkIGEgbmV3CisgICAgICAgIGludGVybmFs IEFQSSBmb3IgdXNlIGJ5IHRlc3RzLgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3J1bl9qYXZh c2NyaXB0KTogTW9kaWZpZWQgdG8gdXNlIGZhY3RvcmVkIG91dAorICAgICAgICBnbHVlLgorICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ2xpYi9XZWJLaXRXZWJWaWV3SW50ZXJuYWwuaDogQWRkZWQu IFBsYWNlIHRvIGtlZXAKKyAgICAgICAgQVBJIHRlc3Qtc3BlY2lmaWMgaW50ZXJuYWwgQVBJcy4K KwogMjAyMC0wNi0wNSAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+ CiAKICAgICAgICAgUkVHUkVTU0lPTihyMjYyMTg0KTogW0dUS10gVHdvIGZhc3QvZm9ybXMgdGVz dHMgYXJlIGNyYXNoaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv Z2xpYi9XZWJLaXRXZWJWaWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGli L1dlYktpdFdlYlZpZXcuY3BwCmluZGV4IGU0MDQ1YzM2NzA2NTc1Y2M3ZGI5Zjk4NzExZWZkNjkw MDRhMmEzZjAuLjUwZGYzZjQ0OGE3ZDM4ZTMyODJlNjYyODI0OTBmMTcwZmVlYmFhZWQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXcuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXcuY3Bw CkBAIC02MCw2ICs2MCw3IEBACiAjaW5jbHVkZSAiV2ViS2l0VXNlck1lc3NhZ2VQcml2YXRlLmgi CiAjaW5jbHVkZSAiV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRX ZWJSZXNvdXJjZVByaXZhdGUuaCIKKyNpbmNsdWRlICJXZWJLaXRXZWJWaWV3SW50ZXJuYWwuaCIK ICNpbmNsdWRlICJXZWJLaXRXZWJWaWV3UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFdlYlZp ZXdTZXNzaW9uU3RhdGVQcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0V2Vic2l0ZURhdGFNYW5h Z2VyUHJpdmF0ZS5oIgpAQCAtMzczMyw2ICszNzM0LDI3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdFdl YlZpZXdSdW5KYXZhU2NyaXB0Q2FsbGJhY2soQVBJOjpTZXJpYWxpemVkU2NyaXB0VmFsdWUqIHdr U2VyCiAgICAgICAgIHJlaW50ZXJwcmV0X2Nhc3Q8R0Rlc3Ryb3lOb3RpZnk+KHdlYmtpdF9qYXZh c2NyaXB0X3Jlc3VsdF91bnJlZikpOwogfQogCitzdGF0aWMgdm9pZCB3ZWJraXRXZWJWaWV3UnVu SmF2YVNjcmlwdFdpdGhQYXJhbXMoV2ViS2l0V2ViVmlldyogd2ViVmlldywgY29uc3QgZ2NoYXIq IHNjcmlwdCwgUnVuSmF2YVNjcmlwdFBhcmFtZXRlcnMmJiBwYXJhbXMsIEdDYW5jZWxsYWJsZSog Y2FuY2VsbGFibGUsIEdBc3luY1JlYWR5Q2FsbGJhY2sgY2FsbGJhY2ssIGdwb2ludGVyIHVzZXJE YXRhKQoreworICAgIEdSZWZQdHI8R1Rhc2s+IHRhc2sgPSBhZG9wdEdSZWYoZ190YXNrX25ldyh3 ZWJWaWV3LCBjYW5jZWxsYWJsZSwgY2FsbGJhY2ssIHVzZXJEYXRhKSk7CisKKyAgICBnZXRQYWdl KHdlYlZpZXcpLnJ1bkphdmFTY3JpcHRJbk1haW5GcmFtZShXVEZNb3ZlKHBhcmFtcyksIFt0YXNr ID0gV1RGTW92ZSh0YXNrKV0oQVBJOjpTZXJpYWxpemVkU2NyaXB0VmFsdWUqIHNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZSwgT3B0aW9uYWw8RXhjZXB0aW9uRGV0YWlscz4gZGV0YWlscywgV2ViS2l0OjpD YWxsYmFja0Jhc2U6OkVycm9yKSB7CisgICAgICAgIEV4Y2VwdGlvbkRldGFpbHMgZXhjZXB0aW9u RGV0YWlsczsKKyAgICAgICAgaWYgKGRldGFpbHMpCisgICAgICAgICAgICBleGNlcHRpb25EZXRh aWxzID0gKmRldGFpbHM7CisgICAgICAgIHdlYmtpdFdlYlZpZXdSdW5KYXZhU2NyaXB0Q2FsbGJh Y2soc2VyaWFsaXplZFNjcmlwdFZhbHVlLCBleGNlcHRpb25EZXRhaWxzLCB0YXNrLmdldCgpKTsK KyAgICB9KTsKK30KKwordm9pZCB3ZWJraXRXZWJWaWV3UnVuSmF2YXNjcmlwdFdpdGhvdXRGb3Jj ZWRVc2VyR2VzdHVyZXMoV2ViS2l0V2ViVmlldyogd2ViVmlldywgY29uc3QgZ2NoYXIqIHNjcmlw dCwgR0NhbmNlbGxhYmxlKiBjYW5jZWxsYWJsZSwgR0FzeW5jUmVhZHlDYWxsYmFjayBjYWxsYmFj aywgZ3BvaW50ZXIgdXNlckRhdGEpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNf V0VCX1ZJRVcod2ViVmlldykpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoc2NyaXB0KTsKKworICAg IFJ1bkphdmFTY3JpcHRQYXJhbWV0ZXJzIHBhcmFtcyA9IHsgU3RyaW5nOjpmcm9tVVRGOChzY3Jp cHQpLCBVUkwgeyB9LCBmYWxzZSwgV1RGOjpudWxsb3B0LCBmYWxzZSB9OworICAgIHdlYmtpdFdl YlZpZXdSdW5KYXZhU2NyaXB0V2l0aFBhcmFtcyh3ZWJWaWV3LCBzY3JpcHQsIFdURk1vdmUocGFy YW1zKSwgY2FuY2VsbGFibGUsIGNhbGxiYWNrLCB1c2VyRGF0YSk7Cit9CisKIC8qKgogICogd2Vi a2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0OgogICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJW aWV3CkBAIC0zNzUyLDEzICszNzc0LDggQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFz Y3JpcHQoV2ViS2l0V2ViVmlldyogd2ViVmlldywgY29uc3QgZ2NoYXIqIHNjcmlwdCwKICAgICBn X3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19XRUJfVklFVyh3ZWJWaWV3KSk7CiAgICAgZ19yZXR1 cm5faWZfZmFpbChzY3JpcHQpOwogCi0gICAgR1JlZlB0cjxHVGFzaz4gdGFzayA9IGFkb3B0R1Jl ZihnX3Rhc2tfbmV3KHdlYlZpZXcsIGNhbmNlbGxhYmxlLCBjYWxsYmFjaywgdXNlckRhdGEpKTsK LSAgICBnZXRQYWdlKHdlYlZpZXcpLnJ1bkphdmFTY3JpcHRJbk1haW5GcmFtZSh7IFN0cmluZzo6 ZnJvbVVURjgoc2NyaXB0KSwgVVJMIHsgfSwgZmFsc2UsIFdURjo6bnVsbG9wdCwgdHJ1ZSB9LCBb dGFzayA9IFdURk1vdmUodGFzayldKEFQSTo6U2VyaWFsaXplZFNjcmlwdFZhbHVlKiBzZXJpYWxp emVkU2NyaXB0VmFsdWUsIE9wdGlvbmFsPEV4Y2VwdGlvbkRldGFpbHM+IGRldGFpbHMsIFdlYktp dDo6Q2FsbGJhY2tCYXNlOjpFcnJvcikgewotICAgICAgICBFeGNlcHRpb25EZXRhaWxzIGV4Y2Vw dGlvbkRldGFpbHM7Ci0gICAgICAgIGlmIChkZXRhaWxzKQotICAgICAgICAgICAgZXhjZXB0aW9u RGV0YWlscyA9ICpkZXRhaWxzOwotICAgICAgICB3ZWJraXRXZWJWaWV3UnVuSmF2YVNjcmlwdENh bGxiYWNrKHNlcmlhbGl6ZWRTY3JpcHRWYWx1ZSwgZXhjZXB0aW9uRGV0YWlscywgdGFzay5nZXQo KSk7Ci0gICAgfSk7CisgICAgUnVuSmF2YVNjcmlwdFBhcmFtZXRlcnMgcGFyYW1zID0geyBTdHJp bmc6OmZyb21VVEY4KHNjcmlwdCksIFVSTCB7IH0sIGZhbHNlLCBXVEY6Om51bGxvcHQsIHRydWUg fTsKKyAgICB3ZWJraXRXZWJWaWV3UnVuSmF2YVNjcmlwdFdpdGhQYXJhbXMod2ViVmlldywgc2Ny aXB0LCBXVEZNb3ZlKHBhcmFtcyksIGNhbmNlbGxhYmxlLCBjYWxsYmFjaywgdXNlckRhdGEpOwog fQogCiAvKioKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9nbGliL1dl YktpdFdlYlZpZXdJbnRlcm5hbC5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2dsaWIv V2ViS2l0V2ViVmlld0ludGVybmFsLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTQ0YmFhMDcyZjE2YjA5YmI1MGZm ZWFkY2YyMTBlMjY3MTMwMWEwNgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS9nbGliL1dlYktpdFdlYlZpZXdJbnRlcm5hbC5oCkBAIC0wLDAgKzEsMjggQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv bjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVk IGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBH TlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgor ICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUg dGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAor ICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNp bmNsdWRlIDxnaW8vZ2lvLmg+CisKKy8vIFByaXZhdGUgQVBJIHJlcXVpcmVkIGJ5IHRoZSB1bml0 IHRlc3RzLgorCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViVmlldyBXZWJLaXRXZWJWaWV3Owor Cit2b2lkIHdlYmtpdFdlYlZpZXdSdW5KYXZhc2NyaXB0V2l0aG91dEZvcmNlZFVzZXJHZXN0dXJl cyhXZWJLaXRXZWJWaWV3KiwgY29uc3QgZ2NoYXIqLCBHQ2FuY2VsbGFibGUqLCBHQXN5bmNSZWFk eUNhbGxiYWNrLCBncG9pbnRlcik7Cg==