50331 2010-12-01 09:55:16 -0800 ASSERT failing restoring scroll position from HistoryItem after reload 2023-10-03 10:50:37 -0700 1 1 1 Unclassified WebKit Page Loading 528+ (Nightly build) PC Linux RESOLVED DUPLICATE 252944 https://bugs.webkit.org/show_bug.cgi?id=252944 P2 Normal --- 57906 1 mario webkit-unassigned abarth ahmad.saleem792 beidson creis darin eric fishd jdiggs mike mrobinson ostroffjh oldest_to_newest 315704 0 mario 2010-12-01 09:55:16 -0800 As unveiled by a new unit test in patch for bug 25831 (currently rolled out), there's a situation where the following ASSERT in HistoryController is failing, causing crashes in GTK's debug builds: void HistoryController::restoreScrollPositionAndViewState() { if (!m_frame->loader()->stateMachine()->committedFirstRealDocumentLoad()) return; ASSERT(m_currentItem); [...] } After some investigation it seems that, in the specific scenario caused by bug 25831's patch, the HistoryController is never, ever, updated with a valid 'currentItem', causing this failure when trying to call this function, while finishing the reload of the webview. So, the question is "how could it be possible that we reached this situation?", and I think I found the answer... The situation that triggers this problem is the following code in WebKit/gtk/tests/testatk.c (where 'contents' is a const char* with a hardcoded html code): static void testWebkitAtkDocumentReloadEvents() { WebKitWebView* webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); [...] webkit_web_view_load_string(webView, contents, 0, 0, 0); [...] } As you can see, that code just loads the HTML in the 'contents' variable in the webview. Then, when trying to test the actual issue fixed with that patch, we do: webkit_web_view_reload(webView); ... and that's what's causing the problem, resulting in the following error output: ASSERTION FAILED: m_currentItem (../../WebCore/loader/HistoryController.cpp:103 void WebCore::HistoryController::restoreScrollPositionAndViewState()) After investigating the issue for a long time, diving through a long backtrace, I found the problem seems to be that it's ok not to have a valid m_currentItem in the HistoryController for this case, since the webView is being loaded from a raw char* with the HTML code, instead of fetching the HTML content from a URI (as it would be done with webkit_web_view_load_uri(), in WebKitGTK), hence there's no valid HistoryItem to be stored (no URI!), resulting in the problem explained above. Hence I think the problem could be solved by either removing that ASSERT from HistoryController::restoreScrollPositionAndViewState(), accepting that there are still situations (like this one) where m_currentItem could be 0, or just to try to protect the calls to that function from the callers when needed. So far, I found that the only place that would require such that extra check would be the following one: void FrameLoader::checkLoadCompleteForThisFrame() { [...] switch (m_state) { [...] case FrameStateCommittedPage: { [...] // If the user had a scroll point, scroll to it, overriding the anchor point if any. if (m_frame->page()) { if (isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload || m_loadType == FrameLoadTypeReloadFromOrigin) history()->restoreScrollPositionAndViewState(); } [...] } [...] } I think we could protect this scenario by just doing something like this: // If the user had a scroll point, scroll to it, overriding the anchor point if any. if (m_frame->page() && history()->currentItem()) { if (isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload || m_loadType == FrameLoadTypeReloadFromOrigin) history()->restoreScrollPositionAndViewState(); } I tested this solution and avoids the crash in my debug build of WebKitGTK, while still passing all the tests, but still not sure whether that's the right solution, if it would be better just to remove the ASSERT in HistoryController::restoreScrollPositionAndViewState() or if I'm missing something else, in which case I'd appreaciate any kind of feedback :-) Sorry for the long report, hope at least you'll find this info valuable. 315717 1 75287 mario 2010-12-01 10:22:01 -0800 Created attachment 75287 Patch proposal Attaching patch based on the comments pointed out in the description 315721 2 mario 2010-12-01 10:24:59 -0800 Adding to CC people found through svn blame 316879 3 eric 2010-12-03 10:29:29 -0800 Btw, webkit-patch upload --suggest-reviewers will do the svn blame step for you automatically and then offer to CC relevant reviewers. It's certainly not perfect, but it's often good enough. 316880 4 75287 eric 2010-12-03 10:30:27 -0800 Comment on attachment 75287 Patch proposal View in context: https://bugs.webkit.org/attachment.cgi?id=75287&action=review This needs a test. > WebCore/loader/FrameLoader.cpp:2408 > + // If the user had a scroll point, scroll to it, > + // overriding the anchor point if any. Also, make sure > + // there's a valid current item in the history before > + // trying to scroll because it could happen there was none > + // (e.g. loading from a string instead of an URI). > + if (m_frame->page() && history()->currentItem()) { Seems rather overzealous line wrapping. :) 317560 5 mario 2010-12-06 04:45:45 -0800 Thanks for the review Eric, but I have some doubts that are currently blocking me from providing a better patch. See below... (In reply to comment #4) > (From update of attachment 75287 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=75287&action=review > > This needs a test. Not sure whether you mean a Layout Test (this is my guessing, though) or an unit test. The problem with writing a Layout Test for this is that, as I said, the bug happens when using webkit_web_view_load_string() in an unit test for the GTK port, which basically loads an HTML content from a (const gchar*) instead of loading the content from an URI. And that is (not having an URI) precisely the problem causing this bug, since history->currentItem() will be 0 at the point we're trying to restore the scroll position, right after finishing the reload process. Hence, I don't know how to test this with a layout test, since (1) a layout test has always an URI (the path to the test), so it wouldn't be testing the problem I try to fix, and (2) since the problem was detected from a function of the GTK port. In case you're talking about an unit test (or perhaps you were not, but my paragraphs above has finally convinced you :-)), I do not see any problem on writing an small unit test in the GTK port for that, which would be a ultra-reduced version of testWebkitAtkDocumentReloadEvents() (provided with patch for bug 25831), in case that was fine. So, as you can see, I need some extra input here to continue working on this :-) > > WebCore/loader/FrameLoader.cpp:2408 > > + // If the user had a scroll point, scroll to it, > > + // overriding the anchor point if any. Also, make sure > > + // there's a valid current item in the history before > > + // trying to scroll because it could happen there was none > > + // (e.g. loading from a string instead of an URI). > > + if (m_frame->page() && history()->currentItem()) { > > Seems rather overzealous line wrapping. :) I don't think I deserve credit for this: emacs was the author of such a beautiful piece of art! 317663 6 75704 mario 2010-12-06 09:20:28 -0800 Created attachment 75704 Patch proposal + unit test Attaching a new patch with a new unit test to check everything works as expected when reloading a webView loaded through a gchar*. The unit test is GTK specific, so I guess it's not the perfect solution, but the best one I could find so far since I wasn't able to write a layout test to test this stuff. 320776 7 eric 2010-12-12 02:27:51 -0800 CC'd folks who know more than I do about history. 320987 8 mario 2010-12-13 01:41:39 -0800 (In reply to comment #7) > CC'd folks who know more than I do about history. Thanks! 327123 9 mrobinson 2010-12-27 14:44:33 -0800 This test changes platform-independent WebCore code. Is it possible to write a layout test for all platforms? 327776 10 75704 darin 2010-12-29 18:01:04 -0800 Comment on attachment 75704 Patch proposal + unit test View in context: https://bugs.webkit.org/attachment.cgi?id=75704&action=review Thanks for tackling this. > WebCore/loader/FrameLoader.cpp:2410 > + // If the user had a scroll point, scroll to it, overriding the anchor > + // point if any. Also, make sure there's a valid current item in the > + // history before trying to scroll because it could happen there was > + // none (e.g. loading from a string instead of an URI). > + if (m_frame->page() && history()->currentItem()) { > if (isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload || m_loadType == FrameLoadTypeReloadFromOrigin) > history()->restoreScrollPositionAndViewState(); > } It’s pretty clear looking at this code that the currentItem check belongs inside the restoreScrollPositionAndViewState function, not here at the call site. 328498 11 mario 2011-01-03 02:10:22 -0800 (In reply to comment #9) > This test changes platform-independent WebCore code. Is it possible to write a layout test for all platforms? A I said in comment #6, I wouldn't know how to write a layout test to test this stuff, that's why I'm proposing a GTK-specific unit test instead. On the bright side, it seems this problem affects only to the GTK port, so perhaps it's not a terrible solution either, but you'll have the final word, of course :-) 328562 12 mario 2011-01-03 07:27:45 -0800 Oops! forgot to reply this other comment... (In reply to comment #10) > (From update of attachment 75704 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=75704&action=review > > Thanks for tackling this. > > > WebCore/loader/FrameLoader.cpp:2410 > > + // If the user had a scroll point, scroll to it, overriding the anchor > > + // point if any. Also, make sure there's a valid current item in the > > + // history before trying to scroll because it could happen there was > > + // none (e.g. loading from a string instead of an URI). > > + if (m_frame->page() && history()->currentItem()) { > > if (isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload || m_loadType == FrameLoadTypeReloadFromOrigin) > > history()->restoreScrollPositionAndViewState(); > > } > > It’s pretty clear looking at this code that the currentItem check belongs inside the > restoreScrollPositionAndViewState function, not here at the call site. As I said in the description, I was not sure about that being the right option, although I also considered as a possibility: " [...] Hence I think the problem could be solved by either removing that ASSERT from HistoryController::restoreScrollPositionAndViewState(), accepting that there are still situations (like this one) where m_currentItem could be 0, or just to try to protect the calls to that function from the callers when needed. So far, I found that the only place that would require such that extra check would be the following one [...]" So, I initially proposed adding the extra check in the call site in order not to remove the ASSERT in HistoryController::restoreScrollPositionAndViewState(), which I thought perhaps could be seen as the wrong thing to do. But now you commented on this I'm more for adding the protection inside that function, replacing the ASSERT right there with just a null check to avoid doing anything if currentItem is null. So, expect a new patch in some minutes... Thanks for the feedback! 328599 13 77812 mario 2011-01-03 09:33:35 -0800 Created attachment 77812 Patch proposal + unit test Attaching new patch to be reviewed, this time moving the null check to HistoryController::restoreScrollPositionAndViewState(), that is, removing the ASSERT and explaining the change in a comment :P Also, provided the unit test as in the previous patch 339310 14 jdiggs 2011-01-24 15:37:41 -0800 So the good news is that Orca+Epiphany are shaping up nicely. The bad news is when I follow links and new pages are loaded Orca has no clue and thus presents the no-longer displayed content. :-( If this is the only thing standing in the way of committing the fix for bug 25831, please let me know what bribes are needed to get Mario's patch reviewed and they will be in the mail. :-P (Really sorry to be a noodge. And thanks in advance guys!!) 339552 15 mario 2011-01-25 02:01:57 -0800 (In reply to comment #14) > So the good news is that Orca+Epiphany are shaping up nicely. Great! > The bad news is when I follow links and new pages are loaded Orca has no clue > and thus presents the no-longer displayed content. :-( If this is the only > thing standing in the way of committing the fix for bug 25831, Yes, actually this is the only pending bit blocking the (already reviewed+) patch for 25831 to be applied. > please let me > know what bribes are needed to get Mario's patch reviewed and they will be in > the mail. :-P :-) 339562 16 77812 fishd 2011-01-25 02:53:43 -0800 Comment on attachment 77812 Patch proposal + unit test View in context: https://bugs.webkit.org/attachment.cgi?id=77812&action=review > WebCore/loader/HistoryController.cpp:-104 > - this seems like the wrong direction to go. you have identified a case where we can get a null m_currentItem. perhaps we should instead try to fix that case to not have a null m_currentItem? i think it needlessly complicates HistoryController to have to support a null m_currentItem as we sort of do today. 339579 17 mario 2011-01-25 03:57:48 -0800 (In reply to comment #16) > (From update of attachment 77812 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=77812&action=review > > > WebCore/loader/HistoryController.cpp:-104 > > - > > this seems like the wrong direction to go. you have identified a case > where we can get a null m_currentItem. perhaps we should instead try > to fix that case to not have a null m_currentItem? > > i think it needlessly complicates HistoryController to have to support > a null m_currentItem as we sort of do today. That was my first approach (to avoid getting a null m_currentItem when calling that function), but in comment #10 Darin (well, "the other Darin") pointed out that it would be better to make the change right inside restoreScrollPositionAndViewState(), so I did. Not sure what to do now, perhaps I'm missing something and there's a third way to fix this, but I can't clearly see it at this moment. Any hint? Thanks for the feedback, btw. 339675 18 fishd 2011-01-25 09:14:41 -0800 (In reply to comment #17) > > this seems like the wrong direction to go. you have identified a case > > where we can get a null m_currentItem. perhaps we should instead try > > to fix that case to not have a null m_currentItem? > > > > i think it needlessly complicates HistoryController to have to support > > a null m_currentItem as we sort of do today. > > That was my first approach (to avoid getting a null m_currentItem when calling that function), but in comment #10 Darin (well, "the other Darin") pointed out that it would be better to make the change right inside restoreScrollPositionAndViewState(), so I did. > > Not sure what to do now, perhaps I'm missing something and there's a third way to fix this, but I can't clearly see it at this moment. Yes, I was referring to a different approach. Instead of null checking m_currentItem, I think it would be better to ensure that webkit_web_view_load_string actually creates a HistoryItem. Why doesn't it create one? webkit_web_view_load_string looks a lot like WebKit::WebFrame::loadData() in the Chromium WebKit API. Perhaps you can compare your implementation of webkit_web_view_load_string to that to see how they compare. 340233 19 mario 2011-01-26 06:12:15 -0800 (In reply to comment #18) > [...] > Yes, I was referring to a different approach. Instead of null checking > m_currentItem, I think it would be better to ensure that > webkit_web_view_load_string actually creates a HistoryItem. > Why doesn't it create one? As far as I can see from the code and while debugging, it seems the problem is that such a function ends up calling webkit_web_frame_load_data () with zero in the unreachableURL param, meaning that no history item will be created later on in HistoryController::updateForStandardLoad(), as historyURL.isEmpty() will return true there. I could probably use webkit_web_frame_load_alternate_string() from the unit test to workaround this problem (passing a dummy unreachableURL), but I don't think it's a good approach... still think that if that was the case the last proposed patch would be a better option, since it would be gracefully treating the (very strange) case of calling to restoreScrollPosition() with m_currentItem == 0. But take this with a grain of salt, of course. I know can be wrong again > webkit_web_view_load_string looks a lot like WebKit::WebFrame::loadData() > in the Chromium WebKit API. Perhaps you can compare your implementation > of webkit_web_view_load_string to that to see how they compare. I've spent all the morning debugging the code and deeply analyzing the code behind that function (and comparing it to webkit_web_view_load_string() in the GTK port), and I can't properly understand why that function in Chromium wouldn't be affected by the same problem... actually, hope you don't mind me explicitly asking this but: are you sure the same problem doesn't happen in Chromium? To be sure, it would be wonderful if you could try to reproduce it by: 1. Compile a debug build, so ASSERTS will make WK crash if false. 2. Create a new WebKit view in your test code. 3. Load an static string with HTML content on it through WebKit::WebFrame::loadData(), as you said. 4. Try to reload now. If I'm right, you should be getting a crash as the result of the ASSERT failing in restoreScrollPositionAndViewState(). I of course understand that you could have no time to test this, but I'd appreciate at least some insight on these thoughts, they could be really helpful to me. Thanks! 348051 20 mario 2011-02-09 01:18:09 -0800 Ping? 379975 21 creis 2011-04-05 17:05:33 -0700 I've discovered a way to write a layout test for this bug: w = window.open(); w.document.write(1); w.location.reload(); This code is actually broken in another way (in that it loads the wrong page during reload()), but it does hit the same assert being discussed here. I've filed bug 57906 for the reload bug, and I've uploaded a sample layout test there. 392834 22 77812 abarth 2011-04-26 15:35:53 -0700 Comment on attachment 77812 Patch proposal + unit test There seems to be agreement in the comments that this ASSERT is correct and other code should be changed so that m_currentItem is always non-NULL at this program point. 392966 23 mario 2011-04-26 16:17:24 -0700 (In reply to comment #22) > (From update of attachment 77812 [details]) > There seems to be agreement in the comments that this ASSERT is correct and > other code should be changed so that m_currentItem is always non-NULL at this > program point. Then, unless I'm missing something else, the right approach would be the one proposed in the second patch, right? https://bugs.webkit.org/attachment.cgi?id=75704&action=prettypatch 514693 24 mario 2011-12-04 08:19:24 -0800 (In reply to comment #23) > (In reply to comment #22) > > (From update of attachment 77812 [details] [details]) > > There seems to be agreement in the comments that this ASSERT is correct and > > other code should be changed so that m_currentItem is always non-NULL at this > > program point. > > Then, unless I'm missing something else, the right approach would be the one proposed in the second patch, right? > > https://bugs.webkit.org/attachment.cgi?id=75704&action=prettypatch Sorry about getting back to this again, but I found myself today in the very same situation while writing a new test, and it would be awesome if we could fix this (supposing it's a bug, which is not 100% clear to me at this point). So... ping? :-) 515261 25 77812 darin 2011-12-05 12:02:57 -0800 Comment on attachment 77812 Patch proposal + unit test I still don’t understand why there is no currentItem when we are loading from a string. Fixing that seems like the way to go. If we do agree that instead we want a null pointer check, then we have a battle of the Darins here. The question is what restoreScrollPositionAndViewState should do when there is no history. Should it assert (and then the caller has to check a pointer for null), or check and quietly do nothing when there is nothing to restore. The reason I suggest the latter is that it seems non-obvious that what the caller should null check is currentItem. Having the check inside the function makes more sense to me because it’s in there that it’s clear what to check. 515264 26 darin 2011-12-05 12:04:21 -0800 The reason these patches keep getting review- is that there is no explanation of *why* current item is 0 in the “load from string” case. Once we understand why it’s 0 we can figure out if it’s a bug or not. Nobody wants to just add code to handle 0 without knowing if the 0 is legitimate or not. The debate about whether to put the null check inside the function or outside it is a relatively unimportant sideshow to that question. 560929 27 ostroffjh 2012-02-21 08:56:35 -0800 I'm getting the same error - but in real use, not testing. I'm using webkit-gtk with balsa (email app) under Gentoo. I just did a debug compile of webkit-gtk 1.6.3 to track down a different problem. I don't know if it's balsa or webkit, but when I first display an HTML email, it does not load remote images. As soon as I click on the button to load remote images, I get this crash. Oddly, run under gdb, it is not finding symbols for libwebktigtk, but that may be a Gentoo related issue. I'm mentioning it only in that I won't be able to provide a useful backtrace until I resolve that issue. 1982146 28 ahmad.saleem792 2023-10-03 10:50:37 -0700 *** This bug has been marked as a duplicate of bug 252944 *** 75287 2010-12-01 10:22:01 -0800 2010-12-06 09:20:28 -0800 Patch proposal 0001-2010-12-01-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 2673 mario RnJvbSA3NjI0MDc5OTQ0YjdjYWJhYmM0YjE0YmExMjUxYWJlZTE3MWRiZTQzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBXZWQsIDEgRGVjIDIwMTAgMTk6MTk6MzggKzAxMDAKU3ViamVjdDogW1BBVENI XSAyMDEwLTEyLTAxICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4K CiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAgICAgIEFTU0VSVCBmYWls aW5nIHJlc3RvcmluZyBzY3JvbGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciByZWxv YWQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTAzMzEK CiAgICAgICAgRW5zdXJlIEhpc3RvcnlDb250cm9sbGVyIGNvbnRhaW5zIGEgdmFsaWQgY3VycmVu dEl0ZW0gYmVmb3JlCiAgICAgICAgdHJ5aW5nIHRvIHJlc3RvcmUgc2Nyb2xsIHBvc2l0aW9uIGFm dGVyIGxvYWQgY29tcGxldGlvbi4KCiAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgog ICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6Y2hlY2tMb2FkQ29tcGxldGVGb3JUaGlzRnJh bWUpOiBFeHRyYSBjaGVjay4KLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgfCAg IDEzICsrKysrKysrKysrKysKIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcCB8ICAgIDgg KysrKysrLS0KIDIgZmlsZXMgY2hhbmdlZCwgMTkgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IGU1MGYzNmUuLjg1NDNhZjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTggQEAKIDIwMTAtMTItMDEgIE1hcmlvIFNh bmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgogCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFTU0VSVCBmYWlsaW5nIHJlc3RvcmluZyBzY3Jv bGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciByZWxvYWQKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwMzMxCisKKyAgICAgICAgRW5zdXJl IEhpc3RvcnlDb250cm9sbGVyIGNvbnRhaW5zIGEgdmFsaWQgY3VycmVudEl0ZW0gYmVmb3JlCisg ICAgICAgIHRyeWluZyB0byByZXN0b3JlIHNjcm9sbCBwb3NpdGlvbiBhZnRlciBsb2FkIGNvbXBs ZXRpb24uCisKKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKTogRXh0cmEg Y2hlY2suCisKKzIwMTAtMTItMDEgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2Fs aWEuY29tPgorCiAgICAgICAgIFJldmlld2VkIGJ5IFhhbiBMb3Blei4KIAogICAgICAgICBbR1RL XSBldmVudHMgbWlzc2luZyB3aGVuIGEgZG9jdW1lbnQgaXMgKHJlKWxvYWRlZApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXIuY3BwCmluZGV4IDM1YTQ5MmIuLjdlNmQ4NmEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvbG9h ZGVyL0ZyYW1lTG9hZGVyLmNwcAorKysgYi9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAK QEAgLTI0MDAsOCArMjQwMCwxMiBAQCB2b2lkIEZyYW1lTG9hZGVyOjpjaGVja0xvYWRDb21wbGV0 ZUZvclRoaXNGcmFtZSgpCiAKICAgICAgICAgICAgIG1fY2xpZW50LT5mb3JjZUxheW91dEZvck5v bkhUTUwoKTsKICAgICAgICAgICAgICAKLSAgICAgICAgICAgIC8vIElmIHRoZSB1c2VyIGhhZCBh IHNjcm9sbCBwb2ludCwgc2Nyb2xsIHRvIGl0LCBvdmVycmlkaW5nIHRoZSBhbmNob3IgcG9pbnQg aWYgYW55LgotICAgICAgICAgICAgaWYgKG1fZnJhbWUtPnBhZ2UoKSkgeworICAgICAgICAgICAg Ly8gSWYgdGhlIHVzZXIgaGFkIGEgc2Nyb2xsIHBvaW50LCBzY3JvbGwgdG8gaXQsCisgICAgICAg ICAgICAvLyBvdmVycmlkaW5nIHRoZSBhbmNob3IgcG9pbnQgaWYgYW55LiBBbHNvLCBtYWtlIHN1 cmUKKyAgICAgICAgICAgIC8vIHRoZXJlJ3MgYSB2YWxpZCBjdXJyZW50IGl0ZW0gaW4gdGhlIGhp c3RvcnkgYmVmb3JlCisgICAgICAgICAgICAvLyB0cnlpbmcgdG8gc2Nyb2xsIGJlY2F1c2UgaXQg Y291bGQgaGFwcGVuIHRoZXJlIHdhcyBub25lCisgICAgICAgICAgICAvLyAoZS5nLiBsb2FkaW5n IGZyb20gYSBzdHJpbmcgaW5zdGVhZCBvZiBhbiBVUkkpLgorICAgICAgICAgICAgaWYgKG1fZnJh bWUtPnBhZ2UoKSAmJiBoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCkpIHsKICAgICAgICAgICAgICAg ICBpZiAoaXNCYWNrRm9yd2FyZExvYWRUeXBlKG1fbG9hZFR5cGUpIHx8IG1fbG9hZFR5cGUgPT0g RnJhbWVMb2FkVHlwZVJlbG9hZCB8fCBtX2xvYWRUeXBlID09IEZyYW1lTG9hZFR5cGVSZWxvYWRG cm9tT3JpZ2luKQogICAgICAgICAgICAgICAgICAgICBoaXN0b3J5KCktPnJlc3RvcmVTY3JvbGxQ b3NpdGlvbkFuZFZpZXdTdGF0ZSgpOwogICAgICAgICAgICAgfQotLSAKMS43LjMuMgoK 75704 2010-12-06 09:20:28 -0800 2011-01-03 09:33:35 -0800 Patch proposal + unit test 0001-2010-12-06-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 7151 mario RnJvbSA1YWYzNjczYzI1MzUxOGRjNDI5MzQ1ZDg5ZGQ3ZWJlYjJiODQxNzk3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDYgRGVjIDIwMTAgMTc6NTQ6MDIgKzAxMDAKU3ViamVjdDogW1BBVENI XSAyMDEwLTEyLTA2ICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4K CiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAgICAgIEFTU0VSVCBmYWls aW5nIHJlc3RvcmluZyBzY3JvbGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciByZWxv YWQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTAzMzEK CiAgICAgICAgRW5zdXJlIEhpc3RvcnlDb250cm9sbGVyIGNvbnRhaW5zIGEgdmFsaWQgY3VycmVu dEl0ZW0gYmVmb3JlCiAgICAgICAgdHJ5aW5nIHRvIHJlc3RvcmUgc2Nyb2xsIHBvc2l0aW9uIGFm dGVyIGxvYWQgY29tcGxldGlvbi4KCiAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgog ICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlcjo6Y2hlY2tMb2FkQ29tcGxldGVGb3JUaGlzRnJh bWUpOiBFeHRyYSBjaGVjay4KCjIwMTAtMTItMDYgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2Fu Y2hlekBpZ2FsaWEuY29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAg ICAgICAgQVNTRVJUIGZhaWxpbmcgcmVzdG9yaW5nIHNjcm9sbCBwb3NpdGlvbiBmcm9tIEhpc3Rv cnlJdGVtIGFmdGVyIHJlbG9hZAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD01MDMzMQoKICAgICAgICBOZXcgdGVzdCBjYXNlIHRvIGNoZWNrIHRoYXQgcmVs b2FkIGZyb20gYSBzdHJpbmcgd29ya3MuCgogICAgICAgIFdpdGhvdXQgdGhlIGZpeCBmb3IgdGhp cyBidWcsIHRoZSBmb2xsb3dpbmcgbmV3IHRlc3Qgd291bGQgY3Jhc2gKICAgICAgICBmb3IgZGVi dWcgYnVpbGRzIGJlY2FzZSBvZiBhbiBBU1NFUlQoKSBmYWlsaW5nIGluIHRoZSBtZXRob2QKICAg ICAgICBIaXN0b3J5Q29udHJvbGxlcjo6cmVzdG9yZVNjcm9sbFBvc2l0aW9uQW5kVmlld1N0YXRl KCkuCgogICAgICAgICogdGVzdHMvdGVzdGxvYWRpbmcuYzoKICAgICAgICAocmVsb2FkX3N0YXR1 c19jaGFuZ2VkX2NiKTogVHJhY2sgc3RhdHVzIGNoYW5nZXMgZm9yIHRoZSByZWxvYWQuCiAgICAg ICAgKHdlYlZpZXdSZWxvYWRPbklkbGUpOiBDb25uZWN0IHRvIHRoZSByaWdodCBzaWduYWwgYW5k IHRyaWdnZXIgdGhlCiAgICAgICAgcmVsb2FkIHByb2Nlc3MgZm9yIHRoZSBjdXJyZW50IHdlYlZp ZXcuCiAgICAgICAgKHRlc3RfbG9hZGluZ19yZWxvYWRfZnJvbV9zdHJpbmcpOiBOZXcgdW5pdCB0 ZXN0LgogICAgICAgIChtYWluKTogQWRkIHRoZSBuZXcgdW5pdCB0ZXN0IHRvIHRoZSBsaXN0Lgot LS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICB8ICAgMTMgKysrKysrKysrKwogV2Vi Q29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIHwgICAgNyArKysrLQogV2ViS2l0L2d0ay9DaGFu Z2VMb2cgICAgICAgICAgIHwgICAyMCArKysrKysrKysrKysrKysrCiBXZWJLaXQvZ3RrL3Rlc3Rz L3Rlc3Rsb2FkaW5nLmMgfCAgIDUwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKIDQgZmlsZXMgY2hhbmdlZCwgODggaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4 IDE3MjE1MjYuLjNiZGQ0NGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMTItMDYgIE1hcmlvIFNhbmNo ZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFTU0VSVCBmYWlsaW5nIHJlc3RvcmluZyBzY3JvbGwg cG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciByZWxvYWQKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwMzMxCisKKyAgICAgICAgRW5zdXJlIEhp c3RvcnlDb250cm9sbGVyIGNvbnRhaW5zIGEgdmFsaWQgY3VycmVudEl0ZW0gYmVmb3JlCisgICAg ICAgIHRyeWluZyB0byByZXN0b3JlIHNjcm9sbCBwb3NpdGlvbiBhZnRlciBsb2FkIGNvbXBsZXRp b24uCisKKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKTogRXh0cmEgY2hl Y2suCisKIDIwMTAtMTItMDYgIFNlcmdpbyBWaWxsYXIgU2VuaW4gIDxzdmlsbGFyQGlnYWxpYS5j b20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFydGluIFJvYmluc29uLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2Fk ZXIuY3BwCmluZGV4IDM1YTQ5MmIuLjEwZGE4MGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvbG9hZGVy L0ZyYW1lTG9hZGVyLmNwcAorKysgYi9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAg LTI0MDAsOCArMjQwMCwxMSBAQCB2b2lkIEZyYW1lTG9hZGVyOjpjaGVja0xvYWRDb21wbGV0ZUZv clRoaXNGcmFtZSgpCiAKICAgICAgICAgICAgIG1fY2xpZW50LT5mb3JjZUxheW91dEZvck5vbkhU TUwoKTsKICAgICAgICAgICAgICAKLSAgICAgICAgICAgIC8vIElmIHRoZSB1c2VyIGhhZCBhIHNj cm9sbCBwb2ludCwgc2Nyb2xsIHRvIGl0LCBvdmVycmlkaW5nIHRoZSBhbmNob3IgcG9pbnQgaWYg YW55LgotICAgICAgICAgICAgaWYgKG1fZnJhbWUtPnBhZ2UoKSkgeworICAgICAgICAgICAgLy8g SWYgdGhlIHVzZXIgaGFkIGEgc2Nyb2xsIHBvaW50LCBzY3JvbGwgdG8gaXQsIG92ZXJyaWRpbmcg dGhlIGFuY2hvcgorICAgICAgICAgICAgLy8gcG9pbnQgaWYgYW55LiBBbHNvLCBtYWtlIHN1cmUg dGhlcmUncyBhIHZhbGlkIGN1cnJlbnQgaXRlbSBpbiB0aGUKKyAgICAgICAgICAgIC8vIGhpc3Rv cnkgYmVmb3JlIHRyeWluZyB0byBzY3JvbGwgYmVjYXVzZSBpdCBjb3VsZCBoYXBwZW4gdGhlcmUg d2FzCisgICAgICAgICAgICAvLyBub25lIChlLmcuIGxvYWRpbmcgZnJvbSBhIHN0cmluZyBpbnN0 ZWFkIG9mIGFuIFVSSSkuCisgICAgICAgICAgICBpZiAobV9mcmFtZS0+cGFnZSgpICYmIGhpc3Rv cnkoKS0+Y3VycmVudEl0ZW0oKSkgewogICAgICAgICAgICAgICAgIGlmIChpc0JhY2tGb3J3YXJk TG9hZFR5cGUobV9sb2FkVHlwZSkgfHwgbV9sb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2Fk IHx8IG1fbG9hZFR5cGUgPT0gRnJhbWVMb2FkVHlwZVJlbG9hZEZyb21PcmlnaW4pCiAgICAgICAg ICAgICAgICAgICAgIGhpc3RvcnkoKS0+cmVzdG9yZVNjcm9sbFBvc2l0aW9uQW5kVmlld1N0YXRl KCk7CiAgICAgICAgICAgICB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dl YktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IGFlMDA2MmEuLjc2MWEwNDggMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MjMgQEAKKzIwMTAtMTItMDYgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFT U0VSVCBmYWlsaW5nIHJlc3RvcmluZyBzY3JvbGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBh ZnRlciByZWxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTUwMzMxCisKKyAgICAgICAgTmV3IHRlc3QgY2FzZSB0byBjaGVjayB0aGF0IHJlbG9hZCBm cm9tIGEgc3RyaW5nIHdvcmtzLgorCisgICAgICAgIFdpdGhvdXQgdGhlIGZpeCBmb3IgdGhpcyBi dWcsIHRoZSBmb2xsb3dpbmcgbmV3IHRlc3Qgd291bGQgY3Jhc2gKKyAgICAgICAgZm9yIGRlYnVn IGJ1aWxkcyBiZWNhc2Ugb2YgYW4gQVNTRVJUKCkgZmFpbGluZyBpbiB0aGUgbWV0aG9kCisgICAg ICAgIEhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUo KS4KKworICAgICAgICAqIHRlc3RzL3Rlc3Rsb2FkaW5nLmM6CisgICAgICAgIChyZWxvYWRfc3Rh dHVzX2NoYW5nZWRfY2IpOiBUcmFjayBzdGF0dXMgY2hhbmdlcyBmb3IgdGhlIHJlbG9hZC4KKyAg ICAgICAgKHdlYlZpZXdSZWxvYWRPbklkbGUpOiBDb25uZWN0IHRvIHRoZSByaWdodCBzaWduYWwg YW5kIHRyaWdnZXIgdGhlCisgICAgICAgIHJlbG9hZCBwcm9jZXNzIGZvciB0aGUgY3VycmVudCB3 ZWJWaWV3LgorICAgICAgICAodGVzdF9sb2FkaW5nX3JlbG9hZF9mcm9tX3N0cmluZyk6IE5ldyB1 bml0IHRlc3QuCisgICAgICAgIChtYWluKTogQWRkIHRoZSBuZXcgdW5pdCB0ZXN0IHRvIHRoZSBs aXN0LgorCiAyMDEwLTEyLTA0ICBBbnRvbmlvIEdvbWVzICA8YWdvbWVzQHJpbS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgTWFydGluIFJvYmluc29uLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay90ZXN0cy90ZXN0bG9hZGluZy5jIGIvV2ViS2l0L2d0ay90ZXN0cy90ZXN0bG9hZGluZy5jCmlu ZGV4IGZkOWEwNWMuLmI5MjUxYTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdGxv YWRpbmcuYworKysgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3Rsb2FkaW5nLmMKQEAgLTM5Niw2ICsz OTYsNTEgQEAgc3RhdGljIHZvaWQgdGVzdF9sb2FkaW5nX2dvYmFjayhXZWJMb2FkaW5nRml4dHVy ZSogZml4dHVyZSwgZ2NvbnN0cG9pbnRlciBkYXRhKQogICAgIGdfc2lnbmFsX2hhbmRsZXJzX2Rp c2Nvbm5lY3RfYnlfZnVuYyhmaXh0dXJlLT53ZWJWaWV3LCBsb2FkX3dlbnRiYWNrX3N0YXR1c19j aGFuZ2VkX2NiLCBmaXh0dXJlKTsKIH0KIAorc3RhdGljIHZvaWQgcmVsb2FkX3N0YXR1c19jaGFu Z2VkX2NiKEdPYmplY3QqIG9iamVjdCwgR1BhcmFtU3BlYyogcHNwZWMsIFdlYkxvYWRpbmdGaXh0 dXJlKiBmaXh0dXJlKQoreworICAgIFdlYktpdExvYWRTdGF0dXMgc3RhdHVzID0gd2Via2l0X3dl Yl92aWV3X2dldF9sb2FkX3N0YXR1cyhXRUJLSVRfV0VCX1ZJRVcob2JqZWN0KSk7CisKKyAgICBz d2l0Y2ggKHN0YXR1cykgeworICAgIGNhc2UgV0VCS0lUX0xPQURfUFJPVklTSU9OQUw6CisgICAg ICAgIGdfYXNzZXJ0KCFmaXh0dXJlLT5oYXNfYmVlbl9wcm92aXNpb25hbCk7CisgICAgICAgIGdf YXNzZXJ0KCFmaXh0dXJlLT5oYXNfYmVlbl9jb21taXR0ZWQpOworICAgICAgICBnX2Fzc2VydCgh Zml4dHVyZS0+aGFzX2JlZW5fZmlyc3RfdmlzdWFsbHlfbm9uX2VtcHR5X2xheW91dCk7CisgICAg ICAgIGZpeHR1cmUtPmhhc19iZWVuX3Byb3Zpc2lvbmFsID0gVFJVRTsKKyAgICAgICAgYnJlYWs7 CisgICAgY2FzZSBXRUJLSVRfTE9BRF9DT01NSVRURUQ6CisgICAgICAgIGdfYXNzZXJ0KGZpeHR1 cmUtPmhhc19iZWVuX3Byb3Zpc2lvbmFsKTsKKyAgICAgICAgZ19hc3NlcnQoIWZpeHR1cmUtPmhh c19iZWVuX2NvbW1pdHRlZCk7CisgICAgICAgIGdfYXNzZXJ0KCFmaXh0dXJlLT5oYXNfYmVlbl9m aXJzdF92aXN1YWxseV9ub25fZW1wdHlfbGF5b3V0KTsKKyAgICAgICAgZml4dHVyZS0+aGFzX2Jl ZW5fY29tbWl0dGVkID0gVFJVRTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBXRUJLSVRfTE9B RF9GSU5JU0hFRDoKKyAgICAgICAgZ19hc3NlcnQoZml4dHVyZS0+aGFzX2JlZW5fcHJvdmlzaW9u YWwpOworICAgICAgICBnX2Fzc2VydChmaXh0dXJlLT5oYXNfYmVlbl9jb21taXR0ZWQpOworICAg ICAgICBnX21haW5fbG9vcF9xdWl0KGZpeHR1cmUtPmxvb3ApOworICAgICAgICBicmVhazsKKyAg ICBkZWZhdWx0OgorICAgICAgICBnX2Fzc2VydF9ub3RfcmVhY2hlZCgpOworICAgIH0KK30KKwor c3RhdGljIGdib29sZWFuIHdlYlZpZXdSZWxvYWRPbklkbGUoV2ViTG9hZGluZ0ZpeHR1cmUqIGZp eHR1cmUpCit7CisgICAgZ19vYmplY3RfY29ubmVjdChHX09CSkVDVChmaXh0dXJlLT53ZWJWaWV3 KSwKKyAgICAgICAgICAgICAgICAgICAgICJzaWduYWw6Om5vdGlmeTo6bG9hZC1zdGF0dXMiLCBH X0NBTExCQUNLKHJlbG9hZF9zdGF0dXNfY2hhbmdlZF9jYiksIGZpeHR1cmUsCisgICAgICAgICAg ICAgICAgICAgICBOVUxMKTsKKworICAgIHdlYmtpdF93ZWJfdmlld19yZWxvYWQoZml4dHVyZS0+ d2ViVmlldyk7CisgICAgcmV0dXJuIEZBTFNFOworfQorCitzdGF0aWMgdm9pZCB0ZXN0X2xvYWRp bmdfcmVsb2FkX2Zyb21fc3RyaW5nKFdlYkxvYWRpbmdGaXh0dXJlKiBmaXh0dXJlLCBnY29uc3Rw b2ludGVyIGRhdGEpCit7CisgICAgd2Via2l0X3dlYl92aWV3X2xvYWRfaHRtbF9zdHJpbmcoZml4 dHVyZS0+d2ViVmlldywgSFRNTF9TVFJJTkcsIDApOworICAgIGdfaWRsZV9hZGQoKEdTb3VyY2VG dW5jKXdlYlZpZXdSZWxvYWRPbklkbGUsIGZpeHR1cmUpOworCisgICAgZ19tYWluX2xvb3BfcnVu KGZpeHR1cmUtPmxvb3ApOworfQorCiBpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCiB7 CiAgICAgU291cFNlcnZlciogc2VydmVyOwpAQCAtNDMyLDYgKzQ3NywxMSBAQCBpbnQgbWFpbihp bnQgYXJnYywgY2hhcioqIGFyZ3YpCiAgICAgICAgICAgICAgICB3ZWJfbG9hZGluZ19maXh0dXJl X3NldHVwLAogICAgICAgICAgICAgICAgdGVzdF9sb2FkaW5nX2dvYmFjaywKICAgICAgICAgICAg ICAgIHdlYl9sb2FkaW5nX2ZpeHR1cmVfdGVhcmRvd24pOworICAgIGdfdGVzdF9hZGQoIi93ZWJr aXQvbG9hZGluZy9yZWxvYWRmcm9tc3RyaW5nIiwKKyAgICAgICAgICAgICAgIFdlYkxvYWRpbmdG aXh0dXJlLCBOVUxMLAorICAgICAgICAgICAgICAgd2ViX2xvYWRpbmdfZml4dHVyZV9zZXR1cCwK KyAgICAgICAgICAgICAgIHRlc3RfbG9hZGluZ19yZWxvYWRfZnJvbV9zdHJpbmcsCisgICAgICAg ICAgICAgICB3ZWJfbG9hZGluZ19maXh0dXJlX3RlYXJkb3duKTsKICAgICByZXR1cm4gZ190ZXN0 X3J1bigpOwogfQogCi0tIAoxLjcuMy4yCgo= 77812 2011-01-03 09:33:35 -0800 2011-12-05 12:02:57 -0800 Patch proposal + unit test 0001-2011-01-03-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 7683 mario RnJvbSBmNmVkZWVlYWE0MTYxMDE3YzUwZGRhNmI4NmNiZDU3ODU2YWQ2NjE5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDMgSmFuIDIwMTEgMTY6Mjk6MDUgKzAxMDAKU3ViamVjdDogW1BBVENI XSAyMDExLTAxLTAzICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4K CiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAgICAgIEFTU0VSVCBmYWls aW5nIHJlc3RvcmluZyBzY3JvbGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciByZWxv YWQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTAzMzEK CiAgICAgICAgUmVtb3ZlZCBBU1NFUlQgbm90IHRvIGZhaWwgZm9yIGRlYnVnIGJ1aWxkcyBpZiAh bV9jdXJyZW50SXRlbS4KCiAgICAgICAgU3RpbGwsIHRoZSBjb2RlIGtlZXBzIGJlaW5nIHNhZmUg YWdhaW5zdCB0aGUgY2FzZSB3aGVyZQogICAgICAgIG1fY3VycmVudEl0ZW0gaXMgemVybywgc2lu Y2UgYSBzaW1wbGUgbnVsbCBjaGVjayBpcyBzdGlsbCBpbgogICAgICAgIHBsYWNlLCBlYXJseSBy ZXR1cm5pbmcgZnJvbSB0aGUgZnVuY3Rpb24gaW4gdGhvc2UgY2FzZXMuCgogICAgICAgICogbG9h ZGVyL0ZyYW1lTG9hZGVyLmNwcDoKICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OmNoZWNr TG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKToKICAgICAgICAqIGxvYWRlci9IaXN0b3J5Q29udHJv bGxlci5jcHA6CiAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Ny b2xsUG9zaXRpb25BbmRWaWV3U3RhdGUpOgoKMjAxMS0wMS0wMyAgTWFyaW8gU2FuY2hleiBQcmFk YSAgPG1zYW5jaGV6QGlnYWxpYS5jb20+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgoKICAgICAgICBBU1NFUlQgZmFpbGluZyByZXN0b3Jpbmcgc2Nyb2xsIHBvc2l0aW9uIGZy b20gSGlzdG9yeUl0ZW0gYWZ0ZXIgcmVsb2FkCiAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTUwMzMxCgogICAgICAgIE5ldyB0ZXN0IGNhc2UgdG8gY2hlY2sg dGhhdCByZWxvYWQgZnJvbSBhIHN0cmluZyB3b3Jrcy4KCiAgICAgICAgV2l0aG91dCB0aGUgZml4 IGZvciB0aGlzIGJ1ZywgdGhlIGZvbGxvd2luZyBuZXcgdGVzdCB3b3VsZCBjcmFzaAogICAgICAg IGZvciBkZWJ1ZyBidWlsZHMgYmVjYXNlIG9mIGFuIEFTU0VSVCgpIGZhaWxpbmcgaW4gdGhlIG1l dGhvZAogICAgICAgIEhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRW aWV3U3RhdGUoKS4KCiAgICAgICAgKiB0ZXN0cy90ZXN0bG9hZGluZy5jOgogICAgICAgIChyZWxv YWRfc3RhdHVzX2NoYW5nZWRfY2IpOiBUcmFjayBzdGF0dXMgY2hhbmdlcyBmb3IgdGhlIHJlbG9h ZC4KICAgICAgICAod2ViVmlld1JlbG9hZE9uSWRsZSk6IENvbm5lY3QgdG8gdGhlIHJpZ2h0IHNp Z25hbCBhbmQgdHJpZ2dlciB0aGUKICAgICAgICByZWxvYWQgcHJvY2VzcyBmb3IgdGhlIGN1cnJl bnQgd2ViVmlldy4KICAgICAgICAodGVzdF9sb2FkaW5nX3JlbG9hZF9mcm9tX3N0cmluZyk6IE5l dyB1bml0IHRlc3QuCiAgICAgICAgKG1haW4pOiBBZGQgdGhlIG5ldyB1bml0IHRlc3QgdG8gdGhl IGxpc3QuCi0tLQogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgIHwgICAxOCAr KysrKysrKysrKysKIFdlYkNvcmUvbG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNwcCB8ICAgIDYg KystLQogV2ViS2l0L2d0ay9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgIHwgICAyMCArKysrKysr KysrKysrCiBXZWJLaXQvZ3RrL3Rlc3RzL3Rlc3Rsb2FkaW5nLmMgICAgICAgfCAgIDUwICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgOTEgaW5zZXJ0 aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBi L1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDFlMWVkNTguLmZmNDlmOTEgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAK KzIwMTEtMDEtMDMgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFTU0VSVCBm YWlsaW5nIHJlc3RvcmluZyBzY3JvbGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciBy ZWxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUw MzMxCisKKyAgICAgICAgUmVtb3ZlZCBBU1NFUlQgbm90IHRvIGZhaWwgZm9yIGRlYnVnIGJ1aWxk cyBpZiAhbV9jdXJyZW50SXRlbS4KKworICAgICAgICBTdGlsbCwgdGhlIGNvZGUga2VlcHMgYmVp bmcgc2FmZSBhZ2FpbnN0IHRoZSBjYXNlIHdoZXJlCisgICAgICAgIG1fY3VycmVudEl0ZW0gaXMg emVybywgc2luY2UgYSBzaW1wbGUgbnVsbCBjaGVjayBpcyBzdGlsbCBpbgorICAgICAgICBwbGFj ZSwgZWFybHkgcmV0dXJuaW5nIGZyb20gdGhlIGZ1bmN0aW9uIGluIHRob3NlIGNhc2VzLgorCisg ICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1l TG9hZGVyOjpjaGVja0xvYWRDb21wbGV0ZUZvclRoaXNGcmFtZSk6CisgICAgICAgICogbG9hZGVy L0hpc3RvcnlDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9s bGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUpOgorCiAyMDExLTAxLTAyICBE YW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQg YnkgU2ltb24gRnJhc2VyLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9sb2FkZXIvSGlzdG9yeUNvbnRy b2xsZXIuY3BwIGIvV2ViQ29yZS9sb2FkZXIvSGlzdG9yeUNvbnRyb2xsZXIuY3BwCmluZGV4IGZm NzMzYTkuLjNkMTM2MGQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvbG9hZGVyL0hpc3RvcnlDb250cm9s bGVyLmNwcAorKysgYi9XZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5jcHAKQEAgLTEw MCwxMyArMTAwLDEzIEBAIHZvaWQgSGlzdG9yeUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3Np dGlvbkFuZFZpZXdTdGF0ZSgpCiAgICAgaWYgKCFtX2ZyYW1lLT5sb2FkZXIoKS0+c3RhdGVNYWNo aW5lKCktPmNvbW1pdHRlZEZpcnN0UmVhbERvY3VtZW50TG9hZCgpKQogICAgICAgICByZXR1cm47 CiAKLSAgICBBU1NFUlQobV9jdXJyZW50SXRlbSk7Ci0gICAgCi0gICAgLy8gRklYTUU6IEFzIHRo ZSBBU1NFUlQgYXR0ZXN0cywgaXQgc2VlbXMgd2Ugc2hvdWxkIGFsd2F5cyBoYXZlIGEgY3VycmVu dEl0ZW0gaGVyZS4KKyAgICAvLyBGSVhNRTogSXQgc2VlbXMgd2Ugc2hvdWxkIGFsd2F5cyBoYXZl IGEgY3VycmVudEl0ZW0gaGVyZS4KICAgICAvLyBPbmUgY291bnRlcmV4YW1wbGUgaXMgPHJkYXI6 Ly9wcm9ibGVtLzQ5MTcyOTA+CiAgICAgLy8gRm9yIG5vdywgdG8gY292ZXIgdGhpcyBpc3N1ZSBp biByZWxlYXNlIGJ1aWxkcywgdGhlcmUgaXMgbm8gdGVjaG5pY2FsIGhhcm0gdG8gcmV0dXJuaW5n CiAgICAgLy8gZWFybHkgYW5kIGZyb20gYSB1c2VyIHN0YW5kcG9pbnQgLSBhcyBpbiB0aGUgYWJv dmUgcmFkYXIgLSB0aGUgcHJldmlvdXMgcGFnZSBsb2FkIGZhaWxlZCAKICAgICAvLyBzbyB0aGVy ZSAqaXMqIG5vIHNjcm9sbCBvciB2aWV3IHN0YXRlIHRvIHJlc3RvcmUhCisgICAgLy8gSW4gdGhl IHBhc3QsIHRoZXJlIHdhcyBhbiBBU1NFUlQgaGVyZSB0aGF0IHdvdWxkIGZhaWwgaW4gdGhvc2Ug Y291bnRlcmV4YW1wbGVzIGZvciBkZWJ1ZworICAgIC8vIGJ1aWxkcywgYnV0IHdhcyByZW1vdmVk IGR1ZSB0byBXZWJLaXQgYnVnIDUwMzMxLCByZWx5aW5nIG9uIHRoZSBzaW1wbGUgY2hlY2sgYmVs b3cuCiAgICAgaWYgKCFtX2N1cnJlbnRJdGVtKQogICAgICAgICByZXR1cm47CiAgICAgCmRpZmYg LS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4 IDBkN2Y1YjEuLjMwMzUzZTQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBi L1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTEtMDEtMDMgIE1hcmlv IFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFTU0VSVCBmYWlsaW5nIHJlc3RvcmluZyBz Y3JvbGwgcG9zaXRpb24gZnJvbSBIaXN0b3J5SXRlbSBhZnRlciByZWxvYWQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTUwMzMxCisKKyAgICAgICAgTmV3 IHRlc3QgY2FzZSB0byBjaGVjayB0aGF0IHJlbG9hZCBmcm9tIGEgc3RyaW5nIHdvcmtzLgorCisg ICAgICAgIFdpdGhvdXQgdGhlIGZpeCBmb3IgdGhpcyBidWcsIHRoZSBmb2xsb3dpbmcgbmV3IHRl c3Qgd291bGQgY3Jhc2gKKyAgICAgICAgZm9yIGRlYnVnIGJ1aWxkcyBiZWNhc2Ugb2YgYW4gQVNT RVJUKCkgZmFpbGluZyBpbiB0aGUgbWV0aG9kCisgICAgICAgIEhpc3RvcnlDb250cm9sbGVyOjpy ZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUoKS4KKworICAgICAgICAqIHRlc3RzL3Rl c3Rsb2FkaW5nLmM6CisgICAgICAgIChyZWxvYWRfc3RhdHVzX2NoYW5nZWRfY2IpOiBUcmFjayBz dGF0dXMgY2hhbmdlcyBmb3IgdGhlIHJlbG9hZC4KKyAgICAgICAgKHdlYlZpZXdSZWxvYWRPbklk bGUpOiBDb25uZWN0IHRvIHRoZSByaWdodCBzaWduYWwgYW5kIHRyaWdnZXIgdGhlCisgICAgICAg IHJlbG9hZCBwcm9jZXNzIGZvciB0aGUgY3VycmVudCB3ZWJWaWV3LgorICAgICAgICAodGVzdF9s b2FkaW5nX3JlbG9hZF9mcm9tX3N0cmluZyk6IE5ldyB1bml0IHRlc3QuCisgICAgICAgIChtYWlu KTogQWRkIHRoZSBuZXcgdW5pdCB0ZXN0IHRvIHRoZSBsaXN0LgorCiAyMDExLTAxLTAyICBYYW4g TG9wZXogIDx4bG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBGaXggR1RLKyBidWlsZC4KZGlm ZiAtLWdpdCBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdGxvYWRpbmcuYyBiL1dlYktpdC9ndGsvdGVz dHMvdGVzdGxvYWRpbmcuYwppbmRleCBhMGVjOGM5Li40MGU0ZTlkIDEwMDY0NAotLS0gYS9XZWJL aXQvZ3RrL3Rlc3RzL3Rlc3Rsb2FkaW5nLmMKKysrIGIvV2ViS2l0L2d0ay90ZXN0cy90ZXN0bG9h ZGluZy5jCkBAIC0zOTYsNiArMzk2LDUxIEBAIHN0YXRpYyB2b2lkIHRlc3RfbG9hZGluZ19nb2Jh Y2soV2ViTG9hZGluZ0ZpeHR1cmUqIGZpeHR1cmUsIGdjb25zdHBvaW50ZXIgZGF0YSkKICAgICBn X3NpZ25hbF9oYW5kbGVyc19kaXNjb25uZWN0X2J5X2Z1bmMoZml4dHVyZS0+d2ViVmlldywgbG9h ZF93ZW50YmFja19zdGF0dXNfY2hhbmdlZF9jYiwgZml4dHVyZSk7CiB9CiAKK3N0YXRpYyB2b2lk IHJlbG9hZF9zdGF0dXNfY2hhbmdlZF9jYihHT2JqZWN0KiBvYmplY3QsIEdQYXJhbVNwZWMqIHBz cGVjLCBXZWJMb2FkaW5nRml4dHVyZSogZml4dHVyZSkKK3sKKyAgICBXZWJLaXRMb2FkU3RhdHVz IHN0YXR1cyA9IHdlYmtpdF93ZWJfdmlld19nZXRfbG9hZF9zdGF0dXMoV0VCS0lUX1dFQl9WSUVX KG9iamVjdCkpOworCisgICAgc3dpdGNoIChzdGF0dXMpIHsKKyAgICBjYXNlIFdFQktJVF9MT0FE X1BST1ZJU0lPTkFMOgorICAgICAgICBnX2Fzc2VydCghZml4dHVyZS0+aGFzX2JlZW5fcHJvdmlz aW9uYWwpOworICAgICAgICBnX2Fzc2VydCghZml4dHVyZS0+aGFzX2JlZW5fY29tbWl0dGVkKTsK KyAgICAgICAgZ19hc3NlcnQoIWZpeHR1cmUtPmhhc19iZWVuX2ZpcnN0X3Zpc3VhbGx5X25vbl9l bXB0eV9sYXlvdXQpOworICAgICAgICBmaXh0dXJlLT5oYXNfYmVlbl9wcm92aXNpb25hbCA9IFRS VUU7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgV0VCS0lUX0xPQURfQ09NTUlUVEVEOgorICAg ICAgICBnX2Fzc2VydChmaXh0dXJlLT5oYXNfYmVlbl9wcm92aXNpb25hbCk7CisgICAgICAgIGdf YXNzZXJ0KCFmaXh0dXJlLT5oYXNfYmVlbl9jb21taXR0ZWQpOworICAgICAgICBnX2Fzc2VydCgh Zml4dHVyZS0+aGFzX2JlZW5fZmlyc3RfdmlzdWFsbHlfbm9uX2VtcHR5X2xheW91dCk7CisgICAg ICAgIGZpeHR1cmUtPmhhc19iZWVuX2NvbW1pdHRlZCA9IFRSVUU7CisgICAgICAgIGJyZWFrOwor ICAgIGNhc2UgV0VCS0lUX0xPQURfRklOSVNIRUQ6CisgICAgICAgIGdfYXNzZXJ0KGZpeHR1cmUt Pmhhc19iZWVuX3Byb3Zpc2lvbmFsKTsKKyAgICAgICAgZ19hc3NlcnQoZml4dHVyZS0+aGFzX2Jl ZW5fY29tbWl0dGVkKTsKKyAgICAgICAgZ19tYWluX2xvb3BfcXVpdChmaXh0dXJlLT5sb29wKTsK KyAgICAgICAgYnJlYWs7CisgICAgZGVmYXVsdDoKKyAgICAgICAgZ19hc3NlcnRfbm90X3JlYWNo ZWQoKTsKKyAgICB9Cit9CisKK3N0YXRpYyBnYm9vbGVhbiB3ZWJWaWV3UmVsb2FkT25JZGxlKFdl YkxvYWRpbmdGaXh0dXJlKiBmaXh0dXJlKQoreworICAgIGdfb2JqZWN0X2Nvbm5lY3QoR19PQkpF Q1QoZml4dHVyZS0+d2ViVmlldyksCisgICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjpub3Rp Znk6OmxvYWQtc3RhdHVzIiwgR19DQUxMQkFDSyhyZWxvYWRfc3RhdHVzX2NoYW5nZWRfY2IpLCBm aXh0dXJlLAorICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CisKKyAgICB3ZWJraXRfd2ViX3Zp ZXdfcmVsb2FkKGZpeHR1cmUtPndlYlZpZXcpOworICAgIHJldHVybiBGQUxTRTsKK30KKworc3Rh dGljIHZvaWQgdGVzdF9sb2FkaW5nX3JlbG9hZF9mcm9tX3N0cmluZyhXZWJMb2FkaW5nRml4dHVy ZSogZml4dHVyZSwgZ2NvbnN0cG9pbnRlciBkYXRhKQoreworICAgIHdlYmtpdF93ZWJfdmlld19s b2FkX2h0bWxfc3RyaW5nKGZpeHR1cmUtPndlYlZpZXcsIEhUTUxfU1RSSU5HLCAwKTsKKyAgICBn X2lkbGVfYWRkKChHU291cmNlRnVuYyl3ZWJWaWV3UmVsb2FkT25JZGxlLCBmaXh0dXJlKTsKKwor ICAgIGdfbWFpbl9sb29wX3J1bihmaXh0dXJlLT5sb29wKTsKK30KKwogaW50IG1haW4oaW50IGFy Z2MsIGNoYXIqKiBhcmd2KQogewogICAgIFNvdXBTZXJ2ZXIqIHNlcnZlcjsKQEAgLTQzMiw2ICs0 NzcsMTEgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KQogICAgICAgICAgICAgICAg d2ViX2xvYWRpbmdfZml4dHVyZV9zZXR1cCwKICAgICAgICAgICAgICAgIHRlc3RfbG9hZGluZ19n b2JhY2ssCiAgICAgICAgICAgICAgICB3ZWJfbG9hZGluZ19maXh0dXJlX3RlYXJkb3duKTsKKyAg ICBnX3Rlc3RfYWRkKCIvd2Via2l0L2xvYWRpbmcvcmVsb2FkZnJvbXN0cmluZyIsCisgICAgICAg ICAgICAgICBXZWJMb2FkaW5nRml4dHVyZSwgTlVMTCwKKyAgICAgICAgICAgICAgIHdlYl9sb2Fk aW5nX2ZpeHR1cmVfc2V0dXAsCisgICAgICAgICAgICAgICB0ZXN0X2xvYWRpbmdfcmVsb2FkX2Zy b21fc3RyaW5nLAorICAgICAgICAgICAgICAgd2ViX2xvYWRpbmdfZml4dHVyZV90ZWFyZG93bik7 CiAgICAgcmV0dXJuIGdfdGVzdF9ydW4oKTsKIH0KIAotLSAKMS43LjMuNAoK