160450 2016-08-02 06:27:08 -0700 [GTK][Threaded Compositor] Several flaky tests due to differences in scrollbars 2016-08-26 06:53:35 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Local Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=161242 Gtk, LayoutTestFailure P2 Normal --- 1 cgarcia webkit-unassigned bugs-noreply commit-queue mcatanzaro yoon zan oldest_to_newest 1216471 0 cgarcia 2016-08-02 06:27:08 -0700 We still have a lot of flaky tests since we switched to the threaded compositor. I can't reproduce them though. I've seen several reftests failing because there's a part of the vertical scrollbar that is not rendered. It turns out that the part not rendered is the second tile of the scrollbar layer, that for some reason it seems to be rendered later. So, my guess is that we force a repaint that when finishes hasn't actually painted all the tiles. Then the UI process takes the screenshot too early, before the second tile of the scrollbar layer is actually painted. I took advantage of the DRI3 bug, to see how things happen when everything is slow, and that's exactly what happens, everything is rendered in one pass and then the second tile of the scrollbar layer. See: http://people.igalia.com/cgarcia/webkitgtk-scrollbar-layer.mp4 I'm not sure how to fix it, because I don't know why that happens and I can't really reproduce the flakiness, but we could try to wait for more damage events in the UI process before taking the screenshot. 1216835 1 285207 cgarcia 2016-08-03 00:58:16 -0700 Created attachment 285207 Speculative fix 1216837 2 commit-queue 2016-08-03 01:01:35 -0700 Attachment 285207 did not pass style-queue: ERROR: Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp:353: Extra space before ( in function call [whitespace/parens] [4] ERROR: Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h:94: Extra space before ( in function call [whitespace/parens] [4] ERROR: Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h:104: Extra space before ( in function call [whitespace/parens] [4] Total errors found: 3 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 1217948 3 285207 mcatanzaro 2016-08-05 10:14:36 -0700 Comment on attachment 285207 Speculative fix View in context: https://bugs.webkit.org/attachment.cgi?id=285207&action=review > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp:359 > +#if PLATFORM(GTK) > + g_signal_connect_swapped(m_webPage.viewWidget(), "draw", reinterpret_cast<GCallback>(webViewDrawCallback), this); > + m_timer.startOneShot(1); So we have a DrawingMonitor class that doesn't actually monitor drawing unless PLATFORM(GTK). Consider guarding the entire class and putting an #ifdef in DrawingAreaProxyImpl::dispatchAfterEnsuringDrawing so it's not used at all on other platforms. > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp:382 > + // We wait up to 1 second for draw events. If there are several draw events queued quickly, > + // we want to wait until all of them have been processed, so after receiving a draw, we wait > + // up to 100ms for the next one or stop. I have no clue if this is right or sensible, but OK. > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h:89 > + class DrawingMonitor { > + WTF_MAKE_NONCOPYABLE(DrawingMonitor); WTF_MAKE_FAST_ALLOCATED; Does it really make sense to use WTF_MAKE_FAST_ALLOCATED for a class that will rarely be allocated? > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h:136 > + std::unique_ptr<DrawingMonitor> m_drawingMonitor; This use of std::unique_ptr appears to be unnecessary, since you're not using it for polymorphism, you don't really need the null state, and you don't appear to need the lazy initialization. You can just keep a DrawingMonitor member, then you don't need to worry about creating it in DrawingAreaProxyImpl::dispatchAfterEnsuringDrawing or checking that it's not null. 1218196 4 cgarcia 2016-08-05 22:57:25 -0700 (In reply to comment #3) > Comment on attachment 285207 [details] > Speculative fix > > View in context: > https://bugs.webkit.org/attachment.cgi?id=285207&action=review Thanks for the review. I think Zan was looking at the actual cause of the scrollbars drawing delay, so I'll wait until he confirms this is ok. > > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp:359 > > +#if PLATFORM(GTK) > > + g_signal_connect_swapped(m_webPage.viewWidget(), "draw", reinterpret_cast<GCallback>(webViewDrawCallback), this); > > + m_timer.startOneShot(1); > > So we have a DrawingMonitor class that doesn't actually monitor drawing > unless PLATFORM(GTK). Consider guarding the entire class and putting an > #ifdef in DrawingAreaProxyImpl::dispatchAfterEnsuringDrawing so it's not > used at all on other platforms. This file is actually only used by GTK anyway, what is protected by GTK is the actual use of GTK API. > > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp:382 > > + // We wait up to 1 second for draw events. If there are several draw events queued quickly, > > + // we want to wait until all of them have been processed, so after receiving a draw, we wait > > + // up to 100ms for the next one or stop. > > I have no clue if this is right or sensible, but OK. Note that this patch is just an experiment to see if flaky tests are reduced in the bots, so I just took those numbers arbitrarily. I didn't want to delay tests for more than 1 second, and if we could finish earlier we do. > > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h:89 > > + class DrawingMonitor { > > + WTF_MAKE_NONCOPYABLE(DrawingMonitor); WTF_MAKE_FAST_ALLOCATED; > > Does it really make sense to use WTF_MAKE_FAST_ALLOCATED for a class that > will rarely be allocated? I don't know, I guess it's harmless. > > Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h:136 > > + std::unique_ptr<DrawingMonitor> m_drawingMonitor; > > This use of std::unique_ptr appears to be unnecessary, since you're not > using it for polymorphism, you don't really need the null state, and you > don't appear to need the lazy initialization. You can just keep a > DrawingMonitor member, then you don't need to worry about creating it in > DrawingAreaProxyImpl::dispatchAfterEnsuringDrawing or checking that it's not > null. This is only used by tests, so when no running tests, it's better to not have that monitor thing created, that's why I create it on demand. 1218197 5 285207 cgarcia 2016-08-05 22:57:46 -0700 Comment on attachment 285207 Speculative fix cq- for now 1218241 6 mcatanzaro 2016-08-06 07:43:14 -0700 Zan :) (In reply to comment #4) > This is only used by tests, so when no running tests, it's better to not > have that monitor thing created, that's why I create it on demand. I'd add a comment to that effect if you don't want someone "optimizing" away the pointer in the future. 1218461 7 285558 zan 2016-08-07 23:09:21 -0700 Created attachment 285558 Simplified test case Just sets up a 400px-wide column that enforces a scrollbar. Reproduces the scrollbar issue in MiniBrowser. It's easier to observe it if a sleep() call is placed into the CoordinatedLayerTreeHost timer callback, along with either using mock scrollbars or exporting GTK_OVERLAY_SCOLLING=0. 1218473 8 zan 2016-08-08 03:02:23 -0700 OK, the issue is that when loading the test case in MiniBrowser, ThreadedCompositor::didChangeVisibleRect() dispatches the setVisibleContentsRect() call that ends up in CompositingCoordinator. Since we're compositing the scrollbars as well, this visible contents rect needs to encompass the complete width of the view, but that's not happening. In case of mock scrollbars, the rightmost 15px are clipped from this rect, but that doesn't prevent the scrollbar overlay layers to be flushed and rendered. What does happen is that during tile creation in the backing store the tiles that would normally intersect the visible rect of the view (if it were spanning over the whole actual visible area) are sorted by distance to the visible rect. The top of the two tiles used for the scrollbar is closer to the visible rect, so that gets created and filled in first. The second tile is stored as pending for creation, and does get rendered at the point of the next layer flush. None of this would be a problem if the setVisibleContentsRect() was passed a proper rect that would cover the whole view. 1223035 9 286961 cgarcia 2016-08-25 05:51:39 -0700 Created attachment 286961 Patch This should be the proper fix, I think. At least it seems to work. Thanks for the explanation Zan, I've copied it to the changelog entry :-) 1223061 10 cgarcia 2016-08-25 08:41:10 -0700 Committed r204961: <http://trac.webkit.org/changeset/204961> 1223333 11 mcatanzaro 2016-08-25 17:00:37 -0700 Didn't work, we had more builds after this landed with huge number of flakes: https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20(Tests)/builds/17873 https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20(Tests)/builds/17874 https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20(Tests)/builds/17877 We need to investigate the 40 unexpected passes in 17877; that is definitely related to the flakes and fallout from threaded compositor. 1223418 12 cgarcia 2016-08-25 23:28:18 -0700 (In reply to comment #11) > Didn't work, we had more builds after this landed with huge number of flakes: No, it worked, it's just that this was not the only cause of flakiness, if you look at the results, there isn't any case in which we don't render the full scrollbar, what the patch fixed. Now it seems we have problems with borders, and also with scrollbars that sometimes are shown (the whole scrollbar) when they shouldn't and the other way around. We need to investigate why. > https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20(Tests)/ > builds/17873 > https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20(Tests)/ > builds/17874 > https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20(Tests)/ > builds/17877 > > We need to investigate the 40 unexpected passes in 17877; that is definitely > related to the flakes and fallout from threaded compositor. Yes. 285207 2016-08-03 00:58:16 -0700 2016-08-25 05:51:39 -0700 Speculative fix wk2-flaky-tests.diff text/plain 6729 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCAzYzY1MGZjLi4zMTc2ZGMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMg QEAKKzIwMTYtMDgtMDMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtHVEtdW1RocmVhZGVkIENvbXBvc2l0b3JdIFNldmVyYWwgZmxha3kgdGVz dHMgZHVlIHRvIGRpZmZlcmVuY2VzIGluIHNjcm9sbGJhcnMKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MDQ1MAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlIHN0aWxsIGhhdmUgYSBsb3Qgb2YgZmxha3kg dGVzdHMgc2luY2Ugd2Ugc3dpdGNoZWQgdG8gdGhlIHRocmVhZGVkIGNvbXBvc2l0b3IuIEkndmUg c2VlbiBzZXZlcmFsIHJlZnRlc3RzCisgICAgICAgIGZhaWxpbmcgYmVjYXVzZSB0aGVyZSdzIGEg cGFydCBvZiB0aGUgdmVydGljYWwgc2Nyb2xsYmFyIHRoYXQgaXMgbm90IHJlbmRlcmVkLiBJdCB0 dXJucyBvdXQgdGhhdCB0aGUgcGFydCBub3QKKyAgICAgICAgcmVuZGVyZWQgaXMgdGhlIHNlY29u ZCB0aWxlIG9mIHRoZSBzY3JvbGxiYXIgbGF5ZXIsIHRoYXQgZm9yIHNvbWUgcmVhc29uIGl0IHNl ZW1zIHRvIGJlIHJlbmRlcmVkIGxhdGVyLiBTbywgbXkKKyAgICAgICAgZ3Vlc3MgaXMgdGhhdCB3 ZSBmb3JjZSBhIHJlcGFpbnQgdGhhdCB3aGVuIGZpbmlzaGVzIGhhc24ndCBhY3R1YWxseSBwYWlu dGVkIGFsbCB0aGUgdGlsZXMuIFRoZW4gdGhlIFVJIHByb2Nlc3MKKyAgICAgICAgdGFrZXMgdGhl IHNjcmVlbnNob3QgdG9vIGVhcmx5LCBiZWZvcmUgdGhlIHNlY29uZCB0aWxlIG9mIHRoZSBzY3Jv bGxiYXIgbGF5ZXIgaXMgYWN0dWFsbHkgcGFpbnRlZC4KKyAgICAgICAgSSBjYW4ndCByZXByb2R1 Y2UgdGhlIHByb2JsZW0sIHNvIHRoaXMgaXMgYWN0dWFsbHkgYSBzcGVjdWxhdGl2ZSBmaXggb3Ig d29ya2Fyb3VuZC4gT3VyIGltcGxlbWVudGF0aW9uIG9mCisgICAgICAgIERyYXdpbmdBcmVhOjpk aXNwYXRjaEFmdGVyRW5zdXJpbmdEcmF3aW5nKCkgaXMgcXVpdGUgc2ltcGxlLCB3ZSBqdXN0IGRp c3BhdGNoIHRoZSBjYWxsYmFjayBpbiB0aGUgbmV4dCBydW4gbG9vcAorICAgICAgICBvcGVyYXRp b24sIHdoaWNoIGRvZXNuJ3QgcmVhbGx5IGVuc3VyZXMgYW55IGRyYXdpbmcgYXQgYWxsLiBTbywg d2UgY2FuIHdhaXQgZm9yIGRyYXcgZXZlbnRzIGJlZm9yZSBkaXNwYXRjaGluZworICAgICAgICB0 aGUgZ2l2ZW4gY2FsbGJhY2suIFNpbmNlIHdlIGRvbid0IHJlYWxseSBrbm93IGlmIGRyYXcgZXZl bnRzIHdlcmUgYWxyZWFkeSBwcm9jZXNzZWQgYmVmb3JlCisgICAgICAgIGRpc3BhdGNoQWZ0ZXJF bnN1cmluZ0RyYXdpbmcoKSBpcyBjYWxsZWQsIG9yIGlmIHRoZXJlIHdpbGwgYmUgbW9yZSB0aGFu IG9uZSBkYW1hZ2UgZXZlbnQgaW4gYSBzaG9ydCB0aW1lLCB0aGlzCisgICAgICAgIHBhdGNoIHdh aXRzIHVwIHRvIDEgc2Vjb25kIGZvciBkcmF3IGV2ZW50cywgYW5kIGlmIGEgZHJhdyBoYXBwZW5z IGl0IHN0b3BzIGlmIHRoZXJlIGlucyd0IGFub3RoZXIgZHJhdyBldmVudCBpbgorICAgICAgICB0 aGUgbmV4dCAxMDBtcy4gVGhpcyBzaG91bGQgZW5zdXJlIGEgZHJhd2luZyBpZiBpdCB3YXMgcmVh bGx5IG5lZWRlZC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9EcmF3aW5nQXJlYVByb3h5SW1wbC5j cHA6CisgICAgICAgIChXZWJLaXQ6OkRyYXdpbmdBcmVhUHJveHlJbXBsOjpEcmF3aW5nTW9uaXRv cjo6RHJhd2luZ01vbml0b3IpOgorICAgICAgICAoV2ViS2l0OjpEcmF3aW5nQXJlYVByb3h5SW1w bDo6RHJhd2luZ01vbml0b3I6On5EcmF3aW5nTW9uaXRvcik6CisgICAgICAgIChXZWJLaXQ6OkRy YXdpbmdBcmVhUHJveHlJbXBsOjpEcmF3aW5nTW9uaXRvcjo6d2ViVmlld0RyYXdDYWxsYmFjayk6 CisgICAgICAgIChXZWJLaXQ6OkRyYXdpbmdBcmVhUHJveHlJbXBsOjpEcmF3aW5nTW9uaXRvcjo6 c3RhcnQpOgorICAgICAgICAoV2ViS2l0OjpEcmF3aW5nQXJlYVByb3h5SW1wbDo6RHJhd2luZ01v bml0b3I6OnN0b3ApOgorICAgICAgICAoV2ViS2l0OjpEcmF3aW5nQXJlYVByb3h5SW1wbDo6RHJh d2luZ01vbml0b3I6OmRpZERyYXcpOgorICAgICAgICAoV2ViS2l0OjpEcmF3aW5nQXJlYVByb3h5 SW1wbDo6ZGlzcGF0Y2hBZnRlckVuc3VyaW5nRHJhd2luZyk6CisgICAgICAgICogVUlQcm9jZXNz L0RyYXdpbmdBcmVhUHJveHlJbXBsLmg6CisKIDIwMTYtMDgtMDIgIENhcmxvcyBHYXJjaWEgQ2Ft cG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIEJhZCBwZXJmb3JtYW5j ZSBpbiBhY2NlbGVyYXRlZCBjb21wb3NpdGluZyBtb2RlIHdpdGggdGhlIG1vZGVzZXR0aW5nIGlu dGVsIGRyaXZlciBhbmQgRFJJMyBlbmFibGVkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvRHJhd2luZ0FyZWFQcm94eUltcGwuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0RyYXdpbmdBcmVhUHJveHlJbXBsLmNwcAppbmRleCAyNDc2Mjk2Li4wZjZmMDUzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvRHJhd2luZ0FyZWFQcm94eUltcGwuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9EcmF3aW5nQXJlYVByb3h5SW1wbC5jcHAK QEAgLTM2LDYgKzM2LDEwIEBACiAjaW5jbHVkZSAiV2ViUHJvY2Vzc1Byb3h5LmgiCiAjaW5jbHVk ZSA8V2ViQ29yZS9SZWdpb24uaD4KIAorI2lmIFBMQVRGT1JNKEdUSykKKyNpbmNsdWRlIDxndGsv Z3RrLmg+CisjZW5kaWYKKwogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKIG5hbWVzcGFjZSBX ZWJLaXQgewpAQCAtMzI4LDYgKzMzMiw2MCBAQCB2b2lkIERyYXdpbmdBcmVhUHJveHlJbXBsOjpk ZXN0cm95TmF0aXZlU3VyZmFjZUhhbmRsZUZvckNvbXBvc2l0aW5nKCkKIH0KICNlbmRpZgogCitE cmF3aW5nQXJlYVByb3h5SW1wbDo6RHJhd2luZ01vbml0b3I6OkRyYXdpbmdNb25pdG9yKFdlYlBh Z2VQcm94eSYgd2ViUGFnZSkKKyAgICA6IG1fd2ViUGFnZSh3ZWJQYWdlKQorICAgICwgbV90aW1l cihSdW5Mb29wOjptYWluKCksIHRoaXMsICZEcmF3aW5nTW9uaXRvcjo6c3RvcCkKK3sKK30KKwor RHJhd2luZ0FyZWFQcm94eUltcGw6OkRyYXdpbmdNb25pdG9yOjp+RHJhd2luZ01vbml0b3IoKQor eworICAgIG1fY2FsbGJhY2sgPSBudWxscHRyOworICAgIHN0b3AoKTsKK30KKworaW50IERyYXdp bmdBcmVhUHJveHlJbXBsOjpEcmF3aW5nTW9uaXRvcjo6d2ViVmlld0RyYXdDYWxsYmFjayhEcmF3 aW5nQXJlYVByb3h5SW1wbDo6RHJhd2luZ01vbml0b3IqIG1vbml0b3IpCit7CisgICAgbW9uaXRv ci0+ZGlkRHJhdygpOworICAgIHJldHVybiBGQUxTRTsKK30KKwordm9pZCBEcmF3aW5nQXJlYVBy b3h5SW1wbDo6RHJhd2luZ01vbml0b3I6OnN0YXJ0KHN0ZDo6ZnVuY3Rpb248dm9pZCAoQ2FsbGJh Y2tCYXNlOjpFcnJvcik+IGNhbGxiYWNrKQoreworICAgIG1fc3RhcnRUaW1lID0gbW9ub3Rvbmlj YWxseUluY3JlYXNpbmdUaW1lTVMoKTsKKyAgICBtX2NhbGxiYWNrID0gY2FsbGJhY2s7CisjaWYg UExBVEZPUk0oR1RLKQorICAgIGdfc2lnbmFsX2Nvbm5lY3Rfc3dhcHBlZChtX3dlYlBhZ2Uudmll d1dpZGdldCgpLCAiZHJhdyIsIHJlaW50ZXJwcmV0X2Nhc3Q8R0NhbGxiYWNrPih3ZWJWaWV3RHJh d0NhbGxiYWNrKSwgdGhpcyk7CisgICAgbV90aW1lci5zdGFydE9uZVNob3QoMSk7CisjZWxzZQor ICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KDApOworI2VuZGlmCit9CisKK3ZvaWQgRHJhd2luZ0Fy ZWFQcm94eUltcGw6OkRyYXdpbmdNb25pdG9yOjpzdG9wKCkKK3sKKyAgICBtX3RpbWVyLnN0b3Ao KTsKKyNpZiBQTEFURk9STShHVEspCisgICAgZ19zaWduYWxfaGFuZGxlcnNfZGlzY29ubmVjdF9i eV9mdW5jKG1fd2ViUGFnZS52aWV3V2lkZ2V0KCksIHJlaW50ZXJwcmV0X2Nhc3Q8Z3BvaW50ZXI+ KHdlYlZpZXdEcmF3Q2FsbGJhY2spLCB0aGlzKTsKKyNlbmRpZgorICAgIG1fc3RhcnRUaW1lID0g MDsKKyAgICBpZiAobV9jYWxsYmFjaykgeworICAgICAgICBtX2NhbGxiYWNrKENhbGxiYWNrQmFz ZTo6RXJyb3I6Ok5vbmUpOworICAgICAgICBtX2NhbGxiYWNrID0gbnVsbHB0cjsKKyAgICB9Cit9 CisKK3ZvaWQgRHJhd2luZ0FyZWFQcm94eUltcGw6OkRyYXdpbmdNb25pdG9yOjpkaWREcmF3KCkK K3sKKyAgICAvLyBXZSB3YWl0IHVwIHRvIDEgc2Vjb25kIGZvciBkcmF3IGV2ZW50cy4gSWYgdGhl cmUgYXJlIHNldmVyYWwgZHJhdyBldmVudHMgcXVldWVkIHF1aWNrbHksCisgICAgLy8gd2Ugd2Fu dCB0byB3YWl0IHVudGlsIGFsbCBvZiB0aGVtIGhhdmUgYmVlbiBwcm9jZXNzZWQsIHNvIGFmdGVy IHJlY2VpdmluZyBhIGRyYXcsIHdlIHdhaXQKKyAgICAvLyB1cCB0byAxMDBtcyBmb3IgdGhlIG5l eHQgb25lIG9yIHN0b3AuCisgICAgaWYgKG1vbm90b25pY2FsbHlJbmNyZWFzaW5nVGltZU1TKCkg LSBtX3N0YXJ0VGltZSA+IDEwMDApCisgICAgICAgIHN0b3AoKTsKKyAgICBlbHNlCisgICAgICAg IG1fdGltZXIuc3RhcnRPbmVTaG90KDAuMTAwKTsKK30KKwogdm9pZCBEcmF3aW5nQXJlYVByb3h5 SW1wbDo6ZGlzcGF0Y2hBZnRlckVuc3VyaW5nRHJhd2luZyhzdGQ6OmZ1bmN0aW9uPHZvaWQgKENh bGxiYWNrQmFzZTo6RXJyb3IpPiBjYWxsYmFja0Z1bmN0aW9uKQogewogICAgIGlmICghbV93ZWJQ YWdlUHJveHkuaXNWYWxpZCgpKSB7CkBAIC0zMzUsNyArMzkzLDkgQEAgdm9pZCBEcmF3aW5nQXJl YVByb3h5SW1wbDo6ZGlzcGF0Y2hBZnRlckVuc3VyaW5nRHJhd2luZyhzdGQ6OmZ1bmN0aW9uPHZv aWQgKENhbGwKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIFJ1bkxvb3A6Om1haW4oKS5k aXNwYXRjaChbY2FsbGJhY2tGdW5jdGlvbl0geyBjYWxsYmFja0Z1bmN0aW9uKENhbGxiYWNrQmFz ZTo6RXJyb3I6Ok5vbmUpOyB9KTsKKyAgICBpZiAoIW1fZHJhd2luZ01vbml0b3IpCisgICAgICAg IG1fZHJhd2luZ01vbml0b3IgPSBzdGQ6Om1ha2VfdW5pcXVlPERyYXdpbmdBcmVhUHJveHlJbXBs OjpEcmF3aW5nTW9uaXRvcj4obV93ZWJQYWdlUHJveHkpOworICAgIG1fZHJhd2luZ01vbml0b3It PnN0YXJ0KGNhbGxiYWNrRnVuY3Rpb24pOwogfQogCiB2b2lkIERyYXdpbmdBcmVhUHJveHlJbXBs OjpleGl0QWNjZWxlcmF0ZWRDb21wb3NpdGluZ01vZGUoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0RyYXdpbmdBcmVhUHJveHlJbXBsLmggYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvRHJhd2luZ0FyZWFQcm94eUltcGwuaAppbmRleCAxZWQ2ZDAwLi5mMjIwODAzIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvRHJhd2luZ0FyZWFQcm94eUltcGwu aAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvRHJhd2luZ0FyZWFQcm94eUltcGwuaApA QCAtODUsNiArODUsMjYgQEAgcHJpdmF0ZToKICAgICB2b2lkIGRpc2NhcmRCYWNraW5nU3RvcmVT b29uKCk7CiAgICAgdm9pZCBkaXNjYXJkQmFja2luZ1N0b3JlKCk7CiAKKyAgICBjbGFzcyBEcmF3 aW5nTW9uaXRvciB7CisgICAgICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKERyYXdpbmdNb25pdG9y KTsgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CisgICAgcHVibGljOgorICAgICAgICBEcmF3aW5n TW9uaXRvcihXZWJQYWdlUHJveHkmKTsKKyAgICAgICAgfkRyYXdpbmdNb25pdG9yKCk7CisKKyAg ICAgICAgdm9pZCBzdGFydChzdGQ6OmZ1bmN0aW9uPHZvaWQgKENhbGxiYWNrQmFzZTo6RXJyb3Ip Pik7CisKKyAgICBwcml2YXRlOgorICAgICAgICBzdGF0aWMgaW50IHdlYlZpZXdEcmF3Q2FsbGJh Y2soRHJhd2luZ01vbml0b3IqKTsKKworICAgICAgICB2b2lkIHN0b3AoKTsKKyAgICAgICAgdm9p ZCBkaWREcmF3KCk7CisKKyAgICAgICAgV2ViUGFnZVByb3h5JiBtX3dlYlBhZ2U7CisgICAgICAg IGRvdWJsZSBtX3N0YXJ0VGltZSB7IDAgfTsKKyAgICAgICAgc3RkOjpmdW5jdGlvbjx2b2lkIChD YWxsYmFja0Jhc2U6OkVycm9yKT4gbV9jYWxsYmFjazsKKyAgICAgICAgUnVuTG9vcDo6VGltZXI8 RHJhd2luZ01vbml0b3I+IG1fdGltZXI7CisgICAgfTsKKwogICAgIC8vIFRoZSBzdGF0ZSBJRCBj b3JyZXNwb25kaW5nIHRvIG91ciBjdXJyZW50IGJhY2tpbmcgc3RvcmUuIFVwZGF0ZWQgd2hlbmV2 ZXIgd2UgYWxsb2NhdGUKICAgICAvLyBhIG5ldyBiYWNraW5nIHN0b3JlLiBBbnkgbWVzc2FnZXMg cmVjZWl2ZWQgdGhhdCBjb3JyZXNwb25kIHRvIGFuIGVhcmxpZXIgc3RhdGUgYXJlIGlnbm9yZWQs CiAgICAgLy8gYXMgdGhleSBkb24ndCBhcHBseSB0byBvdXIgY3VycmVudCBiYWNraW5nIHN0b3Jl LgpAQCAtMTEyLDYgKzEzMiw4IEBAIHByaXZhdGU6CiAjaWYgVVNFKFRFWFRVUkVfTUFQUEVSKSAm JiBQTEFURk9STShHVEspCiAgICAgdWludDY0X3QgbV9wZW5kaW5nTmF0aXZlU3VyZmFjZUhhbmRs ZUZvckNvbXBvc2l0aW5nIHsgMCB9OwogI2VuZGlmCisKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8RHJh d2luZ01vbml0b3I+IG1fZHJhd2luZ01vbml0b3I7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJL aXQK 285558 2016-08-07 23:09:21 -0700 2016-08-07 23:09:21 -0700 Simplified test case test.html text/html 149 zan PGh0bWw+Cjxib2R5Pgo8ZGl2IHN0eWxlPSJ3aWR0aDogNDAwcHg7IGhlaWdodDogMTYwMHB4Ij48 L2Rpdj4KPGRpdiBzdHlsZT0id2lkdGg6IDQwMHB4OyBoZWlnaHQ6IDIwMHB4OyBiYWNrZ3JvdW5k LWNvbG9yOiByZWQiPC9kaXY+CjwvYm9keT4KPC9odG1sPgo= 286961 2016-08-25 05:51:39 -0700 2016-08-25 07:13:33 -0700 Patch wk2-flaky-scrollbars.diff text/plain 4003 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCAyMGRmOGYwLi4yMDRiMzcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUg QEAKKzIwMTYtMDgtMjUgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtHVEtdW1RocmVhZGVkIENvbXBvc2l0b3JdIFNldmVyYWwgZmxha3kgdGVz dHMgZHVlIHRvIGRpZmZlcmVuY2VzIGluIHNjcm9sbGJhcnMKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MDQ1MAorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBpc3N1ZSBpcyB0aGF0IFRocmVhZGVkQ29t cG9zaXRvcjo6ZGlkQ2hhbmdlVmlzaWJsZVJlY3QoKSBkaXNwYXRjaGVzIHRoZSBzZXRWaXNpYmxl Q29udGVudHNSZWN0KCkgY2FsbCB0aGF0CisgICAgICAgIGVuZHMgdXAgaW4gQ29tcG9zaXRpbmdD b29yZGluYXRvci4gU2luY2Ugd2UncmUgY29tcG9zaXRpbmcgdGhlIHNjcm9sbGJhcnMgYXMgd2Vs bCwgdGhpcyB2aXNpYmxlIGNvbnRlbnRzIHJlY3QKKyAgICAgICAgbmVlZHMgdG8gZW5jb21wYXNz IHRoZSBjb21wbGV0ZSB3aWR0aCBvZiB0aGUgdmlldywgYnV0IHRoYXQncyBub3QgaGFwcGVuaW5n LgorICAgICAgICBJbiBjYXNlIG9mIG5vbi1vdmVybGF5IHNjcm9sbGJhcnMsIHRoZSBzY3JvbGxi YXJzIGFyZSBjbGlwcGVkIGZyb20gdGhpcyByZWN0LCBidXQgdGhhdCBkb2Vzbid0IHByZXZlbnQg dGhlCisgICAgICAgIHNjcm9sbGJhciBvdmVybGF5IGxheWVycyB0byBiZSBmbHVzaGVkIGFuZCBy ZW5kZXJlZC4gV2hhdCBkb2VzIGhhcHBlbiBpcyB0aGF0IGR1cmluZyB0aWxlIGNyZWF0aW9uIGlu IHRoZQorICAgICAgICBiYWNraW5nIHN0b3JlIHRoZSB0aWxlcyB0aGF0IHdvdWxkIG5vcm1hbGx5 IGludGVyc2VjdCB0aGUgdmlzaWJsZSByZWN0IG9mIHRoZSB2aWV3IChpZiBpdCB3ZXJlIHNwYW5u aW5nIG92ZXIgdGhlCisgICAgICAgIHdob2xlIGFjdHVhbCB2aXNpYmxlIGFyZWEpIGFyZSBzb3J0 ZWQgYnkgZGlzdGFuY2UgdG8gdGhlIHZpc2libGUgcmVjdC4KKyAgICAgICAgVGhlIHRvcCBvZiB0 aGUgdHdvIHRpbGVzIHVzZWQgZm9yIHRoZSBzY3JvbGxiYXIgaXMgY2xvc2VyIHRvIHRoZSB2aXNp YmxlIHJlY3QsIHNvIHRoYXQgZ2V0cyBjcmVhdGVkIGFuZCBmaWxsZWQKKyAgICAgICAgaW4gZmly c3QuIFRoZSBzZWNvbmQgdGlsZSBpcyBzdG9yZWQgYXMgcGVuZGluZyBmb3IgY3JlYXRpb24sIGFu ZCBkb2VzIGdldCByZW5kZXJlZCBhdCB0aGUgcG9pbnQgb2YgdGhlIG5leHQKKyAgICAgICAgbGF5 ZXIgZmx1c2guCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvQ29vcmRpbmF0ZWRHcmFw aGljcy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdC5jcHA6CisgICAgICAgIChXZWJL aXQ6OlRocmVhZGVkQ29vcmRpbmF0ZWRMYXllclRyZWVIb3N0OjpzZXRWaXNpYmxlQ29udGVudHNS ZWN0KTogVXBkYXRlIHRoZSB2aXNpYmxlIHJlY3QgdGFraW5nIGludG8gYWNjb3VudAorICAgICAg ICB0aGUgbm9uLW92ZXJsYXkgc2Nyb2xsYmFycyBiZWZvcmUgcGFzc2luZyBpdCB0byB0aGUgY29t cG9zaXRvci4KKwogMjAxNi0wOC0xNiAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGln YWxpYS5jb20+CiAKICAgICAgICAgW0dUS10gQWNjZWxlcmF0ZWQgY29tcG9zaXRpbmcgZG9lcyBu b3Qgd29yayBpbiBXYXlsYW5kCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L1dlYlBhZ2UvQ29vcmRpbmF0ZWRHcmFwaGljcy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVl SG9zdC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvQ29vcmRpbmF0ZWRH cmFwaGljcy9UaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggZWM0NzE5 NC4uOGNlNjg0ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdl L0Nvb3JkaW5hdGVkR3JhcGhpY3MvVGhyZWFkZWRDb29yZGluYXRlZExheWVyVHJlZUhvc3QuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9Db29yZGluYXRlZEdyYXBo aWNzL1RocmVhZGVkQ29vcmRpbmF0ZWRMYXllclRyZWVIb3N0LmNwcApAQCAtMTMzLDEyICsxMzMs MjUgQEAgdm9pZCBUaHJlYWRlZENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdDo6c2V0TmF0aXZlU3Vy ZmFjZUhhbmRsZUZvckNvbXBvc2l0aW5nKHVpbnQKIAogdm9pZCBUaHJlYWRlZENvb3JkaW5hdGVk TGF5ZXJUcmVlSG9zdDo6c2V0VmlzaWJsZUNvbnRlbnRzUmVjdChjb25zdCBGbG9hdFJlY3QmIHJl Y3QsIGNvbnN0IEZsb2F0UG9pbnQmIHRyYWplY3RvcnlWZWN0b3IsIGZsb2F0IHNjYWxlKQogewot ICAgIENvb3JkaW5hdGVkTGF5ZXJUcmVlSG9zdDo6c2V0VmlzaWJsZUNvbnRlbnRzUmVjdChyZWN0 LCB0cmFqZWN0b3J5VmVjdG9yKTsKLSAgICBpZiAobV9sYXN0U2Nyb2xsUG9zaXRpb24gIT0gcm91 bmRlZEludFBvaW50KHJlY3QubG9jYXRpb24oKSkpIHsKLSAgICAgICAgbV9sYXN0U2Nyb2xsUG9z aXRpb24gPSByb3VuZGVkSW50UG9pbnQocmVjdC5sb2NhdGlvbigpKTsKLQotICAgICAgICBpZiAo IW1fd2ViUGFnZS5jb3JlUGFnZSgpLT5tYWluRnJhbWUoKS52aWV3KCktPnVzZUZpeGVkTGF5b3V0 KCkpCi0gICAgICAgICAgICBtX3dlYlBhZ2UuY29yZVBhZ2UoKS0+bWFpbkZyYW1lKCkudmlldygp LT5ub3RpZnlTY3JvbGxQb3NpdGlvbkNoYW5nZWQobV9sYXN0U2Nyb2xsUG9zaXRpb24pOworICAg IEZsb2F0UmVjdCB2aXNpYmxlUmVjdChyZWN0KTsKKworICAgIC8vIFdoZW4gdXNpbmcgbm9uIG92 ZXJsYXkgc2Nyb2xsYmFycywgdGhlIGNvbnRlbnRzIHNpemUgZG9lc24ndCBpbmNsdWRlIHRoZSBz Y3JvbGxiYXJzLCBidXQgd2UgbmVlZCB0byBpbmNsdWRlIHRoZW0KKyAgICAvLyBpbiB0aGUgdmlz aWJsZSBhcmVhIHVzZWQgYnkgdGhlIGNvbXBvc2l0b3IgdG8gZW5zdXJlIHRoYXQgdGhlIHNjcm9s bGJhciBsYXllcnMgYXJlIGFsc28gdXBkYXRlZC4KKyAgICAvLyBTZWUgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2MDQ1MC4KKyAgICBGcmFtZVZpZXcqIHZpZXcgPSBt X3dlYlBhZ2UuY29yZVBhZ2UoKS0+bWFpbkZyYW1lKCkudmlldygpOworICAgIFNjcm9sbGJhciog c2Nyb2xsYmFyID0gdmlldy0+dmVydGljYWxTY3JvbGxiYXIoKTsKKyAgICBpZiAoc2Nyb2xsYmFy ICYmICFzY3JvbGxiYXItPmlzT3ZlcmxheVNjcm9sbGJhcigpKQorICAgICAgICB2aXNpYmxlUmVj dC5leHBhbmQoc2Nyb2xsYmFyLT53aWR0aCgpLCAwKTsKKyAgICBzY3JvbGxiYXIgPSB2aWV3LT5o b3Jpem9udGFsU2Nyb2xsYmFyKCk7CisgICAgaWYgKHNjcm9sbGJhciAmJiAhc2Nyb2xsYmFyLT5p c092ZXJsYXlTY3JvbGxiYXIoKSkKKyAgICAgICAgdmlzaWJsZVJlY3QuZXhwYW5kKDAsIHNjcm9s bGJhci0+aGVpZ2h0KCkpOworCisgICAgQ29vcmRpbmF0ZWRMYXllclRyZWVIb3N0OjpzZXRWaXNp YmxlQ29udGVudHNSZWN0KHZpc2libGVSZWN0LCB0cmFqZWN0b3J5VmVjdG9yKTsKKyAgICBpZiAo bV9sYXN0U2Nyb2xsUG9zaXRpb24gIT0gcm91bmRlZEludFBvaW50KHZpc2libGVSZWN0LmxvY2F0 aW9uKCkpKSB7CisgICAgICAgIG1fbGFzdFNjcm9sbFBvc2l0aW9uID0gcm91bmRlZEludFBvaW50 KHZpc2libGVSZWN0LmxvY2F0aW9uKCkpOworCisgICAgICAgIGlmICghdmlldy0+dXNlRml4ZWRM YXlvdXQoKSkKKyAgICAgICAgICAgIHZpZXctPm5vdGlmeVNjcm9sbFBvc2l0aW9uQ2hhbmdlZCht X2xhc3RTY3JvbGxQb3NpdGlvbik7CiAgICAgfQogCiAgICAgaWYgKG1fbGFzdFNjYWxlRmFjdG9y ICE9IHNjYWxlKSB7Cg==