102900 2012-11-21 01:36:18 -0800 Coordinated Graphics: refactor LayerTreeRenderer::syncRemoteContent(). 2012-11-21 14:11:14 -0800 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 dongseong.hwang dongseong.hwang abecsi cmarcelo gyuyoung.kim menard noam ostap73 rakuco webkit.review.bot zeno oldest_to_newest 772617 0 dongseong.hwang 2012-11-21 01:36:18 -0800 Currently, QQuickWebPage::updatePaintNode() calls LayerTreeRenderer::syncRemoteContent() with locking the main thread. syncRemoteContent() is heavy, so we should not call syncRemoteContent() in updatePaintNode() because syncRemoteContent() does not access any data structures, which the main thread use. After this patch, syncRemoteContent() is used only internally, so syncRemoteContent() becomes private. 772620 1 175376 dongseong.hwang 2012-11-21 01:39:03 -0800 Created attachment 175376 Patch 772625 2 dongseong.hwang 2012-11-21 01:40:17 -0800 After this patch, I can feel reducing lag due to texture uploading. For example, snowstack. http://www.satine.org/research/webkit/snowleopard/snowstack.html 772633 3 dongseong.hwang 2012-11-21 01:43:09 -0800 I decided to post this patch after reading Slava's mail. Thank Slava for explanation! Qt WK2 port already runs layer tree painting on separate thread. Layer tree renderer is created on main thread, but rendering is performed only on paint thread. Qt5 creates paint nodes for painting and QQuickWebPage paint node keeps threaded reference on LayerTreeRenderer. Messages to LayerTreeRenderer are delivered through dispatchUpdate/bind/renderQueue . All updates from renderQueue to renderer are applied in QQuickWebPage::updatePaintNode call. QQuickItem::updatePaintNode is very special call. During this call main thread is locked and it is safe to access main thread objects from paint thread. http://doc-snapshot.qt-project.org/5.0/qquickitem.html#updatePaintNode So, the only thing that needs to be implemented for GTK is replacement for Qt paint node and sync point similar to QQuickItem::updatePaintNode . 772919 4 175376 noam 2012-11-21 06:57:56 -0800 Comment on attachment 175376 Patch Good catch! 772937 5 175376 webkit.review.bot 2012-11-21 07:12:26 -0800 Comment on attachment 175376 Patch Clearing flags on attachment: 175376 Committed r135401: <http://trac.webkit.org/changeset/135401> 772938 6 webkit.review.bot 2012-11-21 07:12:31 -0800 All reviewed patches have been landed. Closing bug. 772975 7 175376 ostap73 2012-11-21 07:57:42 -0800 Comment on attachment 175376 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=175376&action=review > Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp:125 > + syncRemoteContent(); Actually, I doubt that it improves something and I would suspect regression here. QQuickWebPage::updatePaintNode is called only when update is required (like new tiles coming). LayerTreeRenderer::paintToCurrentGLContext is called for every paint, so with this patch it will be called more often and that's why individual tiles might come faster, because paint node update is called only from didRenderFrame. If faster displaying of incoming tile updates is desired this could be achieved by calling updateViewPort more often in LayerTreeCoordinatorProxy (like, for every incoming tile update), but this could cause visual partial update artifacts. Also, syncRemoteContent originally was also called from paint and I removed it intentionally because this function uses renderQueue which is accessible both from main and paint threads. Previously renderQueue had no locking and it worked because Qt5 guarantees that main thread is locked during updatePaintNode call. Now this might work because of locking of renderQueue, but it will crash it locking would be removed. 773272 8 dongseong.hwang 2012-11-21 14:11:14 -0800 (In reply to comment #7) > (From update of attachment 175376 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=175376&action=review > > > Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp:125 > > + syncRemoteContent(); > > Actually, I doubt that it improves something and I would suspect regression here. Thanks for helpful explanation! I could really feel reducing lag due to texture uploading. > QQuickWebPage::updatePaintNode is called only when update is required (like new tiles coming). LayerTreeRenderer::paintToCurrentGLContext is called for every paint, so with this patch it will be called more often and that's why individual tiles might come faster, because paint node update is called only from didRenderFrame. If faster displaying of incoming tile updates is desired this could be achieved by calling updateViewPort more often in LayerTreeCoordinatorProxy (like, for every incoming tile update), but this could cause visual partial update artifacts. Before I had changed, I hesitated due to your reason: updatePaintNode is called if needed. After taking some time to think, I arrived at the conclusion: it is safe. It is because we update tiles when handling didRenderFrame in that calling flushLayerChanges(), especially commitTileOperations(). LayerTreeRenderer::paintToCurrentGLContext can causes calling updateTile() but actual update is deferred until flushLayerChanges() is called. Furthermore, Web Process still wait to progress until receiving a RenderNextFrame message. void LayerTreeRenderer::flushLayerChanges() { m_renderedContentsScrollPosition = m_pendingRenderedContentsScrollPosition; // Since the frame has now been rendered, we can safely unlock the animations until the next layout. setAnimationsLocked(false); m_rootLayer->flushCompositingState(FloatRect()); commitTileOperations(); removeReleasedImageBackingsIfNeeded(); // The pending tiles state is on its way for the screen, tell the web process to render the next one. dispatchOnMainThread(bind(&LayerTreeRenderer::renderNextFrame, this)); } > Also, syncRemoteContent originally was also called from paint and I removed it intentionally because this function uses renderQueue which is accessible both from main and paint threads. Previously renderQueue had no locking and it worked because Qt5 guarantees that main thread is locked during updatePaintNode call. Now this might work because of locking of renderQueue, but it will crash it locking would be removed. Yes, your work ensuring atomic operation encouraged me to make the patch. syncRemoteContent is not called from external clients anymore and LayerTreeRenderer::paintToGraphicsContext also calls syncRemoteContent, so I think it is natural for LayerTreeRenderer::paintToCurrentGLContext to call syncRemoteContent now. However, when another requirement exists, syncRemoteContent can be public again. I'm ok. Please let me know if there is gap with your opinion. 175376 2012-11-21 01:39:03 -0800 2012-11-21 07:57:42 -0800 Patch bug-102900-20121121183650.patch text/plain 6725 dongseong.hwang U3VidmVyc2lvbiBSZXZpc2lvbjogMTM1MzU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMWZlZGY4OTQ0MmZmYWFh NmYxYWFmMWE3YjEyNjUyMTk4MzMyNzE4NC4uMTE2NTE0NGIzNDMwNGY1OGE0MjhlMDRjNTc0NmIy MzVkNjI5M2Y2MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDM0IEBACiAyMDEyLTExLTIxICBIdWFu ZyBEb25nc3VuZyAgPGx1eHRlbGxhQGNvbXBhbnkxMDAubmV0PgogCisgICAgICAgIENvb3JkaW5h dGVkIEdyYXBoaWNzOiByZWZhY3RvciBMYXllclRyZWVSZW5kZXJlcjo6c3luY1JlbW90ZUNvbnRl bnQoKS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEw MjkwMAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEN1 cnJlbnRseSwgUVF1aWNrV2ViUGFnZTo6dXBkYXRlUGFpbnROb2RlKCkgY2FsbHMKKyAgICAgICAg TGF5ZXJUcmVlUmVuZGVyZXI6OnN5bmNSZW1vdGVDb250ZW50KCkgd2l0aCBsb2NraW5nIHRoZSBt YWluIHRocmVhZC4KKyAgICAgICAgc3luY1JlbW90ZUNvbnRlbnQoKSBpcyBoZWF2eSwgc28gd2Ug c2hvdWxkIG5vdCBjYWxsIHN5bmNSZW1vdGVDb250ZW50KCkgaW4KKyAgICAgICAgdXBkYXRlUGFp bnROb2RlKCkuIENhbGxpbmcgc3luY1JlbW90ZUNvbnRlbnQoKSBpbiB0aGUgcGFpbnRpbmcgdGhy ZWFkIGlzCisgICAgICAgIHRocmVhZC1zYWZlIGJlY2F1c2Ugc3luY1JlbW90ZUNvbnRlbnQoKSBk b2VzIG5vdCBhY2Nlc3MgYW55IGRhdGEKKyAgICAgICAgc3RydWN0dXJlcywgd2hpY2ggdGhlIG1h aW4gdGhyZWFkIHVzZS4KKworICAgICAgICBBZnRlciB0aGlzIHBhdGNoLCBzeW5jUmVtb3RlQ29u dGVudCgpIGlzIHVzZWQgb25seSBpbnRlcm5hbGx5LCBzbworICAgICAgICBzeW5jUmVtb3RlQ29u dGVudCgpIGJlY29tZXMgcHJpdmF0ZS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZWZsL0V3 a1ZpZXdJbXBsLmNwcDoKKyAgICAgICAgKEV3a1ZpZXdJbXBsOjpkaXNwbGF5VGltZXJGaXJlZCk6 CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9xdC9xcXVpY2t3ZWJwYWdlLmNwcDoKKyAgICAgICAg KFFRdWlja1dlYlBhZ2U6OnVwZGF0ZVBhaW50Tm9kZSk6CisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9xdC9yYXcvcXJhd3dlYnZpZXcuY3BwOgorICAgICAgICAoUVJhd1dlYlZpZXc6OnBhaW50KToK KyAgICAgICAgKiBVSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9MYXllclRyZWVSZW5kZXJl ci5jcHA6CisgICAgICAgIChXZWJLaXQ6OkxheWVyVHJlZVJlbmRlcmVyOjpwYWludFRvQ3VycmVu dEdMQ29udGV4dCk6CisgICAgICAgIChXZWJLaXQ6OkxheWVyVHJlZVJlbmRlcmVyOjplbnN1cmVS b290TGF5ZXIpOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL0xheWVy VHJlZVJlbmRlcmVyLmg6CisgICAgICAgIChMYXllclRyZWVSZW5kZXJlcik6CisKKzIwMTItMTEt MjEgIEh1YW5nIERvbmdzdW5nICA8bHV4dGVsbGFAY29tcGFueTEwMC5uZXQ+CisKICAgICAgICAg Q29vcmRpbmF0ZWQgR3JhcGhpY3M6IHJlZmFjdG9yIGNoYW5naW5nIGNoaWxkcmVuIGNvZGUgaW4g Q29vcmRpbmF0ZWRHcmFwaGljc0xheWVyLgogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTAyODk2CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZWZsL0V3a1ZpZXdJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZWZsL0V3a1ZpZXdJbXBsLmNwcAppbmRleCAwMDQ0MzQxOTI3ZTgyYjdlZjdjNDFjN2Ey MGM2ZWI3MjdmNGQyMTFjLi40YzdlODAwMWEwNWRiYTViMzJjZDlhYjUzNmI1NjEzNDNjNDhkZDU1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9Fd2tWaWV3SW1w bC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvRXdrVmlld0ltcGwu Y3BwCkBAIC0zNTksNyArMzU5LDYgQEAgdm9pZCBFd2tWaWV3SW1wbDo6ZGlzcGxheVRpbWVyRmly ZWQoVGltZXI8RXdrVmlld0ltcGw+KikKIAogICAgIHJlbmRlcmVyLT5zZXRBY3RpdmUodHJ1ZSk7 CiAgICAgcmVuZGVyZXItPnNldERyYXdzQmFja2dyb3VuZChtX3NldERyYXdzQmFja2dyb3VuZCk7 Ci0gICAgcmVuZGVyZXItPnN5bmNSZW1vdGVDb250ZW50KCk7CiAgICAgaWYgKG1faXNIYXJkd2Fy ZUFjY2VsZXJhdGVkKSB7CiAgICAgICAgIHJlbmRlcmVyLT5wYWludFRvQ3VycmVudEdMQ29udGV4 dCh0cmFuc2Zvcm1Ub1NjZW5lKCkudG9UcmFuc2Zvcm1hdGlvbk1hdHJpeCgpLCAvKiBvcGFjaXR5 ICovIDEsIHZpZXdwb3J0KTsKICAgICAgICAgLy8gc2QtPmltYWdlIGlzIHRpZWQgdG8gYSBuYXRp dmUgc3VyZmFjZS4gVGhlIG5hdGl2ZSBzdXJmYWNlIGlzIGluIHRoZSBwYXJlbnQncyBjb29yZGlu YXRlcywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvcXQvcXF1aWNr d2VicGFnZS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL3F0L3FxdWlja3dlYnBh Z2UuY3BwCmluZGV4IDcxNjg4Y2JlNjg2ODlmNjA3MmYwYTllMDQzNTc5M2ExZjE3NzhjYjUuLmU1 ZjNkM2VkNDc0MGZlMDJmNTFkNTFlMWU1ZTYwZTMwMWNhMDA2MGQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvcXQvcXF1aWNrd2VicGFnZS5jcHAKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9xdC9xcXVpY2t3ZWJwYWdlLmNwcApAQCAtODcsNyArODcs NiBAQCBRU0dOb2RlKiBRUXVpY2tXZWJQYWdlOjp1cGRhdGVQYWludE5vZGUoUVNHTm9kZSogb2xk Tm9kZSwgVXBkYXRlUGFpbnROb2RlRGF0YSopCiAgICAgaWYgKCFub2RlKQogICAgICAgICBub2Rl ID0gbmV3IFF0V2ViUGFnZVNHTm9kZSgpOwogICAgIG5vZGUtPnNldFJlbmRlcmVyKHJlbmRlcmVy KTsKLSAgICByZW5kZXJlci0+c3luY1JlbW90ZUNvbnRlbnQoKTsKIAogICAgIG5vZGUtPnNldFNj YWxlKGQtPmNvbnRlbnRzU2NhbGUpOwogICAgIFFDb2xvciBiYWNrZ3JvdW5kQ29sb3IgPSBkLT53 ZWJQYWdlUHJveHktPmRyYXdzVHJhbnNwYXJlbnRCYWNrZ3JvdW5kKCkgPyBRdDo6dHJhbnNwYXJl bnQgOiBRdDo6d2hpdGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L3F0L3Jhdy9xcmF3d2Vidmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL3F0 L3Jhdy9xcmF3d2Vidmlldy5jcHAKaW5kZXggNWY2YzE2ZDU2YzFkMzkzYWU4MDA3MmUxODA0MGRh YzE2MGJjY2ZjYi4uZjVmMGJkM2Y5OWZmNDMyMWY2ZjcwMTZiNmQwNzA3MTM2YTliMmUzZiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9xdC9yYXcvcXJhd3dlYnZpZXcu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvcXQvcmF3L3FyYXd3ZWJ2aWV3 LmNwcApAQCAtMzc2LDcgKzM3Niw2IEBAIHZvaWQgUVJhd1dlYlZpZXc6OnBhaW50KGNvbnN0IFFN YXRyaXg0eDQmIHRyYW5zZm9ybSwgZmxvYXQgb3BhY2l0eSwgdW5zaWduZWQgcGFpCiAgICAgICAg IHJldHVybjsKIAogICAgIHJlbmRlcmVyLT5zZXRBY3RpdmUodHJ1ZSk7Ci0gICAgcmVuZGVyZXIt PnN5bmNSZW1vdGVDb250ZW50KCk7CiAKICAgICBXZWJDb3JlOjpGbG9hdFJlY3QgcmVjdCgwLCAw LCBkLT5tX3NpemUud2lkdGgoKSwgZC0+bV9zaXplLmhlaWdodCgpKTsKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvTGF5ZXJUcmVlUmVu ZGVyZXIuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3Mv TGF5ZXJUcmVlUmVuZGVyZXIuY3BwCmluZGV4IDRlZWZhYTAzZjJiMTNlYmJkNDE0ZjJmOWI5NWZj NGMxY2M1MGJjZWIuLjI5YmE5Mjk5NDIyZDkwZjkzZjIxMmU3NWEwMGNiYTZlMGUwOTQwZWMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL0xh eWVyVHJlZVJlbmRlcmVyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRp bmF0ZWRHcmFwaGljcy9MYXllclRyZWVSZW5kZXJlci5jcHAKQEAgLTEyMiw2ICsxMjIsNyBAQCB2 b2lkIExheWVyVHJlZVJlbmRlcmVyOjpwYWludFRvQ3VycmVudEdMQ29udGV4dChjb25zdCBUcmFu c2Zvcm1hdGlvbk1hdHJpeCYgbWF0cgogICAgIGlmICghbV90ZXh0dXJlTWFwcGVyKQogICAgICAg ICBtX3RleHR1cmVNYXBwZXIgPSBUZXh0dXJlTWFwcGVyOjpjcmVhdGUoVGV4dHVyZU1hcHBlcjo6 T3BlbkdMTW9kZSk7CiAgICAgQVNTRVJUKG1fdGV4dHVyZU1hcHBlci0+YWNjZWxlcmF0aW9uTW9k ZSgpID09IFRleHR1cmVNYXBwZXI6Ok9wZW5HTE1vZGUpOworICAgIHN5bmNSZW1vdGVDb250ZW50 KCk7CiAKICAgICBhZGp1c3RQb3NpdGlvbkZvckZpeGVkTGF5ZXJzKCk7CiAgICAgR3JhcGhpY3NM YXllciogY3VycmVudFJvb3RMYXllciA9IHJvb3RMYXllcigpOwpAQCAtNTgwLDEwICs1ODEsNiBA QCB2b2lkIExheWVyVHJlZVJlbmRlcmVyOjplbnN1cmVSb290TGF5ZXIoKQogewogICAgIGlmICht X3Jvb3RMYXllcikKICAgICAgICAgcmV0dXJuOwotICAgIGlmICghbV90ZXh0dXJlTWFwcGVyKSB7 Ci0gICAgICAgIG1fdGV4dHVyZU1hcHBlciA9IFRleHR1cmVNYXBwZXI6OmNyZWF0ZShtX2FjY2Vs ZXJhdGlvbk1vZGUpOwotICAgICAgICBzdGF0aWNfY2FzdDxUZXh0dXJlTWFwcGVyR0wqPihtX3Rl eHR1cmVNYXBwZXIuZ2V0KCkpLT5zZXRFbmFibGVFZGdlRGlzdGFuY2VBbnRpYWxpYXNpbmcodHJ1 ZSk7Ci0gICAgfQogCiAgICAgbV9yb290TGF5ZXIgPSBjcmVhdGVMYXllcihJbnZhbGlkV2ViTGF5 ZXJJRCk7CiAgICAgbV9yb290TGF5ZXItPnNldE1hc2tzVG9Cb3VuZHMoZmFsc2UpOwpAQCAtNTky LDYgKzU4OSw4IEBAIHZvaWQgTGF5ZXJUcmVlUmVuZGVyZXI6OmVuc3VyZVJvb3RMYXllcigpCiAK ICAgICAvLyBUaGUgcm9vdCBsYXllciBzaG91bGQgbm90IGhhdmUgemVybyBzaXplLCBvciBpdCB3 b3VsZCBiZSBvcHRpbWl6ZWQgb3V0LgogICAgIG1fcm9vdExheWVyLT5zZXRTaXplKEZsb2F0U2l6 ZSgxLjAsIDEuMCkpOworCisgICAgQVNTRVJUKG1fdGV4dHVyZU1hcHBlcik7CiAgICAgdG9UZXh0 dXJlTWFwcGVyTGF5ZXIobV9yb290TGF5ZXIuZ2V0KCkpLT5zZXRUZXh0dXJlTWFwcGVyKG1fdGV4 dHVyZU1hcHBlci5nZXQoKSk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL0xheWVyVHJlZVJlbmRlcmVyLmggYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9MYXllclRyZWVSZW5kZXJlci5oCmlu ZGV4IDNhNWVmZjZmZDNiNmNmYTc1MGY5OGIyNDA4OWJmOTJhZDUxOTdkZWYuLjZjMjAzZjJkNWQw YjgxMGVhMzAzZTMxNGI3YzAwZWY4YzVlMzU5YjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL0xheWVyVHJlZVJlbmRlcmVyLmgKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvTGF5ZXJUcmVlUmVu ZGVyZXIuaApAQCAtNzAsNyArNzAsNiBAQCBwdWJsaWM6CiAgICAgdm9pZCBwdXJnZUdMUmVzb3Vy Y2VzKCk7CiAgICAgdm9pZCBwYWludFRvQ3VycmVudEdMQ29udGV4dChjb25zdCBXZWJDb3JlOjpU cmFuc2Zvcm1hdGlvbk1hdHJpeCYsIGZsb2F0LCBjb25zdCBXZWJDb3JlOjpGbG9hdFJlY3QmLCBX ZWJDb3JlOjpUZXh0dXJlTWFwcGVyOjpQYWludEZsYWdzID0gMCk7CiAgICAgdm9pZCBwYWludFRv R3JhcGhpY3NDb250ZXh0KEJhY2tpbmdTdG9yZTo6UGxhdGZvcm1HcmFwaGljc0NvbnRleHQpOwot ICAgIHZvaWQgc3luY1JlbW90ZUNvbnRlbnQoKTsKICAgICB2b2lkIHNldENvbnRlbnRzU2l6ZShj b25zdCBXZWJDb3JlOjpGbG9hdFNpemUmKTsKICAgICB2b2lkIHNldFZpc2libGVDb250ZW50c1Jl Y3QoY29uc3QgV2ViQ29yZTo6RmxvYXRSZWN0Jik7CiAgICAgdm9pZCBkaWRDaGFuZ2VTY3JvbGxQ b3NpdGlvbihjb25zdCBXZWJDb3JlOjpJbnRQb2ludCYgcG9zaXRpb24pOwpAQCAtMTI3LDYgKzEy Niw4IEBAIHByaXZhdGU6CiAgICAgV2ViQ29yZTo6R3JhcGhpY3NMYXllciogbGF5ZXJCeUlEKFdl YkxheWVySUQgaWQpIHsgcmV0dXJuIChpZCA9PSBJbnZhbGlkV2ViTGF5ZXJJRCkgPyAwIDogbV9s YXllcnMuZ2V0KGlkKTsgfQogICAgIFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXIqIHJvb3RMYXllcigp IHsgcmV0dXJuIG1fcm9vdExheWVyLmdldCgpOyB9CiAKKyAgICB2b2lkIHN5bmNSZW1vdGVDb250 ZW50KCk7CisKICAgICAvLyBSZWltcGxlbWVudGF0aW9ucyBmcm9tIFdlYkNvcmU6OkdyYXBoaWNz TGF5ZXJDbGllbnQuCiAgICAgdmlydHVhbCB2b2lkIG5vdGlmeUFuaW1hdGlvblN0YXJ0ZWQoY29u c3QgV2ViQ29yZTo6R3JhcGhpY3NMYXllciosIGRvdWJsZSkgeyB9CiAgICAgdmlydHVhbCB2b2lk IG5vdGlmeUZsdXNoUmVxdWlyZWQoY29uc3QgV2ViQ29yZTo6R3JhcGhpY3NMYXllciopIHsgfQo=