49018 2010-11-04 12:58:21 -0700 [GTK] response.isNull() assert when using directory file URI 2010-11-24 12:03:01 -0800 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 0 nicolas webkit-unassigned commit-queue mrobinson svillar webkit.review.bot oldest_to_newest 304812 0 nicolas 2010-11-04 12:58:21 -0700 When using file:/// (or any directory) we get an assertion. This is due to Soup backend not sending a proper response prior to the first data chunk. Patch coming. 304819 1 72974 nicolas 2010-11-04 13:05:39 -0700 Created attachment 72974 Fix assert using directory file URI 304820 2 webkit.review.bot 2010-11-04 13:08:01 -0700 Attachment 72974 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--diff-files', u'WebCore/ChangeLog', u'WebCore/platform/network/soup/ResourceHandleSoup.cpp']" exit_code: 1 WebCore/ChangeLog:11: Line contains tab character. [whitespace/tab] [5] WebCore/ChangeLog:12: Line contains tab character. [whitespace/tab] [5] Total errors found: 2 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 304833 3 72976 nicolas 2010-11-04 13:34:57 -0700 Created attachment 72976 Fix assert using directory file URI Fixed tabs instead of space in ChangeLog 304836 4 webkit.review.bot 2010-11-04 13:39:05 -0700 Attachment 72976 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--diff-files', u'WebCore/ChangeLog', u'WebCore/platform/network/soup/ResourceHandleSoup.cpp']" exit_code: 1 WebCore/ChangeLog:11: Line contains tab character. [whitespace/tab] [5] WebCore/ChangeLog:12: Line contains tab character. [whitespace/tab] [5] Total errors found: 2 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 304843 5 72978 nicolas 2010-11-04 13:44:23 -0700 Created attachment 72978 Fix assert using directory file URI Sorry for the noise, small manipulation error here. This is the version without tabs. 306211 6 svillar 2010-11-08 10:49:06 -0800 Nice catch!. Some comments to your patch > WebCore/platform/network/soup/ResourceHandleSoup.cpp:-694 > - if (equalIgnoringCase(protocol, "http") || equalIgnoringCase(protocol, "https")) { Although not directly related to the bug I think you can indeed include style fixes. > WebCore/platform/network/soup/ResourceHandleSoup.cpp:-699 > - if (equalIgnoringCase(protocol, "file") || equalIgnoringCase(protocol, "ftp") || equalIgnoringCase(protocol, "ftps")) { If I am not wrong, this has nothing to do with the bug so, I guess you either should attach another patch or maybe a different bug, Martin? > WebCore/platform/network/soup/ResourceHandleSoup.cpp:793 > GOwnPtr<GError> error; You're indeed right, we're not notifying about the didReceiveResponse for directories but: 1) why don't you just remove the condition in line 534 then?, and 2) in order to keep the consistency of the new design for ResourceHandleSoup, the didReceiveResponse should be called before any read, so it's better to keep the check in sendRequestCallback. 306304 7 nicolas 2010-11-08 13:01:11 -0800 (In reply to comment #6) > Nice catch!. Some comments to your patch > > > WebCore/platform/network/soup/ResourceHandleSoup.cpp:-694 > > - if (equalIgnoringCase(protocol, "http") || equalIgnoringCase(protocol, "https")) { > > Although not directly related to the bug I think you can indeed include style fixes. Ok, but I'll be careful next time, didn't notice I did that. > > > WebCore/platform/network/soup/ResourceHandleSoup.cpp:-699 > > - if (equalIgnoringCase(protocol, "file") || equalIgnoringCase(protocol, "ftp") || equalIgnoringCase(protocol, "ftps")) { > > If I am not wrong, this has nothing to do with the bug so, I guess you either should attach another patch or maybe a different bug, Martin? I'll let Martin reply, normally I would split this up in a git branch, but WebKit process with ChangeLog is such a *** that I prefer keep related one liner together. > > > WebCore/platform/network/soup/ResourceHandleSoup.cpp:793 > > GOwnPtr<GError> error; > > You're indeed right, we're not notifying about the didReceiveResponse for directories but: > > 1) why don't you just remove the condition in line 534 then?, and That would mean calling didReceiveResponse multiple time in the case of HTTP. Also there was discussion about Soup future where FTP would fire callbacks that triggers didReceiveResponse too, and potentially other protocols. Checking if a response was send right before passing the first buffer seems to be the most generic solution at the moment. > 2) in order to keep the consistency of the new design for ResourceHandleSoup, the didReceiveResponse should be called before any read, so it's better to keep the check in sendRequestCallback. That's pretty much explained in 1), but one addition is that currently didReceiveResponse() is called during the first read and not before. 306307 8 nicolas 2010-11-08 13:02:32 -0800 Martin, there was questions for you in previous comments, so adding you in CC. 306322 9 mrobinson 2010-11-08 13:18:46 -0800 (In reply to comment #7) > > > WebCore/platform/network/soup/ResourceHandleSoup.cpp:-699 > > > - if (equalIgnoringCase(protocol, "file") || equalIgnoringCase(protocol, "ftp") || equalIgnoringCase(protocol, "ftps")) { > > > > If I am not wrong, this has nothing to do with the bug so, I guess you either should attach another patch or maybe a different bug, Martin? > > I'll let Martin reply, normally I would split this up in a git branch, but WebKit process with ChangeLog is such a *** that I prefer keep related one liner together. Unrelated bug fixes should be in separate bugs and patches. Additionally, each patch should, if possible, include tests for that change (and especially changes in WebCore). In some cases there is no sane way to test a change, this should probably be outlined in the ChangeLog. The webkit-patch tool makes working with ChangeLogs and patches a lot easier. Definitely look into that. 306477 10 73309 nicolas 2010-11-08 17:03:50 -0800 Created attachment 73309 Fix assert using directory file URI - Added unit test - Removed unrelated style fix - Removed unrelated non-working FTP shceme filtering 306498 11 73316 nicolas 2010-11-08 17:20:44 -0800 Created attachment 73316 Fix assert using directory file URI The style check script consider as garbage an empty file, so why not put some information about the directory with keep-empty file. Hopefully this won't be considered garbage. 306645 12 svillar 2010-11-09 00:39:07 -0800 (In reply to comment #7) > (In reply to comment #6) > > You're indeed right, we're not notifying about the didReceiveResponse for directories but: > > > > 1) why don't you just remove the condition in line 534 then?, and > > That would mean calling didReceiveResponse multiple time in the case of HTTP. Also there was discussion about Soup future where FTP would fire callbacks that triggers didReceiveResponse too, and potentially other protocols. Checking if a response was send right before passing the first buffer seems to be the most generic solution at the moment. Maybe I'm missing something but that did receive response is only called for "file:" URIs. HTTP requests don't match that condition. 306736 13 nicolas 2010-11-09 05:32:00 -0800 (In reply to comment #12) > > That would mean calling didReceiveResponse multiple time in the case of HTTP. Also there was discussion about Soup future where FTP would fire callbacks that triggers didReceiveResponse too, and potentially other protocols. Checking if a response was send right before passing the first buffer seems to be the most generic solution at the moment. > > Maybe I'm missing something but that did receive response is only called for "file:" URIs. HTTP requests don't match that condition. client->didReceiveResponse() is called in signals fired between the notification for the request being sent and the first data buffer (see gotHeadersCallback(), contentSniffedCallback()). client->didReceiveResponse() is also the only way to set a response and MUST be called before didReceiveData(). I'm trying to guaranty that this will always happen and will not happend twice. This way, if someone add support for protocols with proper response (ftp, gopher, etc.) we can just concentrate on the soup backend and know that the binding is ready for it (aside the file/ftp/ftps filter that could be removed when the GIO backend is fixed). 306804 14 svillar 2010-11-09 08:28:07 -0800 (In reply to comment #13) > (In reply to comment #12) > > > That would mean calling didReceiveResponse multiple time in the case of HTTP. Also there was discussion about Soup future where FTP would fire callbacks that triggers didReceiveResponse too, and potentially other protocols. Checking if a response was send right before passing the first buffer seems to be the most generic solution at the moment. > > > > Maybe I'm missing something but that did receive response is only called for "file:" URIs. HTTP requests don't match that condition. > > client->didReceiveResponse() is called in signals fired between the notification for the request being sent and the first data buffer (see gotHeadersCallback(), contentSniffedCallback()). client->didReceiveResponse() is also the only way to set a response and MUST be called before didReceiveData(). I'm trying to guaranty that this will always happen and will not happend twice. This way, if someone add support for protocols with proper response (ftp, gopher, etc.) we can just concentrate on the soup backend and know that the binding is ready for it (aside the file/ftp/ftps filter that could be removed when the GIO backend is fixed). All the callbacks you mention are only executed for HTTP requests, for file: uri's none of them are called. That's why didreceiveresponse won't be called twice for file:URI's. 306811 15 nicolas 2010-11-09 08:37:59 -0800 (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > All the callbacks you mention are only executed for HTTP requests, for file: uri's none of them are called. That's why didreceiveresponse won't be called twice for file:URI's. I completely understand that, but you forgot that FTP, FTPS is also enabled (and those are currently handled with GIO, which mean no response). Your solution to do case by case handling is just not future proof. We need to be able to change the backend (e.g. add new protocols, add proper response to FTP) without always getting weird assert and crash. 306839 16 73316 gustavo 2010-11-09 09:54:34 -0800 Comment on attachment 73316 Fix assert using directory file URI As discussed on IRC, given the API is not set in stone, and the conceptually more correct fix for the current situation is to make the check on sendRequestCallback less strict, we'll go with that and rely on ASSERT to make sure we don't forget to dispatch a response where needed. 306954 17 73407 nicolas 2010-11-09 13:36:46 -0800 Created attachment 73407 Fix assert using directory file URI As requested I've reused the check that decided if GIO should be used and send a response in this case in sendRequestCallback(), also added assert to check we don't send twice and that we have sent a response. At first I though that we could simply check for m_response.isNull() in sendRequestCallback(), but found out that contentSniffedCallback() may be called after with HTTP streams, which leads to sending two responses. 307062 18 73407 mrobinson 2010-11-09 17:03:40 -0800 Comment on attachment 73407 Fix assert using directory file URI View in context: https://bugs.webkit.org/attachment.cgi?id=73407&action=review > LayoutTests/fast/loader/local-iFrame-directory-from-local.html:8 > + var localDirectoryLocation = "file:///tmp/LayoutTests/fast/loader/resources/directory"; Sorry. I did not get a chance to give you this feedback before you posted a new patch. Using the "/tmp" directory will not work on Windows machines. If possible this should be changed to a directory relative to the test file. Additionally the test should use "iframe" instead of "iFrame" to match the rest of the tests in the directory. > LayoutTests/fast/loader/local-iFrame-directory-from-local.html:16 > + var localDirectoryElement = document.createElement("iframe"); > + localDirectoryElement.setAttribute("id", "myDirectory"); > + localDirectoryElement.setAttribute("src", localDirectoryLocation); > + localDirectoryElement.setAttribute("width", "96%"); > + localDirectoryElement.setAttribute("height", "70%"); Is it possible to simply include this element in the HTML source instead of adding it dynamically? You might need to use the onload event to run the test at the proper time. > LayoutTests/fast/loader/local-iFrame-directory-from-local.html:22 > + var directoryDocument = document.getElementById("myDirectory").contentDocument; Is there a guarantee that the load will complete by this point? 307136 19 nicolas 2010-11-09 20:08:43 -0800 (In reply to comment #18) > (From update of attachment 73407 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=73407&action=review > > > LayoutTests/fast/loader/local-iFrame-directory-from-local.html:8 > > + var localDirectoryLocation = "file:///tmp/LayoutTests/fast/loader/resources/directory"; > > Sorry. I did not get a chance to give you this feedback before you posted a new patch. Using the "/tmp" directory will not work on Windows machines. If possible this should be changed to a directory relative to the test file. > > Additionally the test should use "iframe" instead of "iFrame" to match the rest of the tests in the directory. All this is base on local-iFrame-source-from-local.html (yes named with a big F) in the same directory. I assumed the test was correct. From this bug point of view, the test reproduce the ASSERT we had, but I'm not a JS expert. If you have a better example to propose I'll take, also if you consider this test wrong, then you should file a bug against those others tests (I think at least two other tests in this directory uses this template). 307221 20 svillar 2010-11-10 00:45:15 -0800 (In reply to comment #17) > Created an attachment (id=73407) [details] > Fix assert using directory file URI > > As requested I've reused the check that decided if GIO should be used and send a response in this case in sendRequestCallback(), also added assert to check we don't send twice and that we have sent a response. > > At first I though that we could simply check for m_response.isNull() in sendRequestCallback(), but found out that contentSniffedCallback() may be called after with HTTP streams, which leads to sending two responses. You could check with handle->shouldContentSniff() if content sniffing is activated and thus complement the isNull() check. Have you tried it? 307378 21 mrobinson 2010-11-10 09:17:23 -0800 > All this is base on local-iFrame-source-from-local.html (yes named with a big F) in the same directory. I assumed the test was correct. From this bug point of view, the test reproduce the ASSERT we had, but I'm not a JS expert. If you have a better example to propose I'll take, also if you consider this test wrong, then you should file a bug against those others tests (I think at least two other tests in this directory uses this template). I think the iFrame naming is an exceptional case among unit test naming. Perhaps a better template for this test would be iframe-crash-on-missing-image.xhtml. It's typical for crash to be in the name, when tseting crashes, for instance. 307531 22 73535 nicolas 2010-11-10 13:51:55 -0800 Created attachment 73535 Fix assert using directory file URI Updated patch. Code: - Added more assert() - Moved readCallback() assert lower since sending a response is not required if read failed. - Use d->m_response for data:// to avoid asserting on !d->m_response.isNull() later - Using handle->shouldContentSniff() along with d->m_response.isNull() to decide if a response should be sent in sendRequestCallback() Test: - renamed test to crash-display-local-directory.html - Creating iframe in HTML and not using JS - Using iframe onload() instead of body onload() - Using <p> instead of <div> and <br/> 307814 23 svillar 2010-11-11 03:38:02 -0800 (In reply to comment #22) > Created an attachment (id=73535) [details] > Fix assert using directory file URI > > Updated patch. The patch looks good to me, don't know if we need such amount of new asserts tough :). Being a bit picky I wouldn't say "Ensure a response for protocol using GIO.", we're ensuring it for any protocol not directly handled by WebKitGtk+, it could be gio, libsoup or whatever. And regarding the comment in the ChangeLog I suggest something more descriptive like: "Do ensure that didReceiveResponse happens before any call to didReceiveData. That was not true for file: URIs pointing to directories and thus was triggering an assertion." I think that's a bit better because your patch is really fixing that instead of only the directory issue mentioned in the bug. Just my 2 cents. Thx! > > Code: > - Added more assert() > - Moved readCallback() assert lower since sending a response is not required if read failed. > - Use d->m_response for data:// to avoid asserting on !d->m_response.isNull() later > - Using handle->shouldContentSniff() along with d->m_response.isNull() to decide if a response should be sent in sendRequestCallback() > > Test: > - renamed test to crash-display-local-directory.html > - Creating iframe in HTML and not using JS > - Using iframe onload() instead of body onload() > - Using <p> instead of <div> and <br/> 307859 24 nicolas 2010-11-11 05:46:05 -0800 (In reply to comment #23) > (In reply to comment #22) > > Created an attachment (id=73535) [details] [details] > > Fix assert using directory file URI > > > > Updated patch. > > The patch looks good to me, don't know if we need such amount of new asserts tough :). Being a bit picky I wouldn't say "Ensure a response for protocol using GIO.", we're ensuring it for any protocol not directly handled by WebKitGtk+, it could be gio, libsoup or whatever. All the asserts have been triggered once by at least one test. The numerous assert is just an indicator of how spaghetti is that code ;) I was doing generic stuff and you guys complained, so I've did it for what exist, and in this case soup and data was working, so I only fixed GIO (nothing else exist atm). > > And regarding the comment in the ChangeLog I suggest something more descriptive like: > "Do ensure that didReceiveResponse happens before any call to didReceiveData. That was not true for file: URIs pointing to directories and thus was triggering an assertion." I think that's a bit better because your patch is really fixing that instead of only the directory issue mentioned in the bug. Just my 2 cents. No, it was working for normal files, only directories where affected. FTP and FTPs always do errors (not mounted error), so they are not affected. > > Thx! > Just want to leave a note that it gets really frustrating when reviews are being done 1 line at the time. Please, consider doing full review next time, you'll save time and I'll save time too. Thanks for the review, I don't see anymore issues now. 307890 25 svillar 2010-11-11 06:49:12 -0800 (In reply to comment #24) > (In reply to comment #23) > > (In reply to comment #22) > > > Created an attachment (id=73535) [details] [details] [details] > > > Fix assert using directory file URI > > > > > > Updated patch. > > > > The patch looks good to me, don't know if we need such amount of new asserts tough :). Being a bit picky I wouldn't say "Ensure a response for protocol using GIO.", we're ensuring it for any protocol not directly handled by WebKitGtk+, it could be gio, libsoup or whatever. > > All the asserts have been triggered once by at least one test. The numerous assert is just an indicator of how spaghetti is that code ;) > > I was doing generic stuff and you guys complained, so I've did it for what exist, and in this case soup and data was working, so I only fixed GIO (nothing else exist atm). > > > > > And regarding the comment in the ChangeLog I suggest something more descriptive like: > > "Do ensure that didReceiveResponse happens before any call to didReceiveData. That was not true for file: URIs pointing to directories and thus was triggering an assertion." I think that's a bit better because your patch is really fixing that instead of only the directory issue mentioned in the bug. Just my 2 cents. > > No, it was working for normal files, only directories where affected. FTP and FTPs always do errors (not mounted error), so they are not affected. "That was not true for file: URIs pointing to directories" I didn't mention normal files at all. > Just want to leave a note that it gets really frustrating when reviews are being done 1 line at the time. Please, consider doing full review next time, you'll save time and I'll save time too. I have learned several things since I'm a webkitter, and one of them is that the review process could take some time, but it works, and it ensures that the project moves forward. We're part of a bigger project and entering in such a big community requires to accept some rules. I'm not a reviewer yet, but if you want to work in webkit my advice would be that you should be more patient, as reviewers are very busy guys that have to do a lot of things and ensure that the quality of the contributions meets webkit requirements. 310512 26 74152 nicolas 2010-11-17 14:01:59 -0800 Created attachment 74152 Fix assert using directory file URI Clarified commit and changelog messages along with the comment mentioned. 310743 27 svillar 2010-11-18 01:04:13 -0800 Sorry for not spotting this before but I think this is totally useless + String protocol = handle->firstRequest().url().protocol(); 310994 28 nicolas 2010-11-18 11:26:48 -0800 (In reply to comment #27) > Sorry for not spotting this before but I think this is totally useless > > + String protocol = handle->firstRequest().url().protocol(); Oops, good catch, will fix this afternoon (currently on PST). 312841 29 74663 nicolas 2010-11-23 07:50:36 -0800 Created attachment 74663 Fix assert using directory file URI This was a long afternoon ;), so I removed unused variable. 312879 30 74663 mrobinson 2010-11-23 08:59:17 -0800 Comment on attachment 74663 Fix assert using directory file URI Great. Thank you. 312898 31 74663 commit-queue 2010-11-23 09:56:16 -0800 Comment on attachment 74663 Fix assert using directory file URI Rejecting patch 74663 from commit-queue. Failed to run "['./WebKitTools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '--bot-id=abarth-cq-sl', 'build-and-test', '--no-clean', '--no-update', '--test', '--non-interactive']" exit_code: 2 Last 500 characters of output: ................................. fast/js/sputnik/Unicode/Unicode_510 ......................................... fast/layers ............................ fast/leaks .. fast/lists .......................................................... fast/loader ...... fast/loader/crash-display-local-directory.html -> failed Exiting early after 1 failures. 14830 tests run. 219.16s total testing time 14829 test cases (99%) succeeded 1 test case (<1%) had incorrect layout 5 test cases (<1%) had stderr output Full output: http://queues.webkit.org/results/6366018 313096 32 nicolas 2010-11-23 17:46:27 -0800 (In reply to comment #31) > fast/loader/crash-display-local-directory.html -> failed The test pass on my machine so I need help here. If somebody could provide me with the actual error being thrown. 313097 33 nicolas 2010-11-23 17:52:11 -0800 (In reply to comment #32) > Full output: http://queues.webkit.org/results/6366018 Wait, is this test run on OSX ? Maybe Safari does not implement directory listing (or not in the backend) ? Definatly need help here ! 313130 34 mrobinson 2010-11-23 22:28:10 -0800 Maybe this test should be a platform-specific test in platform/gtk. Does it rely on some behavior specific to soup? 313146 35 nicolas 2010-11-23 23:27:48 -0800 (In reply to comment #34) > Maybe this test should be a platform-specific test in platform/gtk. Does it rely on some behavior specific to soup? Actually the full story is that the iframe content is not dumped by DRT, which is nice because it makes the result browser agnostic as long as all browser supports listing local directory. One note though, I just realized that WebKit's default security policy is way too excessive with local file. I ran the test in stock Chrome and Epiphany and realized that it actually fails, but pass in GTK's DRT. The javascript operation required to check that the load succeeded get blocked because it pretends that file:/// and file:///mydir is not in the same domain/port. But as we mostly share the same settings for DRT I would be surprise this is the root cause of this failure. Would still be nice to find if there is any rational for this behavior (that we don't see on Opera and Firefox, need to file a bug I guess). As you said, we could make this GTK only, that would work, but I kind of liked the idea that directory listing in general had at least one test. Will look into this tomorrow. Thanks for your time. 313407 36 74782 nicolas 2010-11-24 11:23:44 -0800 Created attachment 74782 Same patch but with test moved to GTK platform test I simply moved the test to the GTK platform specific. 313410 37 74782 mrobinson 2010-11-24 11:27:57 -0800 Comment on attachment 74782 Same patch but with test moved to GTK platform test Okay. Let's try this again. 313417 38 74782 commit-queue 2010-11-24 12:02:54 -0800 Comment on attachment 74782 Same patch but with test moved to GTK platform test Clearing flags on attachment: 74782 Committed r72695: <http://trac.webkit.org/changeset/72695> 313418 39 commit-queue 2010-11-24 12:03:01 -0800 All reviewed patches have been landed. Closing bug. 72974 2010-11-04 13:05:39 -0700 2010-11-04 13:34:57 -0700 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 5276 nicolas RnJvbSBkYWRjZmQyYTFjNWZkMTRiNjFmNGViYWFlNTJhMDMwNzZkZGViZjA1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogVGh1LCA0IE5vdiAyMDEwIDE1OjU4OjQ2IC0wNDAwClN1Ympl Y3Q6IFtQQVRDSF0gW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGly ZWN0b3J5IGZpbGUgVVJJCgpodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDkwMTgKCldoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uClRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgp0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCmFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3Rv Y29sIGJlaW5nIHVzZWQuIEFsc28gcmVtb3ZlZApmdHAgZnJvbSBhbGxvd2VkIHByb3RvY29sIHNp bmNlIGluIGZhaWxzIG9uIGFuICJOb3QgbW91bnRlZCBlcnJvciIuCi0tLQogV2ViQ29yZS9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE4ICsrKysrKysrCiAu Li4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgICB8ICAgNDQg KysrKysrKysrLS0tLS0tLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMzggaW5zZXJ0aW9ucygrKSwg MjQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCAwNWU0OTk5Li5mNjQ5YWFhIDEwMDY0NAotLS0gYS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTEx LTA0ICBOaWNvbGFzIER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10g cmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisg ICAgICAgIFdoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uCisgICAgICAgIFRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGlu ZyBhIHByb3BlciByZXNwb25zZSBwcmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVu ay4gVGhpcyBwYXRjaCBlbnN1cmUgdGhhdCBhIHJlc3BvbnNlIGlzCisJYWx3YXlzIHNlbnQgcmVn YXJkbGVzcyBvZiB0aGUgcHJvdG9jb2wgYmVpbmcgdXNlZC4gQWxzbyByZW1vdmVkCisJZnRwIGZy b20gYWxsb3dlZCBwcm90b2NvbCBzaW5jZSBpbiBmYWlscyBvbiBhbiAiTm90IG1vdW50ZWQgZXJy b3IiLgorCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291 cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpzZW5kUmVxdWVzdENhbGxiYWNrKToKKyAgICAgICAg KFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpzdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpyZWFk Q2FsbGJhY2spOgorCiAyMDEwLTExLTAzICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWxleGV5IFByb3NrdXJ5YWtvdi4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAg Yi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmlu ZGV4IDBmOTc4NjcuLjVlMzJjMzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtNTI2LDI1ICs1MjYsNiBAQCBzdGF0 aWMgdm9pZCBzZW5kUmVxdWVzdENhbGxiYWNrKEdPYmplY3QqIHNvdXJjZSwgR0FzeW5jUmVzdWx0 KiByZXMsIGdwb2ludGVyIHVzZQogICAgIC8vIHJlYWRDYWxsYmFjayBuZWVkcyBpdAogICAgIGdf b2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCkpLCAid2Via2l0 LXJlc291cmNlIiwgaGFuZGxlLmdldCgpKTsKIAotICAgIC8vIFdlIG5lZWQgdG8gY2hlY2sgaWYg aXQncyBhIGZpbGU6IFVSTCBhbmQgaWYgaXQgaXMgYSByZWd1bGFyCi0gICAgLy8gZmlsZSBhcyBp dCBjb3VsZCBiZSBhIGRpcmVjdG9yeS4gSW4gdGhhdCBjYXNlIFNvdXAgcHJvcGVybHkKLSAgICAv LyByZXR1cm5zIGEgc3RyZWFtIHdob3NlIGNvbnRlbnQgaXMgYSBIVE1MIHdpdGggYSBsaXN0IG9m IGZpbGVzCi0gICAgLy8gaW4gdGhlIGRpcmVjdG9yeQotICAgIGlmIChlcXVhbElnbm9yaW5nQ2Fz ZShoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpLnByb3RvY29sKCksICJmaWxlIikKLSAgICAg ICAgJiYgR19JU19GSUxFX0lOUFVUX1NUUkVBTShpbikpIHsKLSAgICAgICAgUmVzb3VyY2VSZXNw b25zZSByZXNwb25zZTsKLQotICAgICAgICByZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJl cXVlc3QoKS51cmwoKSk7Ci0gICAgICAgIHJlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtpdF9zb3Vw X3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAg ICAgIHJlc3BvbnNlLnNldEV4cGVjdGVkQ29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0 X2dldF9jb250ZW50X2xlbmd0aChkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAgICAgIGNs aWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwgcmVzcG9uc2UpOwotCi0gICAg ICAgIGlmIChkLT5tX2NhbmNlbGxlZCkgewotICAgICAgICAgICAgY2xlYW51cFNvdXBSZXF1ZXN0 T3BlcmF0aW9uKGhhbmRsZS5nZXQoKSk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0K LSAgICB9Ci0KICAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2FzeW5jKGQtPm1faW5wdXRTdHJlYW0u Z2V0KCksIGQtPm1fYnVmZmVyLCBSRUFEX0JVRkZFUl9TSVpFLAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgR19QUklPUklUWV9ERUZBVUxULCBkLT5tX2NhbmNlbGxhYmxlLmdldCgpLCBy ZWFkQ2FsbGJhY2ssIDApOwogfQpAQCAtNjkxLDE2ICs2NzIsMTYgQEAgYm9vbCBSZXNvdXJjZUhh bmRsZTo6c3RhcnQoTmV0d29ya2luZ0NvbnRleHQqIGNvbnRleHQpCiAgICAgaWYgKGVxdWFsSWdu b3JpbmdDYXNlKHByb3RvY29sLCAiZGF0YSIpKQogICAgICAgICByZXR1cm4gc3RhcnREYXRhKHRo aXMsIHVybFN0cmluZyk7CiAKLSAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJo dHRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwcyIpKSB7CisgICAgaWYg KGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiaHR0cCIpIHx8IGVxdWFsSWdub3JpbmdDYXNl KHByb3RvY29sLCAiaHR0cHMiKSkKICAgICAgICAgaWYgKHN0YXJ0SHR0cCh0aGlzKSkKICAgICAg ICAgICAgIHJldHVybiB0cnVlOwotICAgIH0KIAotICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZShw cm90b2NvbCwgImZpbGUiKSB8fCBlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZ0cCIpIHx8 IGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZnRwcyIpKSB7Ci0gICAgICAgIC8vIEZJWE1F OiBzaG91bGQgd2UgYmUgZG9pbmcgYW55IG90aGVyIHByb3RvY29scyBoZXJlPworICAgIC8vIEZJ WE1FOiBTbyBmYXIgb3RoZXIgR0lPIHByb3RvY29sIHRoZW4gJ2ZpbGUnIHJlcXVpcmVzIG1vdW50 aW5nIHdoaWNoCisgICAgLy8gaXMgbm90IGRvbmUgYXV0b21hdGljYWxseSBhdCB0aGUgbW9tZW50 LCBzbyBmaWx0ZXIgdGhlbSBvdXQgdW50aWwgdGhpcworICAgIC8vIGlzc3VlIGlzIHNvbHZlZC4K KyAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJmaWxlIikpCiAgICAgICAgIGlm IChzdGFydEdpbyh0aGlzLCB1cmwpKQogICAgICAgICAgICAgcmV0dXJuIHRydWU7Ci0gICAgfQog CiAgICAgLy8gRXJyb3IgbXVzdCBub3QgYmUgcmVwb3J0ZWQgaW1tZWRpYXRlbHkKICAgICB0aGlz LT5zY2hlZHVsZUZhaWx1cmUoSW52YWxpZFVSTEZhaWx1cmUpOwpAQCAtNzk0LDYgKzc3NSwyMSBA QCBzdGF0aWMgdm9pZCByZWFkQ2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1bHQq IGFzeW5jUmVzdWx0LCBncG9pbnRlciBkYQogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAg Ly8gQXQgdGhpcyBwb2ludCwgaWYgdGhlIHByb3RvY29sIGlzIEhUVFAgYSByZXNwb25zZSBzaG91 bGQgaGF2ZQorICAgIC8vIGJlZW4gc2V0LCBvdGhlcndpc2Ugd2UgbmVlZCB0byBzZW5kIG9uZS4K KyAgICBpZiAoZC0+bV9yZXNwb25zZS5pc051bGwoKSkgeworICAgICAgICBkLT5tX3Jlc3BvbnNl LnNldFVSTChoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpKTsKKyAgICAgICAgZC0+bV9yZXNw b25zZS5zZXRNaW1lVHlwZSh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X3R5cGUoZC0+ bV9zb3VwUmVxdWVzdC5nZXQoKSkpOworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldEV4cGVjdGVk Q29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X2xlbmd0aChkLT5t X3NvdXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNl KGhhbmRsZS5nZXQoKSwgZC0+bV9yZXNwb25zZSk7CisKKyAgICAgICAgaWYgKGQtPm1fY2FuY2Vs bGVkKSB7CisgICAgICAgICAgICBjbGVhbnVwU291cFJlcXVlc3RPcGVyYXRpb24oaGFuZGxlLmdl dCgpKTsKKyAgICAgICAgICAgIC8vIE5vIG5lZWQgZm9yIHJlYWRfZmluaXNoKCksIEdJTyBpcyBz YWZlIGZvciB0aGF0CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKICAg ICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CiAKICAgICBnc3NpemUgYnl0ZXNSZWFkID0gZ19pbnB1 dF9zdHJlYW1fcmVhZF9maW5pc2goZC0+bV9pbnB1dFN0cmVhbS5nZXQoKSwgYXN5bmNSZXN1bHQs ICZlcnJvci5vdXRQdHIoKSk7Ci0tIAoxLjcuMy4yCgo= 72976 2010-11-04 13:34:57 -0700 2010-11-04 13:44:23 -0700 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 5276 nicolas RnJvbSA5NDhlMGUwZjEwMWRhMTcyNzYxZWVmZjcwMzZjMzlkNmU1MDgzZTk1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogVGh1LCA0IE5vdiAyMDEwIDE1OjU4OjQ2IC0wNDAwClN1Ympl Y3Q6IFtQQVRDSF0gW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGly ZWN0b3J5IGZpbGUgVVJJCgpodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDkwMTgKCldoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uClRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgp0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCmFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3Rv Y29sIGJlaW5nIHVzZWQuIEFsc28gcmVtb3ZlZApmdHAgZnJvbSBhbGxvd2VkIHByb3RvY29sIHNp bmNlIGluIGZhaWxzIG9uIGFuICJOb3QgbW91bnRlZCBlcnJvciIuCi0tLQogV2ViQ29yZS9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE4ICsrKysrKysrCiAu Li4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgICB8ICAgNDQg KysrKysrKysrLS0tLS0tLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMzggaW5zZXJ0aW9ucygrKSwg MjQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCAwNWU0OTk5Li5mNjQ5YWFhIDEwMDY0NAotLS0gYS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTEx LTA0ICBOaWNvbGFzIER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10g cmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisg ICAgICAgIFdoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uCisgICAgICAgIFRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGlu ZyBhIHByb3BlciByZXNwb25zZSBwcmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVu ay4gVGhpcyBwYXRjaCBlbnN1cmUgdGhhdCBhIHJlc3BvbnNlIGlzCisJYWx3YXlzIHNlbnQgcmVn YXJkbGVzcyBvZiB0aGUgcHJvdG9jb2wgYmVpbmcgdXNlZC4gQWxzbyByZW1vdmVkCisJZnRwIGZy b20gYWxsb3dlZCBwcm90b2NvbCBzaW5jZSBpbiBmYWlscyBvbiBhbiAiTm90IG1vdW50ZWQgZXJy b3IiLgorCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291 cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpzZW5kUmVxdWVzdENhbGxiYWNrKToKKyAgICAgICAg KFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpzdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpyZWFk Q2FsbGJhY2spOgorCiAyMDEwLTExLTAzICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWxleGV5IFByb3NrdXJ5YWtvdi4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAg Yi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmlu ZGV4IDBmOTc4NjcuLjVlMzJjMzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtNTI2LDI1ICs1MjYsNiBAQCBzdGF0 aWMgdm9pZCBzZW5kUmVxdWVzdENhbGxiYWNrKEdPYmplY3QqIHNvdXJjZSwgR0FzeW5jUmVzdWx0 KiByZXMsIGdwb2ludGVyIHVzZQogICAgIC8vIHJlYWRDYWxsYmFjayBuZWVkcyBpdAogICAgIGdf b2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCkpLCAid2Via2l0 LXJlc291cmNlIiwgaGFuZGxlLmdldCgpKTsKIAotICAgIC8vIFdlIG5lZWQgdG8gY2hlY2sgaWYg aXQncyBhIGZpbGU6IFVSTCBhbmQgaWYgaXQgaXMgYSByZWd1bGFyCi0gICAgLy8gZmlsZSBhcyBp dCBjb3VsZCBiZSBhIGRpcmVjdG9yeS4gSW4gdGhhdCBjYXNlIFNvdXAgcHJvcGVybHkKLSAgICAv LyByZXR1cm5zIGEgc3RyZWFtIHdob3NlIGNvbnRlbnQgaXMgYSBIVE1MIHdpdGggYSBsaXN0IG9m IGZpbGVzCi0gICAgLy8gaW4gdGhlIGRpcmVjdG9yeQotICAgIGlmIChlcXVhbElnbm9yaW5nQ2Fz ZShoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpLnByb3RvY29sKCksICJmaWxlIikKLSAgICAg ICAgJiYgR19JU19GSUxFX0lOUFVUX1NUUkVBTShpbikpIHsKLSAgICAgICAgUmVzb3VyY2VSZXNw b25zZSByZXNwb25zZTsKLQotICAgICAgICByZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJl cXVlc3QoKS51cmwoKSk7Ci0gICAgICAgIHJlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtpdF9zb3Vw X3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAg ICAgIHJlc3BvbnNlLnNldEV4cGVjdGVkQ29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0 X2dldF9jb250ZW50X2xlbmd0aChkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAgICAgIGNs aWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwgcmVzcG9uc2UpOwotCi0gICAg ICAgIGlmIChkLT5tX2NhbmNlbGxlZCkgewotICAgICAgICAgICAgY2xlYW51cFNvdXBSZXF1ZXN0 T3BlcmF0aW9uKGhhbmRsZS5nZXQoKSk7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0K LSAgICB9Ci0KICAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2FzeW5jKGQtPm1faW5wdXRTdHJlYW0u Z2V0KCksIGQtPm1fYnVmZmVyLCBSRUFEX0JVRkZFUl9TSVpFLAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgR19QUklPUklUWV9ERUZBVUxULCBkLT5tX2NhbmNlbGxhYmxlLmdldCgpLCBy ZWFkQ2FsbGJhY2ssIDApOwogfQpAQCAtNjkxLDE2ICs2NzIsMTYgQEAgYm9vbCBSZXNvdXJjZUhh bmRsZTo6c3RhcnQoTmV0d29ya2luZ0NvbnRleHQqIGNvbnRleHQpCiAgICAgaWYgKGVxdWFsSWdu b3JpbmdDYXNlKHByb3RvY29sLCAiZGF0YSIpKQogICAgICAgICByZXR1cm4gc3RhcnREYXRhKHRo aXMsIHVybFN0cmluZyk7CiAKLSAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJo dHRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwcyIpKSB7CisgICAgaWYg KGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiaHR0cCIpIHx8IGVxdWFsSWdub3JpbmdDYXNl KHByb3RvY29sLCAiaHR0cHMiKSkKICAgICAgICAgaWYgKHN0YXJ0SHR0cCh0aGlzKSkKICAgICAg ICAgICAgIHJldHVybiB0cnVlOwotICAgIH0KIAotICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZShw cm90b2NvbCwgImZpbGUiKSB8fCBlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZ0cCIpIHx8 IGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZnRwcyIpKSB7Ci0gICAgICAgIC8vIEZJWE1F OiBzaG91bGQgd2UgYmUgZG9pbmcgYW55IG90aGVyIHByb3RvY29scyBoZXJlPworICAgIC8vIEZJ WE1FOiBTbyBmYXIgb3RoZXIgR0lPIHByb3RvY29sIHRoZW4gJ2ZpbGUnIHJlcXVpcmVzIG1vdW50 aW5nIHdoaWNoCisgICAgLy8gaXMgbm90IGRvbmUgYXV0b21hdGljYWxseSBhdCB0aGUgbW9tZW50 LCBzbyBmaWx0ZXIgdGhlbSBvdXQgdW50aWwgdGhpcworICAgIC8vIGlzc3VlIGlzIHNvbHZlZC4K KyAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJmaWxlIikpCiAgICAgICAgIGlm IChzdGFydEdpbyh0aGlzLCB1cmwpKQogICAgICAgICAgICAgcmV0dXJuIHRydWU7Ci0gICAgfQog CiAgICAgLy8gRXJyb3IgbXVzdCBub3QgYmUgcmVwb3J0ZWQgaW1tZWRpYXRlbHkKICAgICB0aGlz LT5zY2hlZHVsZUZhaWx1cmUoSW52YWxpZFVSTEZhaWx1cmUpOwpAQCAtNzk0LDYgKzc3NSwyMSBA QCBzdGF0aWMgdm9pZCByZWFkQ2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1bHQq IGFzeW5jUmVzdWx0LCBncG9pbnRlciBkYQogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAg Ly8gQXQgdGhpcyBwb2ludCwgaWYgdGhlIHByb3RvY29sIGlzIEhUVFAgYSByZXNwb25zZSBzaG91 bGQgaGF2ZQorICAgIC8vIGJlZW4gc2V0LCBvdGhlcndpc2Ugd2UgbmVlZCB0byBzZW5kIG9uZS4K KyAgICBpZiAoZC0+bV9yZXNwb25zZS5pc051bGwoKSkgeworICAgICAgICBkLT5tX3Jlc3BvbnNl LnNldFVSTChoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpKTsKKyAgICAgICAgZC0+bV9yZXNw b25zZS5zZXRNaW1lVHlwZSh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X3R5cGUoZC0+ bV9zb3VwUmVxdWVzdC5nZXQoKSkpOworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldEV4cGVjdGVk Q29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X2xlbmd0aChkLT5t X3NvdXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNl KGhhbmRsZS5nZXQoKSwgZC0+bV9yZXNwb25zZSk7CisKKyAgICAgICAgaWYgKGQtPm1fY2FuY2Vs bGVkKSB7CisgICAgICAgICAgICBjbGVhbnVwU291cFJlcXVlc3RPcGVyYXRpb24oaGFuZGxlLmdl dCgpKTsKKyAgICAgICAgICAgIC8vIE5vIG5lZWQgZm9yIHJlYWRfZmluaXNoKCksIEdJTyBpcyBz YWZlIGZvciB0aGF0CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisKICAg ICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CiAKICAgICBnc3NpemUgYnl0ZXNSZWFkID0gZ19pbnB1 dF9zdHJlYW1fcmVhZF9maW5pc2goZC0+bV9pbnB1dFN0cmVhbS5nZXQoKSwgYXN5bmNSZXN1bHQs ICZlcnJvci5vdXRQdHIoKSk7Ci0tIAoxLjcuMy4yCgo= 72978 2010-11-04 13:44:23 -0700 2010-11-08 17:03:50 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 5290 nicolas RnJvbSA5OTc4ZWFlMmJmYWY3NDliYTI1ZDVlNDc3NzRmMTEwM2E3ODhmZjNjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogVGh1LCA0IE5vdiAyMDEwIDE1OjU4OjQ2IC0wNDAwClN1Ympl Y3Q6IFtQQVRDSF0gW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGly ZWN0b3J5IGZpbGUgVVJJCgpodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDkwMTgKCldoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uClRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgp0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCmFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3Rv Y29sIGJlaW5nIHVzZWQuIEFsc28gcmVtb3ZlZApmdHAgZnJvbSBhbGxvd2VkIHByb3RvY29sIHNp bmNlIGluIGZhaWxzIG9uIGFuICJOb3QgbW91bnRlZCBlcnJvciIuCi0tLQogV2ViQ29yZS9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE4ICsrKysrKysrCiAu Li4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgICB8ICAgNDQg KysrKysrKysrLS0tLS0tLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMzggaW5zZXJ0aW9ucygrKSwg MjQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCAwNWU0OTk5Li5kNjdlZTY0IDEwMDY0NAotLS0gYS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTEx LTA0ICBOaWNvbGFzIER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10g cmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisg ICAgICAgIFdoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uCisgICAgICAgIFRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGlu ZyBhIHByb3BlciByZXNwb25zZSBwcmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVu ay4gVGhpcyBwYXRjaCBlbnN1cmUgdGhhdCBhIHJlc3BvbnNlIGlzCisgICAgICAgIGFsd2F5cyBz ZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3RvY29sIGJlaW5nIHVzZWQuIEFsc28gcmVtb3ZlZAor ICAgICAgICBmdHAgZnJvbSBhbGxvd2VkIHByb3RvY29sIHNpbmNlIGluIGZhaWxzIG9uIGFuICJO b3QgbW91bnRlZCBlcnJvciIuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VIYW5kbGVTb3VwLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnNlbmRSZXF1ZXN0Q2FsbGJh Y2spOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0KToKKyAgICAgICAg KFdlYkNvcmU6OnJlYWRDYWxsYmFjayk6CisKIDIwMTAtMTEtMDMgIE5hdGUgQ2hhcGluICA8amFw aGV0QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBbGV4ZXkgUHJvc2t1cnlh a292LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAKaW5kZXggMGY5Nzg2Ny4uNWUzMmMzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC01MjYsMjUg KzUyNiw2IEBAIHN0YXRpYyB2b2lkIHNlbmRSZXF1ZXN0Q2FsbGJhY2soR09iamVjdCogc291cmNl LCBHQXN5bmNSZXN1bHQqIHJlcywgZ3BvaW50ZXIgdXNlCiAgICAgLy8gcmVhZENhbGxiYWNrIG5l ZWRzIGl0CiAgICAgZ19vYmplY3Rfc2V0X2RhdGEoR19PQkpFQ1QoZC0+bV9pbnB1dFN0cmVhbS5n ZXQoKSksICJ3ZWJraXQtcmVzb3VyY2UiLCBoYW5kbGUuZ2V0KCkpOwogCi0gICAgLy8gV2UgbmVl ZCB0byBjaGVjayBpZiBpdCdzIGEgZmlsZTogVVJMIGFuZCBpZiBpdCBpcyBhIHJlZ3VsYXIKLSAg ICAvLyBmaWxlIGFzIGl0IGNvdWxkIGJlIGEgZGlyZWN0b3J5LiBJbiB0aGF0IGNhc2UgU291cCBw cm9wZXJseQotICAgIC8vIHJldHVybnMgYSBzdHJlYW0gd2hvc2UgY29udGVudCBpcyBhIEhUTUwg d2l0aCBhIGxpc3Qgb2YgZmlsZXMKLSAgICAvLyBpbiB0aGUgZGlyZWN0b3J5Ci0gICAgaWYgKGVx dWFsSWdub3JpbmdDYXNlKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkucHJvdG9jb2woKSwg ImZpbGUiKQotICAgICAgICAmJiBHX0lTX0ZJTEVfSU5QVVRfU1RSRUFNKGluKSkgewotICAgICAg ICBSZXNvdXJjZVJlc3BvbnNlIHJlc3BvbnNlOwotCi0gICAgICAgIHJlc3BvbnNlLnNldFVSTCho YW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpKTsKLSAgICAgICAgcmVzcG9uc2Uuc2V0TWltZVR5 cGUod2Via2l0X3NvdXBfcmVxdWVzdF9nZXRfY29udGVudF90eXBlKGQtPm1fc291cFJlcXVlc3Qu Z2V0KCkpKTsKLSAgICAgICAgcmVzcG9uc2Uuc2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHdlYmtp dF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfbGVuZ3RoKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkp KTsKLSAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCByZXNw b25zZSk7Ci0KLSAgICAgICAgaWYgKGQtPm1fY2FuY2VsbGVkKSB7Ci0gICAgICAgICAgICBjbGVh bnVwU291cFJlcXVlc3RPcGVyYXRpb24oaGFuZGxlLmdldCgpKTsKLSAgICAgICAgICAgIHJldHVy bjsKLSAgICAgICAgfQotICAgIH0KLQogICAgIGdfaW5wdXRfc3RyZWFtX3JlYWRfYXN5bmMoZC0+ bV9pbnB1dFN0cmVhbS5nZXQoKSwgZC0+bV9idWZmZXIsIFJFQURfQlVGRkVSX1NJWkUsCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBHX1BSSU9SSVRZX0RFRkFVTFQsIGQtPm1fY2FuY2Vs bGFibGUuZ2V0KCksIHJlYWRDYWxsYmFjaywgMCk7CiB9CkBAIC02OTEsMTYgKzY3MiwxNiBAQCBi b29sIFJlc291cmNlSGFuZGxlOjpzdGFydChOZXR3b3JraW5nQ29udGV4dCogY29udGV4dCkKICAg ICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJkYXRhIikpCiAgICAgICAgIHJldHVy biBzdGFydERhdGEodGhpcywgdXJsU3RyaW5nKTsKIAotICAgIGlmIChlcXVhbElnbm9yaW5nQ2Fz ZShwcm90b2NvbCwgImh0dHAiKSB8fCBlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImh0dHBz IikpIHsKKyAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwIikgfHwgZXF1 YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwcyIpKQogICAgICAgICBpZiAoc3RhcnRIdHRw KHRoaXMpKQogICAgICAgICAgICAgcmV0dXJuIHRydWU7Ci0gICAgfQogCi0gICAgaWYgKGVxdWFs SWdub3JpbmdDYXNlKHByb3RvY29sLCAiZmlsZSIpIHx8IGVxdWFsSWdub3JpbmdDYXNlKHByb3Rv Y29sLCAiZnRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJmdHBzIikpIHsKLSAg ICAgICAgLy8gRklYTUU6IHNob3VsZCB3ZSBiZSBkb2luZyBhbnkgb3RoZXIgcHJvdG9jb2xzIGhl cmU/CisgICAgLy8gRklYTUU6IFNvIGZhciBvdGhlciBHSU8gcHJvdG9jb2wgdGhlbiAnZmlsZScg cmVxdWlyZXMgbW91bnRpbmcgd2hpY2gKKyAgICAvLyBpcyBub3QgZG9uZSBhdXRvbWF0aWNhbGx5 IGF0IHRoZSBtb21lbnQsIHNvIGZpbHRlciB0aGVtIG91dCB1bnRpbCB0aGlzCisgICAgLy8gaXNz dWUgaXMgc29sdmVkLgorICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZpbGUi KSkKICAgICAgICAgaWYgKHN0YXJ0R2lvKHRoaXMsIHVybCkpCiAgICAgICAgICAgICByZXR1cm4g dHJ1ZTsKLSAgICB9CiAKICAgICAvLyBFcnJvciBtdXN0IG5vdCBiZSByZXBvcnRlZCBpbW1lZGlh dGVseQogICAgIHRoaXMtPnNjaGVkdWxlRmFpbHVyZShJbnZhbGlkVVJMRmFpbHVyZSk7CkBAIC03 OTQsNiArNzc1LDIxIEBAIHN0YXRpYyB2b2lkIHJlYWRDYWxsYmFjayhHT2JqZWN0KiBzb3VyY2Us IEdBc3luY1Jlc3VsdCogYXN5bmNSZXN1bHQsIGdwb2ludGVyIGRhCiAgICAgICAgIHJldHVybjsK ICAgICB9CiAKKyAgICAvLyBBdCB0aGlzIHBvaW50LCBpZiB0aGUgcHJvdG9jb2wgaXMgSFRUUCBh IHJlc3BvbnNlIHNob3VsZCBoYXZlCisgICAgLy8gYmVlbiBzZXQsIG90aGVyd2lzZSB3ZSBuZWVk IHRvIHNlbmQgb25lLgorICAgIGlmIChkLT5tX3Jlc3BvbnNlLmlzTnVsbCgpKSB7CisgICAgICAg IGQtPm1fcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkpOworICAg ICAgICBkLT5tX3Jlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2Nv bnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGQtPm1fcmVzcG9u c2Uuc2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRl bnRfbGVuZ3RoKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKKyAgICAgICAgY2xpZW50LT5kaWRS ZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKKworICAgICAgICBp ZiAoZC0+bV9jYW5jZWxsZWQpIHsKKyAgICAgICAgICAgIGNsZWFudXBTb3VwUmVxdWVzdE9wZXJh dGlvbihoYW5kbGUuZ2V0KCkpOworICAgICAgICAgICAgLy8gTm8gbmVlZCBmb3IgcmVhZF9maW5p c2goKSwgR0lPIGlzIHNhZmUgZm9yIHRoYXQKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAg fQorICAgIH0KKwogICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKIAogICAgIGdzc2l6ZSBieXRl c1JlYWQgPSBnX2lucHV0X3N0cmVhbV9yZWFkX2ZpbmlzaChkLT5tX2lucHV0U3RyZWFtLmdldCgp LCBhc3luY1Jlc3VsdCwgJmVycm9yLm91dFB0cigpKTsKLS0gCjEuNy4zLjIKCg== 73309 2010-11-08 17:03:50 -0800 2010-11-08 17:20:44 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 8300 nicolas RnJvbSBkMjQ2MGNjNTkyNTQ2ZmYyNmUwMWMyMDlmMzBhNjA5OGFkZTc2OWVlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogTW9uLCA4IE5vdiAyMDEwIDE5OjU5OjU3IC0wNTAwClN1Ympl Y3Q6IFtQQVRDSF0gW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGly ZWN0b3J5IGZpbGUgVVJJCgpodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDkwMTgKCldoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uClRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgp0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCmFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3Rv Y29sIGJlaW5nIHVzZWQuCi0tLQogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKysKIC4uLi9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5 LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0IHwgICAgNiArKysKIC4uLi9sb2FkZXIvbG9jYWwtaUZy YW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwgIHwgICA0NCArKysrKysrKysrKysrKysrKysr KwogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg IDE5ICsrKysrKysrCiAuLi4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291 cC5jcHAgICB8ICAgMzQgKysrKysrKy0tLS0tLS0tCiA1IGZpbGVzIGNoYW5nZWQsIDEwMCBpbnNl cnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0 cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQu dHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvbG9jYWwtaUZy YW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRU ZXN0cy9mYXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkKCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg ZGYxYmZiZS4uZjc4NzMyYyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBi L0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEwLTExLTA4ICBOaWNv bGFzIER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10gcmVzcG9uc2Uu aXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisgICAgICAgIFdo ZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBhc3NlcnRpb24u CisgICAgICAgIFRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBw YXRjaCBlbnN1cmUgdGhhdCBhIHJlc3BvbnNlIGlzCisgICAgICAgIGFsd2F5cyBzZW50IHJlZ2Fy ZGxlc3Mgb2YgdGhlIHByb3RvY29sIGJlaW5nIHVzZWQuCisKKyAgICAgICAgKiBmYXN0L2xvYWRl ci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9r ZWVwLWVtcHR5OiBBZGRlZC4KKwogMjAxMC0xMS0wOCAgVG9ueSBDaGFuZyAgPHRvbnlAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQuICBNb3ZpbmcgYSBwbHVnaW4gdGVzdCBpbnRv IHRoZSBwbHVnaW5zIGRpcmVjdG9yeS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbG9h ZGVyL2xvY2FsLWlGcmFtZS1kaXJlY3RvcnktZnJvbS1sb2NhbC1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhw ZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI0YjEzMWUKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGly ZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorVGhpcyB0ZXN0 IGlzIHRvIHNlZSBpZiBhIGxvY2FsIGRpcmVjdG9yeSBpbmRleCBjYW4gYmUgZGlwbGF5ZWQuIAor Q3VycmVudGx5IHRoaXMgdGVzdCBjYW5ub3QgYmUgcnVuIG1hbnVhbGx5IG9uIFdpbmRvd3MgYmVj YXVzZSB3ZSBkbyBub3QgaGF2ZSBhIGZ1bmN0aW9uIGxpa2UgcGF0aFRvTG9jYWxSZXNvdXJjZSgp IG91dHNpZGUgb2YgRFJULiAKKworUEFTUzogTG9jYWwgZGlyZWN0b3J5IGxvYWRlZC4KKworCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5 LWZyb20tbG9jYWwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2xvY2FsLWlGcmFtZS1k aXJlY3RvcnktZnJvbS1sb2NhbC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjE3MzMwNDcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9s b2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbApAQCAtMCwwICsxLDQ0IEBACis8 aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQ+CisgICAgICAgIGZ1bmN0aW9uIGRpcmVjdG9yeVRl c3QoKSB7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAg ICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgICAg ICAgICAgdmFyIGxvY2FsRGlyZWN0b3J5TG9jYXRpb24gPSAiZmlsZTovLy90bXAvTGF5b3V0VGVz dHMvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeSI7CisgICAgICAgICAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxvY2FsRGlyZWN0b3J5 TG9jYXRpb24gPSBsYXlvdXRUZXN0Q29udHJvbGxlci5wYXRoVG9Mb2NhbFJlc291cmNlKGxvY2Fs RGlyZWN0b3J5TG9jYXRpb24pOworCisgICAgICAgICAgICB2YXIgbG9jYWxEaXJlY3RvcnlFbGVt ZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiaWZyYW1lIik7CisgICAgICAgICAgICBsb2Nh bERpcmVjdG9yeUVsZW1lbnQuc2V0QXR0cmlidXRlKCJpZCIsICJteURpcmVjdG9yeSIpOworICAg ICAgICAgICAgbG9jYWxEaXJlY3RvcnlFbGVtZW50LnNldEF0dHJpYnV0ZSgic3JjIiwgbG9jYWxE aXJlY3RvcnlMb2NhdGlvbik7CisgICAgICAgICAgICBsb2NhbERpcmVjdG9yeUVsZW1lbnQuc2V0 QXR0cmlidXRlKCJ3aWR0aCIsICI5NiUiKTsKKyAgICAgICAgICAgIGxvY2FsRGlyZWN0b3J5RWxl bWVudC5zZXRBdHRyaWJ1dGUoImhlaWdodCIsICI3MCUiKTsKKworICAgICAgICAgICAgZG9jdW1l bnQuYm9keS5hcHBlbmRDaGlsZChsb2NhbERpcmVjdG9yeUVsZW1lbnQpOworCisgICAgICAgICAg ICB2YXIgcmVzdWx0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdCIpOworCisgICAg ICAgICAgICB2YXIgZGlyZWN0b3J5RG9jdW1lbnQgPSAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo Im15RGlyZWN0b3J5IikuY29udGVudERvY3VtZW50OworICAgICAgICAgICAgaWYgKGRpcmVjdG9y eURvY3VtZW50KQorICAgICAgICAgICAgICByZXN1bHQuaW5uZXJIVE1MID0gIlBBU1M6IExvY2Fs IGRpcmVjdG9yeSBsb2FkZWQuIjsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgcmVz dWx0LmlubmVySFRNTCA9ICJGQUlMOiBMb2NhbCBkaXJlY3RvcnkgY2Fubm90IGJlIGxpc3RlZC4i OworICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9ImRpcmVj dG9yeVRlc3QoKSI+CisgICAgPGRpdiBpZD0iZGl2MCI+CisgICAgICAgIFRoaXMgdGVzdCBpcyB0 byBzZWUgaWYgYSBsb2NhbCBkaXJlY3RvcnkgaW5kZXggY2FuIGJlIGRpcGxheWVkLgorICAgICAg ICA8YnIvPgorICAgICAgICBDdXJyZW50bHkgdGhpcyB0ZXN0IGNhbm5vdCBiZSBydW4gbWFudWFs bHkgb24gV2luZG93cyBiZWNhdXNlIHdlIGRvIG5vdCBoYXZlCisgICAgICAgIGEgZnVuY3Rpb24g bGlrZSBwYXRoVG9Mb2NhbFJlc291cmNlKCkgb3V0c2lkZSBvZiBEUlQuCisgICAgICAgIDxici8+ CisgICAgPC9kaXY+CisgICAgPC9icj4KKyAgICA8ZGl2IGlkPSJyZXN1bHQiPgorICAgICAgICBU ZXN0IGhhcyBub3QgcnVuLgorICAgIDwvZGl2PgorICAgIDwvYnI+Cis8L2JvZHk+Cis8L2h0bWw+ CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5 L2tlZXAtZW1wdHkgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5 L2tlZXAtZW1wdHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTY5ZGUyOQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBi Zjc4OGRmLi4zOTk2ZTA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJD b3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEwLTExLTA4ICBOaWNvbGFzIER1ZnJl c25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkg YXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisgICAgICAgIFdoZW4gdXNpbmcg ZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBhc3NlcnRpb24uCisgICAgICAg IFRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3BlciByZXNwb25z ZSBwcmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCisgICAgICAgIGFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2Yg dGhlIHByb3RvY29sIGJlaW5nIHVzZWQuCisKKyAgICAgICAgVGVzdDogZmFzdC9sb2FkZXIvbG9j YWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwKKworICAgICAgICAqIHBsYXRmb3Jt L25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 c2VuZFJlcXVlc3RDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZTo6 c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6cmVhZENhbGxiYWNrKToKKwogMjAxMC0xMS0wOCAg WGlhb21laSBKaSAgPHhqaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFu IEJlcm5zdGVpbi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jl c291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNv dXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDBmOTc4NjcuLjU3MWE0ODAgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAt NTI2LDI1ICs1MjYsNiBAQCBzdGF0aWMgdm9pZCBzZW5kUmVxdWVzdENhbGxiYWNrKEdPYmplY3Qq IHNvdXJjZSwgR0FzeW5jUmVzdWx0KiByZXMsIGdwb2ludGVyIHVzZQogICAgIC8vIHJlYWRDYWxs YmFjayBuZWVkcyBpdAogICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKGQtPm1faW5wdXRT dHJlYW0uZ2V0KCkpLCAid2Via2l0LXJlc291cmNlIiwgaGFuZGxlLmdldCgpKTsKIAotICAgIC8v IFdlIG5lZWQgdG8gY2hlY2sgaWYgaXQncyBhIGZpbGU6IFVSTCBhbmQgaWYgaXQgaXMgYSByZWd1 bGFyCi0gICAgLy8gZmlsZSBhcyBpdCBjb3VsZCBiZSBhIGRpcmVjdG9yeS4gSW4gdGhhdCBjYXNl IFNvdXAgcHJvcGVybHkKLSAgICAvLyByZXR1cm5zIGEgc3RyZWFtIHdob3NlIGNvbnRlbnQgaXMg YSBIVE1MIHdpdGggYSBsaXN0IG9mIGZpbGVzCi0gICAgLy8gaW4gdGhlIGRpcmVjdG9yeQotICAg IGlmIChlcXVhbElnbm9yaW5nQ2FzZShoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpLnByb3Rv Y29sKCksICJmaWxlIikKLSAgICAgICAgJiYgR19JU19GSUxFX0lOUFVUX1NUUkVBTShpbikpIHsK LSAgICAgICAgUmVzb3VyY2VSZXNwb25zZSByZXNwb25zZTsKLQotICAgICAgICByZXNwb25zZS5z ZXRVUkwoaGFuZGxlLT5maXJzdFJlcXVlc3QoKS51cmwoKSk7Ci0gICAgICAgIHJlc3BvbnNlLnNl dE1pbWVUeXBlKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBS ZXF1ZXN0LmdldCgpKSk7Ci0gICAgICAgIHJlc3BvbnNlLnNldEV4cGVjdGVkQ29udGVudExlbmd0 aCh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X2xlbmd0aChkLT5tX3NvdXBSZXF1ZXN0 LmdldCgpKSk7Ci0gICAgICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQo KSwgcmVzcG9uc2UpOwotCi0gICAgICAgIGlmIChkLT5tX2NhbmNlbGxlZCkgewotICAgICAgICAg ICAgY2xlYW51cFNvdXBSZXF1ZXN0T3BlcmF0aW9uKGhhbmRsZS5nZXQoKSk7Ci0gICAgICAgICAg ICByZXR1cm47Ci0gICAgICAgIH0KLSAgICB9Ci0KICAgICBnX2lucHV0X3N0cmVhbV9yZWFkX2Fz eW5jKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCksIGQtPm1fYnVmZmVyLCBSRUFEX0JVRkZFUl9TSVpF LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR19QUklPUklUWV9ERUZBVUxULCBkLT5t X2NhbmNlbGxhYmxlLmdldCgpLCByZWFkQ2FsbGJhY2ssIDApOwogfQpAQCAtNzk0LDYgKzc3NSwy MSBAQCBzdGF0aWMgdm9pZCByZWFkQ2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1 bHQqIGFzeW5jUmVzdWx0LCBncG9pbnRlciBkYQogICAgICAgICByZXR1cm47CiAgICAgfQogCisg ICAgLy8gQXQgdGhpcyBwb2ludCwgaWYgdGhlIHByb3RvY29sIGlzIEhUVFAgYSByZXNwb25zZSBz aG91bGQgaGF2ZQorICAgIC8vIGJlZW4gc2V0LCBvdGhlcndpc2Ugd2UgbmVlZCB0byBzZW5kIG9u ZS4KKyAgICBpZiAoZC0+bV9yZXNwb25zZS5pc051bGwoKSkgeworICAgICAgICBkLT5tX3Jlc3Bv bnNlLnNldFVSTChoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpKTsKKyAgICAgICAgZC0+bV9y ZXNwb25zZS5zZXRNaW1lVHlwZSh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X3R5cGUo ZC0+bV9zb3VwUmVxdWVzdC5nZXQoKSkpOworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldEV4cGVj dGVkQ29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50X2xlbmd0aChk LT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3Bv bnNlKGhhbmRsZS5nZXQoKSwgZC0+bV9yZXNwb25zZSk7CisKKyAgICAgICAgaWYgKGQtPm1fY2Fu Y2VsbGVkKSB7CisgICAgICAgICAgICBjbGVhbnVwU291cFJlcXVlc3RPcGVyYXRpb24oaGFuZGxl LmdldCgpKTsKKyAgICAgICAgICAgIC8vIE5vIG5lZWQgZm9yIHJlYWRfZmluaXNoKCksIEdJTyBp cyBzYWZlIGZvciB0aGF0CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CisK ICAgICBHT3duUHRyPEdFcnJvcj4gZXJyb3I7CiAKICAgICBnc3NpemUgYnl0ZXNSZWFkID0gZ19p bnB1dF9zdHJlYW1fcmVhZF9maW5pc2goZC0+bV9pbnB1dFN0cmVhbS5nZXQoKSwgYXN5bmNSZXN1 bHQsICZlcnJvci5vdXRQdHIoKSk7Ci0tIAoxLjcuMy4yCgo= 73316 2010-11-08 17:20:44 -0800 2010-11-09 13:36:46 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 8548 nicolas RnJvbSBjNmNkNWQ5MmVmNWI3N2VmNWE1OGQ4NzM1ODNlMzUxMDA0ZmZmNjM5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogTW9uLCA4IE5vdiAyMDEwIDE5OjU5OjU3IC0wNTAwClN1Ympl Y3Q6IFtQQVRDSF0gW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGly ZWN0b3J5IGZpbGUgVVJJCgpodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDkwMTgKCldoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uClRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgp0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCmFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3Rv Y29sIGJlaW5nIHVzZWQuCi0tLQogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKysKIC4uLi9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5 LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0IHwgICAgNiArKysKIC4uLi9sb2FkZXIvbG9jYWwtaUZy YW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwgIHwgICA0NCArKysrKysrKysrKysrKysrKysr KwogLi4uL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eSAgICAgfCAg ICAyICsKIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgICAxOSArKysrKysrKwogLi4uL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRs ZVNvdXAuY3BwICAgfCAgIDM0ICsrKysrKystLS0tLS0tLQogNiBmaWxlcyBjaGFuZ2VkLCAxMDIg aW5zZXJ0aW9ucygrKSwgMTkgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0 VGVzdHMvZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLWV4cGVj dGVkLnR4dAogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2xvY2Fs LWlGcmFtZS1kaXJlY3RvcnktZnJvbS1sb2NhbC5odG1sCiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5 b3V0VGVzdHMvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5CgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmlu ZGV4IDI4YmY1NDcuLmEwYTJiNTYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZwor KysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxMC0xMS0wOCAg Tmljb2xhcyBEdWZyZXNuZSAgPG5pY29sYXMuZHVmcmVzbmVAY29sbGFib3JhLmNvLnVrPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHVEtdIHJlc3Bv bnNlLmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRpcmVjdG9yeSBmaWxlIFVSSQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDkwMTgKKworICAgICAg ICBXaGVuIHVzaW5nIGZpbGU6Ly8vIChvciBhbnkgZGlyZWN0b3J5KSB3ZSBnZXQgYW4gYXNzZXJ0 aW9uLgorICAgICAgICBUaGlzIGlzIGR1ZSB0byBTb3VwIGJhY2tlbmQgbm90IHNlbmRpbmcgYSBw cm9wZXIgcmVzcG9uc2UgcHJpb3IKKyAgICAgICAgdG8gdGhlIGZpcnN0IGRhdGEgY2h1bmsuIFRo aXMgcGF0Y2ggZW5zdXJlIHRoYXQgYSByZXNwb25zZSBpcworICAgICAgICBhbHdheXMgc2VudCBy ZWdhcmRsZXNzIG9mIHRoZSBwcm90b2NvbCBiZWluZyB1c2VkLgorCisgICAgICAgICogZmFzdC9s b2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxv Y2FsLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rv cnkva2VlcC1lbXB0eTogQWRkZWQuCisKIDIwMTAtMTEtMDggIERhdmlkIEh5YXR0ICA8aHlhdHRA YXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEZyYXNlci4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2xvY2FsLWlGcmFtZS1kaXJlY3RvcnktZnJvbS1s b2NhbC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUt ZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLmI0YjEzMWUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEsNiBAQAorVGhpcyB0ZXN0IGlzIHRvIHNlZSBpZiBhIGxvY2FsIGRpcmVjdG9yeSBp bmRleCBjYW4gYmUgZGlwbGF5ZWQuIAorQ3VycmVudGx5IHRoaXMgdGVzdCBjYW5ub3QgYmUgcnVu IG1hbnVhbGx5IG9uIFdpbmRvd3MgYmVjYXVzZSB3ZSBkbyBub3QgaGF2ZSBhIGZ1bmN0aW9uIGxp a2UgcGF0aFRvTG9jYWxSZXNvdXJjZSgpIG91dHNpZGUgb2YgRFJULiAKKworUEFTUzogTG9jYWwg ZGlyZWN0b3J5IGxvYWRlZC4KKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xvYWRl ci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvbG9hZGVyL2xvY2FsLWlGcmFtZS1kaXJlY3RvcnktZnJvbS1sb2NhbC5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE3MzMwNDcKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwu aHRtbApAQCAtMCwwICsxLDQ0IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDxzY3JpcHQ+CisgICAg ICAgIGZ1bmN0aW9uIGRpcmVjdG9yeVRlc3QoKSB7CisgICAgICAgICAgICBpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKTsKKworICAgICAgICAgICAgdmFyIGxvY2FsRGlyZWN0b3J5TG9jYXRpb24g PSAiZmlsZTovLy90bXAvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9y eSI7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAg ICAgICAgICAgIGxvY2FsRGlyZWN0b3J5TG9jYXRpb24gPSBsYXlvdXRUZXN0Q29udHJvbGxlci5w YXRoVG9Mb2NhbFJlc291cmNlKGxvY2FsRGlyZWN0b3J5TG9jYXRpb24pOworCisgICAgICAgICAg ICB2YXIgbG9jYWxEaXJlY3RvcnlFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiaWZy YW1lIik7CisgICAgICAgICAgICBsb2NhbERpcmVjdG9yeUVsZW1lbnQuc2V0QXR0cmlidXRlKCJp ZCIsICJteURpcmVjdG9yeSIpOworICAgICAgICAgICAgbG9jYWxEaXJlY3RvcnlFbGVtZW50LnNl dEF0dHJpYnV0ZSgic3JjIiwgbG9jYWxEaXJlY3RvcnlMb2NhdGlvbik7CisgICAgICAgICAgICBs b2NhbERpcmVjdG9yeUVsZW1lbnQuc2V0QXR0cmlidXRlKCJ3aWR0aCIsICI5NiUiKTsKKyAgICAg ICAgICAgIGxvY2FsRGlyZWN0b3J5RWxlbWVudC5zZXRBdHRyaWJ1dGUoImhlaWdodCIsICI3MCUi KTsKKworICAgICAgICAgICAgZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChsb2NhbERpcmVjdG9y eUVsZW1lbnQpOworCisgICAgICAgICAgICB2YXIgcmVzdWx0ID0gZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInJlc3VsdCIpOworCisgICAgICAgICAgICB2YXIgZGlyZWN0b3J5RG9jdW1lbnQgPSAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm15RGlyZWN0b3J5IikuY29udGVudERvY3VtZW50Owor ICAgICAgICAgICAgaWYgKGRpcmVjdG9yeURvY3VtZW50KQorICAgICAgICAgICAgICByZXN1bHQu aW5uZXJIVE1MID0gIlBBU1M6IExvY2FsIGRpcmVjdG9yeSBsb2FkZWQuIjsKKyAgICAgICAgICAg IGVsc2UKKyAgICAgICAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICJGQUlMOiBMb2NhbCBkaXJl Y3RvcnkgY2Fubm90IGJlIGxpc3RlZC4iOworICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keSBvbmxvYWQ9ImRpcmVjdG9yeVRlc3QoKSI+CisgICAgPGRpdiBpZD0iZGl2MCI+ CisgICAgICAgIFRoaXMgdGVzdCBpcyB0byBzZWUgaWYgYSBsb2NhbCBkaXJlY3RvcnkgaW5kZXgg Y2FuIGJlIGRpcGxheWVkLgorICAgICAgICA8YnIvPgorICAgICAgICBDdXJyZW50bHkgdGhpcyB0 ZXN0IGNhbm5vdCBiZSBydW4gbWFudWFsbHkgb24gV2luZG93cyBiZWNhdXNlIHdlIGRvIG5vdCBo YXZlCisgICAgICAgIGEgZnVuY3Rpb24gbGlrZSBwYXRoVG9Mb2NhbFJlc291cmNlKCkgb3V0c2lk ZSBvZiBEUlQuCisgICAgICAgIDxici8+CisgICAgPC9kaXY+CisgICAgPC9icj4KKyAgICA8ZGl2 IGlkPSJyZXN1bHQiPgorICAgICAgICBUZXN0IGhhcyBub3QgcnVuLgorICAgIDwvZGl2PgorICAg IDwvYnI+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xv YWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkgYi9MYXlvdXRUZXN0cy9mYXN0L2xv YWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uN2Q3ZWIzYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zh c3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eQpAQCAtMCwwICsxLDIgQEAK K1RoaXMgZGlyZWN0b3J5IGlzIHVzZWQgYnkgZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVj dG9yeS1mcm9tLWxvY2FsLmh0bWwuCitQbGVhc2UgZG9uJ3QgYWRkIGFueXRoaW5nIGludG8gdGhp cyBkaXJlY3RvcnkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IDkzYjk0MjUuLmNkZDVlYzMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTAtMTEtMDgg IE5pY29sYXMgRHVmcmVzbmUgIDxuaWNvbGFzLmR1ZnJlc25lQGNvbGxhYm9yYS5jby51az4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSByZXNw b25zZS5pc051bGwoKSBhc3NlcnQgd2hlbiB1c2luZyBkaXJlY3RvcnkgZmlsZSBVUkkKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ5MDE4CisKKyAgICAg ICAgV2hlbiB1c2luZyBmaWxlOi8vLyAob3IgYW55IGRpcmVjdG9yeSkgd2UgZ2V0IGFuIGFzc2Vy dGlvbi4KKyAgICAgICAgVGhpcyBpcyBkdWUgdG8gU291cCBiYWNrZW5kIG5vdCBzZW5kaW5nIGEg cHJvcGVyIHJlc3BvbnNlIHByaW9yCisgICAgICAgIHRvIHRoZSBmaXJzdCBkYXRhIGNodW5rLiBU aGlzIHBhdGNoIGVuc3VyZSB0aGF0IGEgcmVzcG9uc2UgaXMKKyAgICAgICAgYWx3YXlzIHNlbnQg cmVnYXJkbGVzcyBvZiB0aGUgcHJvdG9jb2wgYmVpbmcgdXNlZC4KKworICAgICAgICBUZXN0OiBm YXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbAorCisgICAg ICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpzZW5kUmVxdWVzdENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlJl c291cmNlSGFuZGxlOjpzdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpyZWFkQ2FsbGJhY2spOgor CiAyMDEwLTExLTA4ICBDaHJpcyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSdXNzZWxsLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXggMGY5Nzg2Ny4uNTcx YTQ4MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZUhhbmRsZVNvdXAuY3BwCkBAIC01MjYsMjUgKzUyNiw2IEBAIHN0YXRpYyB2b2lkIHNlbmRSZXF1 ZXN0Q2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1bHQqIHJlcywgZ3BvaW50ZXIg dXNlCiAgICAgLy8gcmVhZENhbGxiYWNrIG5lZWRzIGl0CiAgICAgZ19vYmplY3Rfc2V0X2RhdGEo R19PQkpFQ1QoZC0+bV9pbnB1dFN0cmVhbS5nZXQoKSksICJ3ZWJraXQtcmVzb3VyY2UiLCBoYW5k bGUuZ2V0KCkpOwogCi0gICAgLy8gV2UgbmVlZCB0byBjaGVjayBpZiBpdCdzIGEgZmlsZTogVVJM IGFuZCBpZiBpdCBpcyBhIHJlZ3VsYXIKLSAgICAvLyBmaWxlIGFzIGl0IGNvdWxkIGJlIGEgZGly ZWN0b3J5LiBJbiB0aGF0IGNhc2UgU291cCBwcm9wZXJseQotICAgIC8vIHJldHVybnMgYSBzdHJl YW0gd2hvc2UgY29udGVudCBpcyBhIEhUTUwgd2l0aCBhIGxpc3Qgb2YgZmlsZXMKLSAgICAvLyBp biB0aGUgZGlyZWN0b3J5Ci0gICAgaWYgKGVxdWFsSWdub3JpbmdDYXNlKGhhbmRsZS0+Zmlyc3RS ZXF1ZXN0KCkudXJsKCkucHJvdG9jb2woKSwgImZpbGUiKQotICAgICAgICAmJiBHX0lTX0ZJTEVf SU5QVVRfU1RSRUFNKGluKSkgewotICAgICAgICBSZXNvdXJjZVJlc3BvbnNlIHJlc3BvbnNlOwot Ci0gICAgICAgIHJlc3BvbnNlLnNldFVSTChoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpKTsK LSAgICAgICAgcmVzcG9uc2Uuc2V0TWltZVR5cGUod2Via2l0X3NvdXBfcmVxdWVzdF9nZXRfY29u dGVudF90eXBlKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKLSAgICAgICAgcmVzcG9uc2Uuc2V0 RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfbGVu Z3RoKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKLSAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZl UmVzcG9uc2UoaGFuZGxlLmdldCgpLCByZXNwb25zZSk7Ci0KLSAgICAgICAgaWYgKGQtPm1fY2Fu Y2VsbGVkKSB7Ci0gICAgICAgICAgICBjbGVhbnVwU291cFJlcXVlc3RPcGVyYXRpb24oaGFuZGxl LmdldCgpKTsKLSAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotICAgIH0KLQogICAgIGdf aW5wdXRfc3RyZWFtX3JlYWRfYXN5bmMoZC0+bV9pbnB1dFN0cmVhbS5nZXQoKSwgZC0+bV9idWZm ZXIsIFJFQURfQlVGRkVSX1NJWkUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHX1BS SU9SSVRZX0RFRkFVTFQsIGQtPm1fY2FuY2VsbGFibGUuZ2V0KCksIHJlYWRDYWxsYmFjaywgMCk7 CiB9CkBAIC03OTQsNiArNzc1LDIxIEBAIHN0YXRpYyB2b2lkIHJlYWRDYWxsYmFjayhHT2JqZWN0 KiBzb3VyY2UsIEdBc3luY1Jlc3VsdCogYXN5bmNSZXN1bHQsIGdwb2ludGVyIGRhCiAgICAgICAg IHJldHVybjsKICAgICB9CiAKKyAgICAvLyBBdCB0aGlzIHBvaW50LCBpZiB0aGUgcHJvdG9jb2wg aXMgSFRUUCBhIHJlc3BvbnNlIHNob3VsZCBoYXZlCisgICAgLy8gYmVlbiBzZXQsIG90aGVyd2lz ZSB3ZSBuZWVkIHRvIHNlbmQgb25lLgorICAgIGlmIChkLT5tX3Jlc3BvbnNlLmlzTnVsbCgpKSB7 CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJs KCkpOworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtpdF9zb3VwX3JlcXVl c3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGQt Pm1fcmVzcG9uc2Uuc2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHdlYmtpdF9zb3VwX3JlcXVlc3Rf Z2V0X2NvbnRlbnRfbGVuZ3RoKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKKyAgICAgICAgY2xp ZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKKwor ICAgICAgICBpZiAoZC0+bV9jYW5jZWxsZWQpIHsKKyAgICAgICAgICAgIGNsZWFudXBTb3VwUmVx dWVzdE9wZXJhdGlvbihoYW5kbGUuZ2V0KCkpOworICAgICAgICAgICAgLy8gTm8gbmVlZCBmb3Ig cmVhZF9maW5pc2goKSwgR0lPIGlzIHNhZmUgZm9yIHRoYXQKKyAgICAgICAgICAgIHJldHVybjsK KyAgICAgICAgfQorICAgIH0KKwogICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKIAogICAgIGdz c2l6ZSBieXRlc1JlYWQgPSBnX2lucHV0X3N0cmVhbV9yZWFkX2ZpbmlzaChkLT5tX2lucHV0U3Ry ZWFtLmdldCgpLCBhc3luY1Jlc3VsdCwgJmVycm9yLm91dFB0cigpKTsKLS0gCjEuNy4zLjIKCg== 73407 2010-11-09 13:36:46 -0800 2010-11-10 13:51:55 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 8313 nicolas RnJvbSBkMjA1MTMwMWY4ZTFlNjRjNmIwMGE3YTU3YjE4MTIzNWQ0NDAxYjgzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogVHVlLCA5IE5vdiAyMDEwIDEzOjAxOjIxIC0wNTAwClN1Ympl Y3Q6IFtQQVRDSF0gW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGly ZWN0b3J5IGZpbGUgVVJJCgpodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NDkwMTgKCldoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBh c3NlcnRpb24uClRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3Bl ciByZXNwb25zZSBwcmlvcgp0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1 cmUgdGhhdCBhIHJlc3BvbnNlIGlzCmFsd2F5cyBzZW50IHJlZ2FyZGxlc3Mgb2YgdGhlIHByb3Rv Y29sIGJlaW5nIHVzZWQuCi0tLQogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDE0ICsrKysrKwogLi4uL2xvY2FsLWlGcmFtZS1kaXJlY3Rvcnkt ZnJvbS1sb2NhbC1leHBlY3RlZC50eHQgfCAgICA2ICsrKwogLi4uL2xvYWRlci9sb2NhbC1pRnJh bWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbCAgfCAgIDQ0ICsrKysrKysrKysrKysrKysrKysr CiAuLi4vZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5ICAgICB8ICAg IDIgKwogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAgIDE5ICsrKysrKysrCiAuLi4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxl U291cC5jcHAgICB8ICAgMjQgKysrKystLS0tLQogNiBmaWxlcyBjaGFuZ2VkLCA5NyBpbnNlcnRp b25zKCspLCAxMiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9m YXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0 CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1l LWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0 cy9mYXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkKCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggZjQ4 YzM0MS4uZTJmYzlhYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDEwLTExLTA5ICBOaWNvbGFz IER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10gcmVzcG9uc2UuaXNO dWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisgICAgICAgIFdoZW4g dXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpLCBXZWJLaXRHVEsgdXNlIHRvIGFib3J0 IG9uCisgICAgICAgIGFzc2VydGlvbi4gVGhpcyB0ZXN0IGVuc3VyZSB0aGF0IGxvYWRpbmcgYSBk aXJlY3RvcnkgaXMgcG9zc2libGUuCisKKyAgICAgICAgKiBmYXN0L2xvYWRlci9sb2NhbC1pRnJh bWUtZGlyZWN0b3J5LWZyb20tbG9jYWwtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBm YXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbDogQWRkZWQu CisgICAgICAgICogZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5OiBB ZGRlZC4KKwogMjAxMC0xMS0wOSAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBVbnJldmlld2VkIENocm9taXVtIHJlYmFzZWxpbmUuCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9j YWwtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1lLWRp cmVjdG9yeS1mcm9tLWxvY2FsLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5iNGIxMzFlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9s b2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLWV4cGVjdGVkLnR4dApAQCAt MCwwICsxLDYgQEAKK1RoaXMgdGVzdCBpcyB0byBzZWUgaWYgYSBsb2NhbCBkaXJlY3RvcnkgaW5k ZXggY2FuIGJlIGRpcGxheWVkLiAKK0N1cnJlbnRseSB0aGlzIHRlc3QgY2Fubm90IGJlIHJ1biBt YW51YWxseSBvbiBXaW5kb3dzIGJlY2F1c2Ugd2UgZG8gbm90IGhhdmUgYSBmdW5jdGlvbiBsaWtl IHBhdGhUb0xvY2FsUmVzb3VyY2UoKSBvdXRzaWRlIG9mIERSVC4gCisKK1BBU1M6IExvY2FsIGRp cmVjdG9yeSBsb2FkZWQuCisKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIv bG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2xvYWRlci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xNzMzMDQ3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0 bWwKQEAgLTAsMCArMSw0NCBAQAorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0PgorICAgICAg ICBmdW5jdGlvbiBkaXJlY3RvcnlUZXN0KCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KCk7CisKKyAgICAgICAgICAgIHZhciBsb2NhbERpcmVjdG9yeUxvY2F0aW9uID0g ImZpbGU6Ly8vdG1wL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnki OworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAg ICAgICAgICBsb2NhbERpcmVjdG9yeUxvY2F0aW9uID0gbGF5b3V0VGVzdENvbnRyb2xsZXIucGF0 aFRvTG9jYWxSZXNvdXJjZShsb2NhbERpcmVjdG9yeUxvY2F0aW9uKTsKKworICAgICAgICAgICAg dmFyIGxvY2FsRGlyZWN0b3J5RWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImlmcmFt ZSIpOworICAgICAgICAgICAgbG9jYWxEaXJlY3RvcnlFbGVtZW50LnNldEF0dHJpYnV0ZSgiaWQi LCAibXlEaXJlY3RvcnkiKTsKKyAgICAgICAgICAgIGxvY2FsRGlyZWN0b3J5RWxlbWVudC5zZXRB dHRyaWJ1dGUoInNyYyIsIGxvY2FsRGlyZWN0b3J5TG9jYXRpb24pOworICAgICAgICAgICAgbG9j YWxEaXJlY3RvcnlFbGVtZW50LnNldEF0dHJpYnV0ZSgid2lkdGgiLCAiOTYlIik7CisgICAgICAg ICAgICBsb2NhbERpcmVjdG9yeUVsZW1lbnQuc2V0QXR0cmlidXRlKCJoZWlnaHQiLCAiNzAlIik7 CisKKyAgICAgICAgICAgIGRvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQobG9jYWxEaXJlY3RvcnlF bGVtZW50KTsKKworICAgICAgICAgICAgdmFyIHJlc3VsdCA9IGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJyZXN1bHQiKTsKKworICAgICAgICAgICAgdmFyIGRpcmVjdG9yeURvY3VtZW50ID0gIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJteURpcmVjdG9yeSIpLmNvbnRlbnREb2N1bWVudDsKKyAg ICAgICAgICAgIGlmIChkaXJlY3RvcnlEb2N1bWVudCkKKyAgICAgICAgICAgICAgcmVzdWx0Lmlu bmVySFRNTCA9ICJQQVNTOiBMb2NhbCBkaXJlY3RvcnkgbG9hZGVkLiI7CisgICAgICAgICAgICBl bHNlCisgICAgICAgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAiRkFJTDogTG9jYWwgZGlyZWN0 b3J5IGNhbm5vdCBiZSBsaXN0ZWQuIjsKKyAgICAgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFk PgorPGJvZHkgb25sb2FkPSJkaXJlY3RvcnlUZXN0KCkiPgorICAgIDxkaXYgaWQ9ImRpdjAiPgor ICAgICAgICBUaGlzIHRlc3QgaXMgdG8gc2VlIGlmIGEgbG9jYWwgZGlyZWN0b3J5IGluZGV4IGNh biBiZSBkaXBsYXllZC4KKyAgICAgICAgPGJyLz4KKyAgICAgICAgQ3VycmVudGx5IHRoaXMgdGVz dCBjYW5ub3QgYmUgcnVuIG1hbnVhbGx5IG9uIFdpbmRvd3MgYmVjYXVzZSB3ZSBkbyBub3QgaGF2 ZQorICAgICAgICBhIGZ1bmN0aW9uIGxpa2UgcGF0aFRvTG9jYWxSZXNvdXJjZSgpIG91dHNpZGUg b2YgRFJULgorICAgICAgICA8YnIvPgorICAgIDwvZGl2PgorICAgIDwvYnI+CisgICAgPGRpdiBp ZD0icmVzdWx0Ij4KKyAgICAgICAgVGVzdCBoYXMgbm90IHJ1bi4KKyAgICA8L2Rpdj4KKyAgICA8 L2JyPgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sb2Fk ZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5IGIvTGF5b3V0VGVzdHMvZmFzdC9sb2Fk ZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjdkN2ViM2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkKQEAgLTAsMCArMSwyIEBACitU aGlzIGRpcmVjdG9yeSBpcyB1c2VkIGJ5IGZhc3QvbG9hZGVyL2xvY2FsLWlGcmFtZS1kaXJlY3Rv cnktZnJvbS1sb2NhbC5odG1sLgorUGxlYXNlIGRvbid0IGFkZCBhbnl0aGluZyBpbnRvIHRoaXMg ZGlyZWN0b3J5LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5n ZUxvZwppbmRleCA1NmQ4YTdjLi4yYmIxNWMzIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxv ZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEwLTExLTA5ICBO aWNvbGFzIER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10gcmVzcG9u c2UuaXNOdWxsKCkgYXNzZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisgICAgICAg IFdoZW4gdXNpbmcgZmlsZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBhc3NlcnRp b24uCisgICAgICAgIFRoaXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHBy b3BlciByZXNwb25zZSBwcmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhp cyBwYXRjaCBlbnN1cmUgdGhhdCBhIHJlc3BvbnNlIGlzCisgICAgICAgIHNlbnQgZm9yIHByb3Rv Y29sIHRoYXQgZG9lcyBub3QgZW1pdCBnb3QtaGVhZGVycyBzaWduYWwuCisKKyAgICAgICAgVGVz dDogZmFzdC9sb2FkZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwKKwor ICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6c2VuZFJlcXVlc3RDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3Jl OjpSZXNvdXJjZUhhbmRsZTo6c3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6cmVhZENhbGxiYWNr KToKKwogMjAxMC0xMS0wOSAgU3RldmUgQmxvY2sgIDxzdGV2ZWJsb2NrQGdvb2dsZS5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgQW5kcmVhcyBLbGluZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDBmOTc4Njcu LjIyOTUzOGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtNTI2LDE4ICs1MjYsMTUgQEAgc3RhdGljIHZvaWQgc2Vu ZFJlcXVlc3RDYWxsYmFjayhHT2JqZWN0KiBzb3VyY2UsIEdBc3luY1Jlc3VsdCogcmVzLCBncG9p bnRlciB1c2UKICAgICAvLyByZWFkQ2FsbGJhY2sgbmVlZHMgaXQKICAgICBnX29iamVjdF9zZXRf ZGF0YShHX09CSkVDVChkLT5tX2lucHV0U3RyZWFtLmdldCgpKSwgIndlYmtpdC1yZXNvdXJjZSIs IGhhbmRsZS5nZXQoKSk7CiAKLSAgICAvLyBXZSBuZWVkIHRvIGNoZWNrIGlmIGl0J3MgYSBmaWxl OiBVUkwgYW5kIGlmIGl0IGlzIGEgcmVndWxhcgotICAgIC8vIGZpbGUgYXMgaXQgY291bGQgYmUg YSBkaXJlY3RvcnkuIEluIHRoYXQgY2FzZSBTb3VwIHByb3Blcmx5Ci0gICAgLy8gcmV0dXJucyBh IHN0cmVhbSB3aG9zZSBjb250ZW50IGlzIGEgSFRNTCB3aXRoIGEgbGlzdCBvZiBmaWxlcwotICAg IC8vIGluIHRoZSBkaXJlY3RvcnkKLSAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UoaGFuZGxlLT5m aXJzdFJlcXVlc3QoKS51cmwoKS5wcm90b2NvbCgpLCAiZmlsZSIpCi0gICAgICAgICYmIEdfSVNf RklMRV9JTlBVVF9TVFJFQU0oaW4pKSB7Ci0gICAgICAgIFJlc291cmNlUmVzcG9uc2UgcmVzcG9u c2U7Ci0KLSAgICAgICAgcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJs KCkpOwotICAgICAgICByZXNwb25zZS5zZXRNaW1lVHlwZSh3ZWJraXRfc291cF9yZXF1ZXN0X2dl dF9jb250ZW50X3R5cGUoZC0+bV9zb3VwUmVxdWVzdC5nZXQoKSkpOwotICAgICAgICByZXNwb25z ZS5zZXRFeHBlY3RlZENvbnRlbnRMZW5ndGgod2Via2l0X3NvdXBfcmVxdWVzdF9nZXRfY29udGVu dF9sZW5ndGgoZC0+bV9zb3VwUmVxdWVzdC5nZXQoKSkpOwotICAgICAgICBjbGllbnQtPmRpZFJl Y2VpdmVSZXNwb25zZShoYW5kbGUuZ2V0KCksIHJlc3BvbnNlKTsKKyAgICAvLyBFbnN1cmUgYSBy ZXNwb25zZSBmb3IgcHJvdG9jb2wgdXNpbmcgR0lPLgorICAgIFN0cmluZyBwcm90b2NvbCA9IGhh bmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkucHJvdG9jb2woKTsKKyAgICBpZiAoZXF1YWxJZ25v cmluZ0Nhc2UocHJvdG9jb2wsICJmaWxlIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2ws ICJmdHAiKSB8fCBlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZ0cHMiKSkgeworICAgICAg ICBBU1NFUlQoZC0+bV9yZXNwb25zZS5pc051bGwoKSk7CisKKyAgICAgICAgZC0+bV9yZXNwb25z ZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJlcXVlc3QoKS51cmwoKSk7CisgICAgICAgIGQtPm1fcmVz cG9uc2Uuc2V0TWltZVR5cGUod2Via2l0X3NvdXBfcmVxdWVzdF9nZXRfY29udGVudF90eXBlKGQt Pm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKKyAgICAgICAgZC0+bV9yZXNwb25zZS5zZXRFeHBlY3Rl ZENvbnRlbnRMZW5ndGgod2Via2l0X3NvdXBfcmVxdWVzdF9nZXRfY29udGVudF9sZW5ndGgoZC0+ bV9zb3VwUmVxdWVzdC5nZXQoKSkpOworICAgICAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25z ZShoYW5kbGUuZ2V0KCksIGQtPm1fcmVzcG9uc2UpOwogCiAgICAgICAgIGlmIChkLT5tX2NhbmNl bGxlZCkgewogICAgICAgICAgICAgY2xlYW51cFNvdXBSZXF1ZXN0T3BlcmF0aW9uKGhhbmRsZS5n ZXQoKSk7CkBAIC03ODksNiArNzg2LDkgQEAgc3RhdGljIHZvaWQgcmVhZENhbGxiYWNrKEdPYmpl Y3QqIHNvdXJjZSwgR0FzeW5jUmVzdWx0KiBhc3luY1Jlc3VsdCwgZ3BvaW50ZXIgZGEKICAgICBS ZXNvdXJjZUhhbmRsZUludGVybmFsKiBkID0gaGFuZGxlLT5nZXRJbnRlcm5hbCgpOwogICAgIFJl c291cmNlSGFuZGxlQ2xpZW50KiBjbGllbnQgPSBoYW5kbGUtPmNsaWVudCgpOwogCisgICAgLy8g SXQncyBtYW5kYXRvcnkgdG8gaGF2ZSBzZW50IGEgcmVzcG9uc2UgYmVmb3JlIHNlbmRpbmcgZGF0 YQorICAgIEFTU0VSVCghZC0+bV9yZXNwb25zZS5pc051bGwoKSk7CisKICAgICBpZiAoZC0+bV9j YW5jZWxsZWQgfHwgIWNsaWVudCkgewogICAgICAgICBjbGVhbnVwU291cFJlcXVlc3RPcGVyYXRp b24oaGFuZGxlLmdldCgpKTsKICAgICAgICAgcmV0dXJuOwotLSAKMS43LjMuMgoK 73535 2010-11-10 13:51:55 -0800 2010-11-17 14:01:59 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 9489 nicolas RnJvbSBmNGU1YzI1ZTg1ODdiYjcwYjA3NTZlNGZkZjRmYTkyNmZkNGU3Y2I5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogV2VkLCAxMCBOb3YgMjAxMCAxNjoyNjozMSAtMDUwMApTdWJq ZWN0OiBbUEFUQ0hdIFtHVEtdIHJlc3BvbnNlLmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRp cmVjdG9yeSBmaWxlIFVSSQoKaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTQ5MDE4CgpXaGVuIHVzaW5nIGZpbGU6Ly8vIChvciBhbnkgZGlyZWN0b3J5KSB3ZSBnZXQgYW4g YXNzZXJ0aW9uLgpUaGlzIGlzIGR1ZSB0byBTb3VwIGJhY2tlbmQgbm90IHNlbmRpbmcgYSBwcm9w ZXIgcmVzcG9uc2UgcHJpb3IKdG8gdGhlIGZpcnN0IGRhdGEgY2h1bmsuIFRoaXMgcGF0Y2ggZW5z dXJlIHRoYXQgYSByZXNwb25zZSBpcwphbHdheXMgc2VudCByZWdhcmRsZXNzIG9mIHRoZSBwcm90 b2NvbCBiZWluZyB1c2VkLgotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAxNCArKysrKysrCiAuLi4vY3Jhc2gtZGlzcGxheS1sb2NhbC1k aXJlY3RvcnktZXhwZWN0ZWQudHh0ICAgICB8ICAgIDUgKysKIC4uLi9mYXN0L2xvYWRlci9jcmFz aC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sIHwgICAyNiArKysrKysrKysrKysKIC4uLi9m YXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkgICAgIHwgICAgMiArCiBX ZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjEg KysrKysrKysrKwogLi4uL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAu Y3BwICAgfCAgIDQxICsrKysrKysrKysrLS0tLS0tLS0KIDYgZmlsZXMgY2hhbmdlZCwgOTIgaW5z ZXJ0aW9ucygrKSwgMTcgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVz dHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnktZXhwZWN0ZWQudHh0 CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxh eS1sb2NhbC1kaXJlY3RvcnkuaHRtbAogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL2Zh c3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eQoKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAzODJmMWQ3 Li4xOGViMThjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTAtMTEtMTAgIE5pY29sYXMgRHVm cmVzbmUgIDxuaWNvbGFzLmR1ZnJlc25lQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSByZXNwb25zZS5pc051bGwo KSBhc3NlcnQgd2hlbiB1c2luZyBkaXJlY3RvcnkgZmlsZSBVUkkKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ5MDE4CisKKyAgICAgICAgV2hlbiB1c2lu ZyBmaWxlOi8vLyAob3IgYW55IGRpcmVjdG9yeSksIFdlYktpdEdUSyB1c2UgdG8gYWJvcnQgb24K KyAgICAgICAgYXNzZXJ0aW9uLiBUaGlzIHRlc3QgZW5zdXJlIHRoYXQgbG9hZGluZyBhIGRpcmVj dG9yeSBpcyBwb3NzaWJsZS4KKworICAgICAgICAqIGZhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXkt bG9jYWwtZGlyZWN0b3J5LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9sb2Fk ZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnkuaHRtbDogQWRkZWQuCisgICAgICAgICog ZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5OiBBZGRlZC4KKwogMjAx MC0xMS0xMCAgTWloYWkgUGFycGFyaXRhICA8bWloYWlwQGNocm9taXVtLm9yZz4KIAogICAgICAg ICBVbnJldml3ZWQsIHVwZGF0aW5nIENocm9taXVtIEdQVSB0ZXN0IGV4cGVjdGF0aW9ucy4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9jYWwtZGly ZWN0b3J5LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3Bs YXktbG9jYWwtZGlyZWN0b3J5LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5jNTRlYjVlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9s b2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnktZXhwZWN0ZWQudHh0CkBAIC0wLDAg KzEsNSBAQAorVGhpcyB0ZXN0IGlzIHRvIHNlZSBpZiBhIGxvY2FsIGRpcmVjdG9yeSBpbmRleCBj YW4gYmUgZGlwbGF5ZWQuCisKK1BBU1M6IExvY2FsIGRpcmVjdG9yeSBsb2FkZWQuCisKKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJl Y3RvcnkuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9jYWwt ZGlyZWN0b3J5Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2ZhMGNi OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3Bs YXktbG9jYWwtZGlyZWN0b3J5Lmh0bWwKQEAgLTAsMCArMSwyNiBAQAorPGh0bWw+Cis8aGVhZD4K KyAgICA8dGl0bGU+VGVzdCBjcmFzaCBvbiBkaXJlY3RvcnkgZGlzcGxheTwvdGl0bGU+CisgICAg PHNjcmlwdD4KKyAgICAgICAgZnVuY3Rpb24gZGlyZWN0b3J5VGVzdCgpIHsKKyAgICAgICAgICAg IGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCisgICAgICAgICAgICB2YXIgcmVzdWx0ID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdCIpOworCisgICAgICAgICAgICB2YXIgZGly ZWN0b3J5RG9jdW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibXlEaXJlY3RvcnkiKS5j b250ZW50RG9jdW1lbnQ7CisgICAgICAgICAgICBpZiAoZGlyZWN0b3J5RG9jdW1lbnQpCisgICAg ICAgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAiUEFTUzogTG9jYWwgZGlyZWN0b3J5IGxvYWRl ZC4iOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICByZXN1bHQuaW5uZXJIVE1MID0g IkZBSUw6IExvY2FsIGRpcmVjdG9yeSBjYW5ub3QgYmUgbGlzdGVkLiI7CisgICAgICAgIH0KKyAg ICA8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorICAgIDxwPlRoaXMgdGVzdCBpcyB0byBzZWUg aWYgYSBsb2NhbCBkaXJlY3RvcnkgaW5kZXggY2FuIGJlIGRpcGxheWVkLjwvcD4KKyAgICA8cCBp ZD0icmVzdWx0Ij4KKyAgICAgICAgVGVzdCBoYXMgbm90IHJ1bi4KKyAgICA8L3A+CisgICAgPGlm cmFtZSBpZD0ibXlEaXJlY3RvcnkiIHNyYz0icmVzb3VyY2VzL2RpcmVjdG9yeSIgd2lkdGg9IjYw MHB4IiBoZWlnaHQ9IjQwMHB4IiBvbmxvYWQ9ImRpcmVjdG9yeVRlc3QoKSIvPgorPC9ib2R5Pgor PC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2Rp cmVjdG9yeS9rZWVwLWVtcHR5IGIvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2Rp cmVjdG9yeS9rZWVwLWVtcHR5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdk N2ViM2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9yZXNvdXJj ZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkKQEAgLTAsMCArMSwyIEBACitUaGlzIGRpcmVjdG9yeSBp cyB1c2VkIGJ5IGZhc3QvbG9hZGVyL2xvY2FsLWlGcmFtZS1kaXJlY3RvcnktZnJvbS1sb2NhbC5o dG1sLgorUGxlYXNlIGRvbid0IGFkZCBhbnl0aGluZyBpbnRvIHRoaXMgZGlyZWN0b3J5LgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwNGE4 ZjNmLi4wYTI3MGI5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3Jl L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEwLTExLTEwICBOaWNvbGFzIER1ZnJlc25l ICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10gcmVzcG9uc2UuaXNOdWxsKCkgYXNz ZXJ0IHdoZW4gdXNpbmcgZGlyZWN0b3J5IGZpbGUgVVJJCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00OTAxOAorCisgICAgICAgIFdoZW4gdXNpbmcgZmls ZTovLy8gKG9yIGFueSBkaXJlY3RvcnkpIHdlIGdldCBhbiBhc3NlcnRpb24uCisgICAgICAgIFRo aXMgaXMgZHVlIHRvIFNvdXAgYmFja2VuZCBub3Qgc2VuZGluZyBhIHByb3BlciByZXNwb25zZSBw cmlvcgorICAgICAgICB0byB0aGUgZmlyc3QgZGF0YSBjaHVuay4gVGhpcyBwYXRjaCBlbnN1cmUg dGhhdCBhIHJlc3BvbnNlIGlzCisgICAgICAgIHNlbnQgZm9yIHByb3RvY29sIHRoYXQgZG9lcyBu b3QgZW1pdCBnb3QtaGVhZGVycyBzaWduYWwuCisKKyAgICAgICAgVGVzdDogZmFzdC9sb2FkZXIv Y3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnkuaHRtbAorCisgICAgICAgICogcGxhdGZvcm0v bmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpn b3RIZWFkZXJzQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6Y29udGVudFNuaWZmZWRDYWxs YmFjayk6CisgICAgICAgIChXZWJDb3JlOjpwYXJzZURhdGFVcmwpOgorICAgICAgICAoV2ViQ29y ZTo6c2VuZFJlcXVlc3RDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpyZWFkQ2FsbGJhY2sp OgorCiAyMDEwLTExLTEwICBBbGV4YW5kZXIgUGF2bG92ICA8YXBhdmxvdkBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgWXVyeSBTZW1pa2hhdHNreS4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDBm OTc4NjcuLmFjNzZmZGUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtMjQ1LDYgKzI0NSw4IEBAIHN0YXRpYyB2b2lk IGdvdEhlYWRlcnNDYWxsYmFjayhTb3VwTWVzc2FnZSogbXNnLCBncG9pbnRlciBkYXRhKQogICAg IGlmICghY2xpZW50KQogICAgICAgICByZXR1cm47CiAKKyAgICBBU1NFUlQoZC0+bV9yZXNwb25z ZS5pc051bGwoKSk7CisKICAgICBmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZShtc2csICZkLT5tX3Jl c3BvbnNlKTsKICAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUuZ2V0KCksIGQt Pm1fcmVzcG9uc2UpOwogfQpAQCAtMjcyLDYgKzI3NCw4IEBAIHN0YXRpYyB2b2lkIGNvbnRlbnRT bmlmZmVkQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgY29uc3QgY2hhciogc25pZmZlZFR5cGUs IEdICiAgICAgaWYgKCFjbGllbnQpCiAgICAgICAgIHJldHVybjsKIAorICAgIEFTU0VSVChkLT5t X3Jlc3BvbnNlLmlzTnVsbCgpKTsKKwogICAgIGZpbGxSZXNwb25zZUZyb21NZXNzYWdlKG1zZywg JmQtPm1fcmVzcG9uc2UpOwogICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5n ZXQoKSwgZC0+bV9yZXNwb25zZSk7CiB9CkBAIC0yOTEsNiArMjk1LDggQEAgc3RhdGljIHZvaWQg Z290Q2h1bmtDYWxsYmFjayhTb3VwTWVzc2FnZSogbXNnLCBTb3VwQnVmZmVyKiBjaHVuaywgZ3Bv aW50ZXIgZGF0YSkKICAgICBpZiAoIWNsaWVudCkKICAgICAgICAgcmV0dXJuOwogCisgICAgQVNT RVJUKCFkLT5tX3Jlc3BvbnNlLmlzTnVsbCgpKTsKKwogICAgIGNsaWVudC0+ZGlkUmVjZWl2ZURh dGEoaGFuZGxlLmdldCgpLCBjaHVuay0+ZGF0YSwgY2h1bmstPmxlbmd0aCwgZmFsc2UpOwogfQog CkBAIC0zMjksMTQgKzMzNSwxNSBAQCBzdGF0aWMgZ2Jvb2xlYW4gcGFyc2VEYXRhVXJsKGdwb2lu dGVyIGNhbGxiYWNrRGF0YSkKICAgICBTdHJpbmcgbWltZVR5cGUgPSBleHRyYWN0TUlNRVR5cGVG cm9tTWVkaWFUeXBlKG1lZGlhVHlwZSk7CiAgICAgU3RyaW5nIGNoYXJzZXQgPSBleHRyYWN0Q2hh cnNldEZyb21NZWRpYVR5cGUobWVkaWFUeXBlKTsKIAotICAgIFJlc291cmNlUmVzcG9uc2UgcmVz cG9uc2U7Ci0gICAgcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkp OwotICAgIHJlc3BvbnNlLnNldE1pbWVUeXBlKG1pbWVUeXBlKTsKKyAgICBBU1NFUlQoZC0+bV9y ZXNwb25zZS5pc051bGwoKSk7CisKKyAgICBkLT5tX3Jlc3BvbnNlLnNldFVSTChoYW5kbGUtPmZp cnN0UmVxdWVzdCgpLnVybCgpKTsKKyAgICBkLT5tX3Jlc3BvbnNlLnNldE1pbWVUeXBlKG1pbWVU eXBlKTsKIAogICAgIC8vIEZvciBub24gYmFzZTY0IGVuY29kZWQgZGF0YSB3ZSBoYXZlIHRvIGNv bnZlcnQgdG8gVVRGLTE2IGVhcmx5CiAgICAgLy8gZHVlIHRvIGxpbWl0YXRpb25zIGluIEtVUkwK LSAgICByZXNwb25zZS5zZXRUZXh0RW5jb2RpbmdOYW1lKGlzQmFzZTY0ID8gY2hhcnNldCA6ICJV VEYtMTYiKTsKLSAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUsIHJlc3BvbnNl KTsKKyAgICBkLT5tX3Jlc3BvbnNlLnNldFRleHRFbmNvZGluZ05hbWUoaXNCYXNlNjQgPyBjaGFy c2V0IDogIlVURi0xNiIpOworICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZSwg ZC0+bV9yZXNwb25zZSk7CiAKICAgICAvLyBUaGUgbG9hZCBtYXkgYmUgY2FuY2VsbGVkLCBhbmQg dGhlIGNsaWVudCBtYXkgYmUgZGVzdHJveWVkCiAgICAgLy8gYnkgYW55IG9mIHRoZSBjbGllbnQg cmVwb3J0aW5nIGNhbGxzLCBzbyB3ZSBjaGVjaywgYW5kIGJhaWwKQEAgLTQ5Niw2ICs1MDMsOCBA QCBzdGF0aWMgdm9pZCBzZW5kUmVxdWVzdENhbGxiYWNrKEdPYmplY3QqIHNvdXJjZSwgR0FzeW5j UmVzdWx0KiByZXMsIGdwb2ludGVyIHVzZQogICAgICAgICB9CiAKICAgICAgICAgaWYgKGQtPm1f c291cE1lc3NhZ2UgJiYgc3RhdHVzV2lsbEJlSGFuZGxlZEJ5U291cChkLT5tX3NvdXBNZXNzYWdl LT5zdGF0dXNfY29kZSkpIHsKKyAgICAgICAgICAgIEFTU0VSVChkLT5tX3Jlc3BvbnNlLmlzTnVs bCgpKTsKKwogICAgICAgICAgICAgZmlsbFJlc3BvbnNlRnJvbU1lc3NhZ2Uoc291cE1zZywgJmQt Pm1fcmVzcG9uc2UpOwogICAgICAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFu ZGxlLmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKIApAQCAtNTI2LDE4ICs1MzUsMTMgQEAgc3RhdGlj IHZvaWQgc2VuZFJlcXVlc3RDYWxsYmFjayhHT2JqZWN0KiBzb3VyY2UsIEdBc3luY1Jlc3VsdCog cmVzLCBncG9pbnRlciB1c2UKICAgICAvLyByZWFkQ2FsbGJhY2sgbmVlZHMgaXQKICAgICBnX29i amVjdF9zZXRfZGF0YShHX09CSkVDVChkLT5tX2lucHV0U3RyZWFtLmdldCgpKSwgIndlYmtpdC1y ZXNvdXJjZSIsIGhhbmRsZS5nZXQoKSk7CiAKLSAgICAvLyBXZSBuZWVkIHRvIGNoZWNrIGlmIGl0 J3MgYSBmaWxlOiBVUkwgYW5kIGlmIGl0IGlzIGEgcmVndWxhcgotICAgIC8vIGZpbGUgYXMgaXQg Y291bGQgYmUgYSBkaXJlY3RvcnkuIEluIHRoYXQgY2FzZSBTb3VwIHByb3Blcmx5Ci0gICAgLy8g cmV0dXJucyBhIHN0cmVhbSB3aG9zZSBjb250ZW50IGlzIGEgSFRNTCB3aXRoIGEgbGlzdCBvZiBm aWxlcwotICAgIC8vIGluIHRoZSBkaXJlY3RvcnkKLSAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2Uo aGFuZGxlLT5maXJzdFJlcXVlc3QoKS51cmwoKS5wcm90b2NvbCgpLCAiZmlsZSIpCi0gICAgICAg ICYmIEdfSVNfRklMRV9JTlBVVF9TVFJFQU0oaW4pKSB7Ci0gICAgICAgIFJlc291cmNlUmVzcG9u c2UgcmVzcG9uc2U7Ci0KLSAgICAgICAgcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RSZXF1 ZXN0KCkudXJsKCkpOwotICAgICAgICByZXNwb25zZS5zZXRNaW1lVHlwZSh3ZWJraXRfc291cF9y ZXF1ZXN0X2dldF9jb250ZW50X3R5cGUoZC0+bV9zb3VwUmVxdWVzdC5nZXQoKSkpOwotICAgICAg ICByZXNwb25zZS5zZXRFeHBlY3RlZENvbnRlbnRMZW5ndGgod2Via2l0X3NvdXBfcmVxdWVzdF9n ZXRfY29udGVudF9sZW5ndGgoZC0+bV9zb3VwUmVxdWVzdC5nZXQoKSkpOwotICAgICAgICBjbGll bnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUuZ2V0KCksIHJlc3BvbnNlKTsKKyAgICAvLyBF bnN1cmUgYSByZXNwb25zZSBmb3IgcHJvdG9jb2wgdXNpbmcgR0lPLgorICAgIFN0cmluZyBwcm90 b2NvbCA9IGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkucHJvdG9jb2woKTsKKyAgICBpZiAo IWhhbmRsZS0+c2hvdWxkQ29udGVudFNuaWZmKCkgJiYgZC0+bV9yZXNwb25zZS5pc051bGwoKSkg eworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldFVSTChoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVy bCgpKTsKKyAgICAgICAgZC0+bV9yZXNwb25zZS5zZXRNaW1lVHlwZSh3ZWJraXRfc291cF9yZXF1 ZXN0X2dldF9jb250ZW50X3R5cGUoZC0+bV9zb3VwUmVxdWVzdC5nZXQoKSkpOworICAgICAgICBk LT5tX3Jlc3BvbnNlLnNldEV4cGVjdGVkQ29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0 X2dldF9jb250ZW50X2xlbmd0aChkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGNs aWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwgZC0+bV9yZXNwb25zZSk7CiAK ICAgICAgICAgaWYgKGQtPm1fY2FuY2VsbGVkKSB7CiAgICAgICAgICAgICBjbGVhbnVwU291cFJl cXVlc3RPcGVyYXRpb24oaGFuZGxlLmdldCgpKTsKQEAgLTgxMyw2ICs4MTcsOSBAQCBzdGF0aWMg dm9pZCByZWFkQ2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1bHQqIGFzeW5jUmVz dWx0LCBncG9pbnRlciBkYQogICAgICAgICByZXR1cm47CiAgICAgfQogCisgICAgLy8gSXQncyBt YW5kYXRvcnkgdG8gaGF2ZSBzZW50IGEgcmVzcG9uc2UgYmVmb3JlIHNlbmRpbmcgZGF0YQorICAg IEFTU0VSVCghZC0+bV9yZXNwb25zZS5pc051bGwoKSk7CisKICAgICBkLT5tX3RvdGFsICs9IGJ5 dGVzUmVhZDsKICAgICBpZiAoR19MSUtFTFkoIWNvbnZlcnRUb1VURjE2KSkKICAgICAgICAgY2xp ZW50LT5kaWRSZWNlaXZlRGF0YShoYW5kbGUuZ2V0KCksIGQtPm1fYnVmZmVyLCBieXRlc1JlYWQs IGQtPm1fdG90YWwpOwotLSAKMS43LjMuMgoK 74152 2010-11-17 14:01:59 -0800 2010-11-23 07:50:36 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 9461 nicolas RnJvbSBlMzYxNWI4ZWMwZTNmZTljNzFlNTdmNGM1Yjg0MGUxZWUwZWQ2YjM1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogV2VkLCAxMCBOb3YgMjAxMCAxNjoyNjozMSAtMDUwMApTdWJq ZWN0OiBbUEFUQ0hdIFtHVEtdIHJlc3BvbnNlLmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRp cmVjdG9yeSBmaWxlIFVSSQoKaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTQ5MDE4CgpEbyBlbnN1cmUgdGhhdCBkaWRSZWNlaXZlUmVzcG9uc2UgaGFwcGVucyBiZWZvcmUg YW55IGNhbGwgdG8KZGlkUmVjZWl2ZURhdGEuIFRoYXQgd2FzIG5vdCB0cnVlIGZvciBmaWxlOi8v IFVSSXMgcG9pbnRpbmcgdG8KZGlyZWN0b3JpZXMgYW5kIHRodXMgd2FzIHRyaWdnZXJpbmcgYW4g YXNzZXJ0aW9uLgotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAxNCArKysrKysKIC4uLi9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9y eS1leHBlY3RlZC50eHQgICAgIHwgICAgNSArKwogLi4uL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3Bs YXktbG9jYWwtZGlyZWN0b3J5Lmh0bWwgfCAgIDI2ICsrKysrKysrKysrKwogLi4uL2Zhc3QvbG9h ZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eSAgICAgfCAgICAyICsKIFdlYkNvcmUv Q2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyMCArKysrKysr KysKIC4uLi9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCAgIHwg ICA0MyArKysrKysrKysrKystLS0tLS0tLQogNiBmaWxlcyBjaGFuZ2VkLCA5MyBpbnNlcnRpb25z KCspLCAxNyBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9mYXN0 L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS1leHBlY3RlZC50eHQKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2Fs LWRpcmVjdG9yeS5odG1sCiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9sb2Fk ZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5CgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGI2NzQ1OGIuLjE4N2M3 NmEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxNyBAQAorMjAxMC0xMS0xNyAgTmljb2xhcyBEdWZyZXNuZSAg PG5pY29sYXMuZHVmcmVzbmVAY29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHVEtdIHJlc3BvbnNlLmlzTnVsbCgpIGFzc2Vy dCB3aGVuIHVzaW5nIGRpcmVjdG9yeSBmaWxlIFVSSQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDkwMTgKKworICAgICAgICBXaGVuIHVzaW5nIGZpbGU6 Ly8vIChvciBhbnkgZGlyZWN0b3J5KSwgV2ViS2l0R1RLIHVzZSB0byBhYm9ydCBvbgorICAgICAg ICBhc3NlcnRpb24uIFRoaXMgdGVzdCBlbnN1cmUgdGhhdCBsb2FkaW5nIGEgZGlyZWN0b3J5IGlz IHBvc3NpYmxlLgorCisgICAgICAgICogZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1k aXJlY3RvcnktZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xvYWRlci9jcmFz aC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2xv YWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHk6IEFkZGVkLgorCiAyMDEwLTExLTE1 ICBBbmR5IEVzdGVzICA8YWVzdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnNraXAgZmFzdC9m b3Jtcy9zdWJtaXQtZm9ybS1hdHRyaWJ1dGVzLmh0bWwuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzU0ZWI1ZQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXkt bG9jYWwtZGlyZWN0b3J5LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDUgQEAKK1RoaXMgdGVzdCBp cyB0byBzZWUgaWYgYSBsb2NhbCBkaXJlY3RvcnkgaW5kZXggY2FuIGJlIGRpcGxheWVkLgorCitQ QVNTOiBMb2NhbCBkaXJlY3RvcnkgbG9hZGVkLgorCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9jYWwtZGlyZWN0b3J5Lmh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdmYTBjYjkKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5o dG1sCkBAIC0wLDAgKzEsMjYgQEAKKzxodG1sPgorPGhlYWQ+CisgICAgPHRpdGxlPlRlc3QgY3Jh c2ggb24gZGlyZWN0b3J5IGRpc3BsYXk8L3RpdGxlPgorICAgIDxzY3JpcHQ+CisgICAgICAgIGZ1 bmN0aW9uIGRpcmVjdG9yeVRlc3QoKSB7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKKworICAgICAgICAgICAgdmFyIHJlc3VsdCA9IGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJyZXN1bHQiKTsKKworICAgICAgICAgICAgdmFyIGRpcmVjdG9yeURvY3VtZW50ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm15RGlyZWN0b3J5IikuY29udGVudERvY3VtZW50OworICAg ICAgICAgICAgaWYgKGRpcmVjdG9yeURvY3VtZW50KQorICAgICAgICAgICAgICByZXN1bHQuaW5u ZXJIVE1MID0gIlBBU1M6IExvY2FsIGRpcmVjdG9yeSBsb2FkZWQuIjsKKyAgICAgICAgICAgIGVs c2UKKyAgICAgICAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICJGQUlMOiBMb2NhbCBkaXJlY3Rv cnkgY2Fubm90IGJlIGxpc3RlZC4iOworICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+ Cis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgaXMgdG8gc2VlIGlmIGEgbG9jYWwgZGlyZWN0b3J5 IGluZGV4IGNhbiBiZSBkaXBsYXllZC48L3A+CisgICAgPHAgaWQ9InJlc3VsdCI+CisgICAgICAg IFRlc3QgaGFzIG5vdCBydW4uCisgICAgPC9wPgorICAgIDxpZnJhbWUgaWQ9Im15RGlyZWN0b3J5 IiBzcmM9InJlc291cmNlcy9kaXJlY3RvcnkiIHdpZHRoPSI2MDBweCIgaGVpZ2h0PSI0MDBweCIg b25sb2FkPSJkaXJlY3RvcnlUZXN0KCkiLz4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eSBi L0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eQpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZDdlYjNiCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVt cHR5CkBAIC0wLDAgKzEsMiBAQAorVGhpcyBkaXJlY3RvcnkgaXMgdXNlZCBieSBmYXN0L2xvYWRl ci9sb2NhbC1pRnJhbWUtZGlyZWN0b3J5LWZyb20tbG9jYWwuaHRtbC4KK1BsZWFzZSBkb24ndCBh ZGQgYW55dGhpbmcgaW50byB0aGlzIGRpcmVjdG9yeS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hh bmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDllNjZiYy4uOGVkMjBhZiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyMyBAQAorMjAxMC0xMS0xNyAgTmljb2xhcyBEdWZyZXNuZSAgPG5pY29sYXMuZHVmcmVzbmVA Y29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFtHVEtdIHJlc3BvbnNlLmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRpcmVj dG9yeSBmaWxlIFVSSQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NDkwMTgKKworICAgICAgICBEbyBlbnN1cmUgdGhhdCBkaWRSZWNlaXZlUmVzcG9uc2Ug aGFwcGVucyBiZWZvcmUgYW55IGNhbGwgdG8KKyAgICAgICAgZGlkUmVjZWl2ZURhdGEuIFRoYXQg d2FzIG5vdCB0cnVlIGZvciBmaWxlOi8vIFVSSXMgcG9pbnRpbmcgdG8KKyAgICAgICAgZGlyZWN0 b3JpZXMgYW5kIHRodXMgd2FzIHRyaWdnZXJpbmcgYW4gYXNzZXJ0aW9uLgorCisgICAgICAgIFRl c3Q6IGZhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9jYWwtZGlyZWN0b3J5Lmh0bWwKKworICAg ICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6Z290SGVhZGVyc0NhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OmNv bnRlbnRTbmlmZmVkQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6cGFyc2VEYXRhVXJsKToK KyAgICAgICAgKFdlYkNvcmU6OnNlbmRSZXF1ZXN0Q2FsbGJhY2spOgorICAgICAgICAoV2ViQ29y ZTo6cmVhZENhbGxiYWNrKToKKwogMjAxMC0xMS0xNSAgQmV0aCBEYWtpbiAgPGJkYWtpbkBhcHBs ZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCAw Zjk3ODY3Li5jNjg5ODZjIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKQEAgLTI0NSw2ICsyNDUsOCBAQCBzdGF0aWMgdm9p ZCBnb3RIZWFkZXJzQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGF0YSkKICAg ICBpZiAoIWNsaWVudCkKICAgICAgICAgcmV0dXJuOwogCisgICAgQVNTRVJUKGQtPm1fcmVzcG9u c2UuaXNOdWxsKCkpOworCiAgICAgZmlsbFJlc3BvbnNlRnJvbU1lc3NhZ2UobXNnLCAmZC0+bV9y ZXNwb25zZSk7CiAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCBk LT5tX3Jlc3BvbnNlKTsKIH0KQEAgLTI3Miw2ICsyNzQsOCBAQCBzdGF0aWMgdm9pZCBjb250ZW50 U25pZmZlZENhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIGNvbnN0IGNoYXIqIHNuaWZmZWRUeXBl LCBHSAogICAgIGlmICghY2xpZW50KQogICAgICAgICByZXR1cm47CiAKKyAgICBBU1NFUlQoZC0+ bV9yZXNwb25zZS5pc051bGwoKSk7CisKICAgICBmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZShtc2cs ICZkLT5tX3Jlc3BvbnNlKTsKICAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUu Z2V0KCksIGQtPm1fcmVzcG9uc2UpOwogfQpAQCAtMjkxLDYgKzI5NSw4IEBAIHN0YXRpYyB2b2lk IGdvdENodW5rQ2FsbGJhY2soU291cE1lc3NhZ2UqIG1zZywgU291cEJ1ZmZlciogY2h1bmssIGdw b2ludGVyIGRhdGEpCiAgICAgaWYgKCFjbGllbnQpCiAgICAgICAgIHJldHVybjsKIAorICAgIEFT U0VSVCghZC0+bV9yZXNwb25zZS5pc051bGwoKSk7CisKICAgICBjbGllbnQtPmRpZFJlY2VpdmVE YXRhKGhhbmRsZS5nZXQoKSwgY2h1bmstPmRhdGEsIGNodW5rLT5sZW5ndGgsIGZhbHNlKTsKIH0K IApAQCAtMzI5LDE0ICszMzUsMTUgQEAgc3RhdGljIGdib29sZWFuIHBhcnNlRGF0YVVybChncG9p bnRlciBjYWxsYmFja0RhdGEpCiAgICAgU3RyaW5nIG1pbWVUeXBlID0gZXh0cmFjdE1JTUVUeXBl RnJvbU1lZGlhVHlwZShtZWRpYVR5cGUpOwogICAgIFN0cmluZyBjaGFyc2V0ID0gZXh0cmFjdENo YXJzZXRGcm9tTWVkaWFUeXBlKG1lZGlhVHlwZSk7CiAKLSAgICBSZXNvdXJjZVJlc3BvbnNlIHJl c3BvbnNlOwotICAgIHJlc3BvbnNlLnNldFVSTChoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgp KTsKLSAgICByZXNwb25zZS5zZXRNaW1lVHlwZShtaW1lVHlwZSk7CisgICAgQVNTRVJUKGQtPm1f cmVzcG9uc2UuaXNOdWxsKCkpOworCisgICAgZC0+bV9yZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5m aXJzdFJlcXVlc3QoKS51cmwoKSk7CisgICAgZC0+bV9yZXNwb25zZS5zZXRNaW1lVHlwZShtaW1l VHlwZSk7CiAKICAgICAvLyBGb3Igbm9uIGJhc2U2NCBlbmNvZGVkIGRhdGEgd2UgaGF2ZSB0byBj b252ZXJ0IHRvIFVURi0xNiBlYXJseQogICAgIC8vIGR1ZSB0byBsaW1pdGF0aW9ucyBpbiBLVVJM Ci0gICAgcmVzcG9uc2Uuc2V0VGV4dEVuY29kaW5nTmFtZShpc0Jhc2U2NCA/IGNoYXJzZXQgOiAi VVRGLTE2Iik7Ci0gICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLCByZXNwb25z ZSk7CisgICAgZC0+bV9yZXNwb25zZS5zZXRUZXh0RW5jb2RpbmdOYW1lKGlzQmFzZTY0ID8gY2hh cnNldCA6ICJVVEYtMTYiKTsKKyAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUs IGQtPm1fcmVzcG9uc2UpOwogCiAgICAgLy8gVGhlIGxvYWQgbWF5IGJlIGNhbmNlbGxlZCwgYW5k IHRoZSBjbGllbnQgbWF5IGJlIGRlc3Ryb3llZAogICAgIC8vIGJ5IGFueSBvZiB0aGUgY2xpZW50 IHJlcG9ydGluZyBjYWxscywgc28gd2UgY2hlY2ssIGFuZCBiYWlsCkBAIC00OTYsNiArNTAzLDgg QEAgc3RhdGljIHZvaWQgc2VuZFJlcXVlc3RDYWxsYmFjayhHT2JqZWN0KiBzb3VyY2UsIEdBc3lu Y1Jlc3VsdCogcmVzLCBncG9pbnRlciB1c2UKICAgICAgICAgfQogCiAgICAgICAgIGlmIChkLT5t X3NvdXBNZXNzYWdlICYmIHN0YXR1c1dpbGxCZUhhbmRsZWRCeVNvdXAoZC0+bV9zb3VwTWVzc2Fn ZS0+c3RhdHVzX2NvZGUpKSB7CisgICAgICAgICAgICBBU1NFUlQoZC0+bV9yZXNwb25zZS5pc051 bGwoKSk7CisKICAgICAgICAgICAgIGZpbGxSZXNwb25zZUZyb21NZXNzYWdlKHNvdXBNc2csICZk LT5tX3Jlc3BvbnNlKTsKICAgICAgICAgICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhh bmRsZS5nZXQoKSwgZC0+bV9yZXNwb25zZSk7CiAKQEAgLTUyNiwxOCArNTM1LDE1IEBAIHN0YXRp YyB2b2lkIHNlbmRSZXF1ZXN0Q2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1bHQq IHJlcywgZ3BvaW50ZXIgdXNlCiAgICAgLy8gcmVhZENhbGxiYWNrIG5lZWRzIGl0CiAgICAgZ19v YmplY3Rfc2V0X2RhdGEoR19PQkpFQ1QoZC0+bV9pbnB1dFN0cmVhbS5nZXQoKSksICJ3ZWJraXQt cmVzb3VyY2UiLCBoYW5kbGUuZ2V0KCkpOwogCi0gICAgLy8gV2UgbmVlZCB0byBjaGVjayBpZiBp dCdzIGEgZmlsZTogVVJMIGFuZCBpZiBpdCBpcyBhIHJlZ3VsYXIKLSAgICAvLyBmaWxlIGFzIGl0 IGNvdWxkIGJlIGEgZGlyZWN0b3J5LiBJbiB0aGF0IGNhc2UgU291cCBwcm9wZXJseQotICAgIC8v IHJldHVybnMgYSBzdHJlYW0gd2hvc2UgY29udGVudCBpcyBhIEhUTUwgd2l0aCBhIGxpc3Qgb2Yg ZmlsZXMKLSAgICAvLyBpbiB0aGUgZGlyZWN0b3J5Ci0gICAgaWYgKGVxdWFsSWdub3JpbmdDYXNl KGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkucHJvdG9jb2woKSwgImZpbGUiKQotICAgICAg ICAmJiBHX0lTX0ZJTEVfSU5QVVRfU1RSRUFNKGluKSkgewotICAgICAgICBSZXNvdXJjZVJlc3Bv bnNlIHJlc3BvbnNlOwotCi0gICAgICAgIHJlc3BvbnNlLnNldFVSTChoYW5kbGUtPmZpcnN0UmVx dWVzdCgpLnVybCgpKTsKLSAgICAgICAgcmVzcG9uc2Uuc2V0TWltZVR5cGUod2Via2l0X3NvdXBf cmVxdWVzdF9nZXRfY29udGVudF90eXBlKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKLSAgICAg ICAgcmVzcG9uc2Uuc2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHdlYmtpdF9zb3VwX3JlcXVlc3Rf Z2V0X2NvbnRlbnRfbGVuZ3RoKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsKLSAgICAgICAgY2xp ZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCByZXNwb25zZSk7CisgICAgLy8g RW5zdXJlIGEgcmVzcG9uc2UgaXMgc2VudCBmb3IgYW55IHByb3RvY29scyB0aGF0IGRvbid0IGV4 cGxpY2l0bHkgc3VwcG9ydCByZXNwb25zZXMKKyAgICAvLyB0aHJvdWdoIGdvdC1oZWFkZXJzIHNp Z25hbCBvciBjb250ZW50IHNuaWZmaW5nLgorICAgIC8vIChlLmcuIGZpbGUgYW5kIEdJTyBiYXNl ZCBwcm90b2NvbCkuCisgICAgU3RyaW5nIHByb3RvY29sID0gaGFuZGxlLT5maXJzdFJlcXVlc3Qo KS51cmwoKS5wcm90b2NvbCgpOworICAgIGlmICghaGFuZGxlLT5zaG91bGRDb250ZW50U25pZmYo KSAmJiBkLT5tX3Jlc3BvbnNlLmlzTnVsbCgpKSB7CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0 VVJMKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkpOworICAgICAgICBkLT5tX3Jlc3BvbnNl LnNldE1pbWVUeXBlKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3Nv dXBSZXF1ZXN0LmdldCgpKSk7CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0RXhwZWN0ZWRDb250 ZW50TGVuZ3RoKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfbGVuZ3RoKGQtPm1fc291 cFJlcXVlc3QuZ2V0KCkpKTsKKyAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFu ZGxlLmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKIAogICAgICAgICBpZiAoZC0+bV9jYW5jZWxsZWQp IHsKICAgICAgICAgICAgIGNsZWFudXBTb3VwUmVxdWVzdE9wZXJhdGlvbihoYW5kbGUuZ2V0KCkp OwpAQCAtODEzLDYgKzgxOSw5IEBAIHN0YXRpYyB2b2lkIHJlYWRDYWxsYmFjayhHT2JqZWN0KiBz b3VyY2UsIEdBc3luY1Jlc3VsdCogYXN5bmNSZXN1bHQsIGdwb2ludGVyIGRhCiAgICAgICAgIHJl dHVybjsKICAgICB9CiAKKyAgICAvLyBJdCdzIG1hbmRhdG9yeSB0byBoYXZlIHNlbnQgYSByZXNw b25zZSBiZWZvcmUgc2VuZGluZyBkYXRhCisgICAgQVNTRVJUKCFkLT5tX3Jlc3BvbnNlLmlzTnVs bCgpKTsKKwogICAgIGQtPm1fdG90YWwgKz0gYnl0ZXNSZWFkOwogICAgIGlmIChHX0xJS0VMWSgh Y29udmVydFRvVVRGMTYpKQogICAgICAgICBjbGllbnQtPmRpZFJlY2VpdmVEYXRhKGhhbmRsZS5n ZXQoKSwgZC0+bV9idWZmZXIsIGJ5dGVzUmVhZCwgZC0+bV90b3RhbCk7Ci0tIAoxLjcuMy4yCgo= 74663 2010-11-23 07:50:36 -0800 2010-11-24 11:23:44 -0800 Fix assert using directory file URI 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 9398 nicolas RnJvbSAwMjI2MTFlZmY5Njc4MmNhMmQ4MjAyMjIzZjIyY2FhMGIxMzk0YzRkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogV2VkLCAxMCBOb3YgMjAxMCAxNjoyNjozMSAtMDUwMApTdWJq ZWN0OiBbUEFUQ0hdIFtHVEtdIHJlc3BvbnNlLmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRp cmVjdG9yeSBmaWxlIFVSSQoKaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTQ5MDE4CgpEbyBlbnN1cmUgdGhhdCBkaWRSZWNlaXZlUmVzcG9uc2UgaGFwcGVucyBiZWZvcmUg YW55IGNhbGwgdG8KZGlkUmVjZWl2ZURhdGEuIFRoYXQgd2FzIG5vdCB0cnVlIGZvciBmaWxlOi8v IFVSSXMgcG9pbnRpbmcgdG8KZGlyZWN0b3JpZXMgYW5kIHRodXMgd2FzIHRyaWdnZXJpbmcgYW4g YXNzZXJ0aW9uLgotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAxNCArKysrKysrCiAuLi4vY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3Rv cnktZXhwZWN0ZWQudHh0ICAgICB8ICAgIDUgKysKIC4uLi9mYXN0L2xvYWRlci9jcmFzaC1kaXNw bGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sIHwgICAyNiArKysrKysrKysrKysKIC4uLi9mYXN0L2xv YWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkgICAgIHwgICAgMiArCiBXZWJDb3Jl L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjAgKysrKysr KysrCiAuLi4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgICB8 ICAgNDIgKysrKysrKysrKysrLS0tLS0tLS0KIDYgZmlsZXMgY2hhbmdlZCwgOTIgaW5zZXJ0aW9u cygrKSwgMTcgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFz dC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnktZXhwZWN0ZWQudHh0CiBjcmVh dGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2Nh bC1kaXJlY3RvcnkuaHRtbAogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL2Zhc3QvbG9h ZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eQoKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiNjc0NThiLi4xODdj NzZhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTAtMTEtMTcgIE5pY29sYXMgRHVmcmVzbmUg IDxuaWNvbGFzLmR1ZnJlc25lQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSByZXNwb25zZS5pc051bGwoKSBhc3Nl cnQgd2hlbiB1c2luZyBkaXJlY3RvcnkgZmlsZSBVUkkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ5MDE4CisKKyAgICAgICAgV2hlbiB1c2luZyBmaWxl Oi8vLyAob3IgYW55IGRpcmVjdG9yeSksIFdlYktpdEdUSyB1c2UgdG8gYWJvcnQgb24KKyAgICAg ICAgYXNzZXJ0aW9uLiBUaGlzIHRlc3QgZW5zdXJlIHRoYXQgbG9hZGluZyBhIGRpcmVjdG9yeSBp cyBwb3NzaWJsZS4KKworICAgICAgICAqIGZhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9jYWwt ZGlyZWN0b3J5LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9sb2FkZXIvY3Jh c2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnkuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9s b2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5OiBBZGRlZC4KKwogMjAxMC0xMS0x NSAgQW5keSBFc3RlcyAgPGFlc3Rlc0BhcHBsZS5jb20+CiAKICAgICAgICAgVW5za2lwIGZhc3Qv Zm9ybXMvc3VibWl0LWZvcm0tYXR0cmlidXRlcy5odG1sLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnktZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3Rvcnkt ZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM1NGViNWUK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5 LWxvY2FsLWRpcmVjdG9yeS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw1IEBACitUaGlzIHRlc3Qg aXMgdG8gc2VlIGlmIGEgbG9jYWwgZGlyZWN0b3J5IGluZGV4IGNhbiBiZSBkaXBsYXllZC4KKwor UEFTUzogTG9jYWwgZGlyZWN0b3J5IGxvYWRlZC4KKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnkuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZmEwY2I5Ci0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3Rvcnku aHRtbApAQCAtMCwwICsxLDI2IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDx0aXRsZT5UZXN0IGNy YXNoIG9uIGRpcmVjdG9yeSBkaXNwbGF5PC90aXRsZT4KKyAgICA8c2NyaXB0PgorICAgICAgICBm dW5jdGlvbiBkaXJlY3RvcnlUZXN0KCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisKKyAgICAgICAgICAgIHZhciByZXN1bHQgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgicmVzdWx0Iik7CisKKyAgICAgICAgICAgIHZhciBkaXJlY3RvcnlEb2N1bWVudCA9IGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJteURpcmVjdG9yeSIpLmNvbnRlbnREb2N1bWVudDsKKyAg ICAgICAgICAgIGlmIChkaXJlY3RvcnlEb2N1bWVudCkKKyAgICAgICAgICAgICAgcmVzdWx0Lmlu bmVySFRNTCA9ICJQQVNTOiBMb2NhbCBkaXJlY3RvcnkgbG9hZGVkLiI7CisgICAgICAgICAgICBl bHNlCisgICAgICAgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAiRkFJTDogTG9jYWwgZGlyZWN0 b3J5IGNhbm5vdCBiZSBsaXN0ZWQuIjsKKyAgICAgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFk PgorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IGlzIHRvIHNlZSBpZiBhIGxvY2FsIGRpcmVjdG9y eSBpbmRleCBjYW4gYmUgZGlwbGF5ZWQuPC9wPgorICAgIDxwIGlkPSJyZXN1bHQiPgorICAgICAg ICBUZXN0IGhhcyBub3QgcnVuLgorICAgIDwvcD4KKyAgICA8aWZyYW1lIGlkPSJteURpcmVjdG9y eSIgc3JjPSJyZXNvdXJjZXMvZGlyZWN0b3J5IiB3aWR0aD0iNjAwcHgiIGhlaWdodD0iNDAwcHgi IG9ubG9hZD0iZGlyZWN0b3J5VGVzdCgpIi8+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkg Yi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9yZXNvdXJjZXMvZGlyZWN0b3J5L2tlZXAtZW1wdHkK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2Q3ZWIzYgotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkva2VlcC1l bXB0eQpAQCAtMCwwICsxLDIgQEAKK1RoaXMgZGlyZWN0b3J5IGlzIHVzZWQgYnkgZmFzdC9sb2Fk ZXIvbG9jYWwtaUZyYW1lLWRpcmVjdG9yeS1mcm9tLWxvY2FsLmh0bWwuCitQbGVhc2UgZG9uJ3Qg YWRkIGFueXRoaW5nIGludG8gdGhpcyBkaXJlY3RvcnkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL0No YW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDA5ZTY2YmMuLjhlZDIwYWYgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMjMgQEAKKzIwMTAtMTEtMTcgIE5pY29sYXMgRHVmcmVzbmUgIDxuaWNvbGFzLmR1ZnJlc25l QGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBbR1RLXSByZXNwb25zZS5pc051bGwoKSBhc3NlcnQgd2hlbiB1c2luZyBkaXJl Y3RvcnkgZmlsZSBVUkkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQ5MDE4CisKKyAgICAgICAgRG8gZW5zdXJlIHRoYXQgZGlkUmVjZWl2ZVJlc3BvbnNl IGhhcHBlbnMgYmVmb3JlIGFueSBjYWxsIHRvCisgICAgICAgIGRpZFJlY2VpdmVEYXRhLiBUaGF0 IHdhcyBub3QgdHJ1ZSBmb3IgZmlsZTovLyBVUklzIHBvaW50aW5nIHRvCisgICAgICAgIGRpcmVj dG9yaWVzIGFuZCB0aHVzIHdhcyB0cmlnZ2VyaW5nIGFuIGFzc2VydGlvbi4KKworICAgICAgICBU ZXN0OiBmYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OmdvdEhlYWRlcnNDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpj b250ZW50U25pZmZlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnBhcnNlRGF0YVVybCk6 CisgICAgICAgIChXZWJDb3JlOjpzZW5kUmVxdWVzdENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNv cmU6OnJlYWRDYWxsYmFjayk6CisKIDIwMTAtMTEtMTUgIEJldGggRGFraW4gIDxiZGFraW5AYXBw bGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXgg MGY5Nzg2Ny4uZTU3OGE4ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0yNDUsNiArMjQ1LDggQEAgc3RhdGljIHZv aWQgZ290SGVhZGVyc0NhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIGdwb2ludGVyIGRhdGEpCiAg ICAgaWYgKCFjbGllbnQpCiAgICAgICAgIHJldHVybjsKIAorICAgIEFTU0VSVChkLT5tX3Jlc3Bv bnNlLmlzTnVsbCgpKTsKKwogICAgIGZpbGxSZXNwb25zZUZyb21NZXNzYWdlKG1zZywgJmQtPm1f cmVzcG9uc2UpOwogICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwg ZC0+bV9yZXNwb25zZSk7CiB9CkBAIC0yNzIsNiArMjc0LDggQEAgc3RhdGljIHZvaWQgY29udGVu dFNuaWZmZWRDYWxsYmFjayhTb3VwTWVzc2FnZSogbXNnLCBjb25zdCBjaGFyKiBzbmlmZmVkVHlw ZSwgR0gKICAgICBpZiAoIWNsaWVudCkKICAgICAgICAgcmV0dXJuOwogCisgICAgQVNTRVJUKGQt Pm1fcmVzcG9uc2UuaXNOdWxsKCkpOworCiAgICAgZmlsbFJlc3BvbnNlRnJvbU1lc3NhZ2UobXNn LCAmZC0+bV9yZXNwb25zZSk7CiAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxl LmdldCgpLCBkLT5tX3Jlc3BvbnNlKTsKIH0KQEAgLTI5MSw2ICsyOTUsOCBAQCBzdGF0aWMgdm9p ZCBnb3RDaHVua0NhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIFNvdXBCdWZmZXIqIGNodW5rLCBn cG9pbnRlciBkYXRhKQogICAgIGlmICghY2xpZW50KQogICAgICAgICByZXR1cm47CiAKKyAgICBB U1NFUlQoIWQtPm1fcmVzcG9uc2UuaXNOdWxsKCkpOworCiAgICAgY2xpZW50LT5kaWRSZWNlaXZl RGF0YShoYW5kbGUuZ2V0KCksIGNodW5rLT5kYXRhLCBjaHVuay0+bGVuZ3RoLCBmYWxzZSk7CiB9 CiAKQEAgLTMyOSwxNCArMzM1LDE1IEBAIHN0YXRpYyBnYm9vbGVhbiBwYXJzZURhdGFVcmwoZ3Bv aW50ZXIgY2FsbGJhY2tEYXRhKQogICAgIFN0cmluZyBtaW1lVHlwZSA9IGV4dHJhY3RNSU1FVHlw ZUZyb21NZWRpYVR5cGUobWVkaWFUeXBlKTsKICAgICBTdHJpbmcgY2hhcnNldCA9IGV4dHJhY3RD aGFyc2V0RnJvbU1lZGlhVHlwZShtZWRpYVR5cGUpOwogCi0gICAgUmVzb3VyY2VSZXNwb25zZSBy ZXNwb25zZTsKLSAgICByZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJlcXVlc3QoKS51cmwo KSk7Ci0gICAgcmVzcG9uc2Uuc2V0TWltZVR5cGUobWltZVR5cGUpOworICAgIEFTU0VSVChkLT5t X3Jlc3BvbnNlLmlzTnVsbCgpKTsKKworICAgIGQtPm1fcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+ Zmlyc3RSZXF1ZXN0KCkudXJsKCkpOworICAgIGQtPm1fcmVzcG9uc2Uuc2V0TWltZVR5cGUobWlt ZVR5cGUpOwogCiAgICAgLy8gRm9yIG5vbiBiYXNlNjQgZW5jb2RlZCBkYXRhIHdlIGhhdmUgdG8g Y29udmVydCB0byBVVEYtMTYgZWFybHkKICAgICAvLyBkdWUgdG8gbGltaXRhdGlvbnMgaW4gS1VS TAotICAgIHJlc3BvbnNlLnNldFRleHRFbmNvZGluZ05hbWUoaXNCYXNlNjQgPyBjaGFyc2V0IDog IlVURi0xNiIpOwotICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZSwgcmVzcG9u c2UpOworICAgIGQtPm1fcmVzcG9uc2Uuc2V0VGV4dEVuY29kaW5nTmFtZShpc0Jhc2U2NCA/IGNo YXJzZXQgOiAiVVRGLTE2Iik7CisgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxl LCBkLT5tX3Jlc3BvbnNlKTsKIAogICAgIC8vIFRoZSBsb2FkIG1heSBiZSBjYW5jZWxsZWQsIGFu ZCB0aGUgY2xpZW50IG1heSBiZSBkZXN0cm95ZWQKICAgICAvLyBieSBhbnkgb2YgdGhlIGNsaWVu dCByZXBvcnRpbmcgY2FsbHMsIHNvIHdlIGNoZWNrLCBhbmQgYmFpbApAQCAtNDk2LDYgKzUwMyw4 IEBAIHN0YXRpYyB2b2lkIHNlbmRSZXF1ZXN0Q2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5 bmNSZXN1bHQqIHJlcywgZ3BvaW50ZXIgdXNlCiAgICAgICAgIH0KIAogICAgICAgICBpZiAoZC0+ bV9zb3VwTWVzc2FnZSAmJiBzdGF0dXNXaWxsQmVIYW5kbGVkQnlTb3VwKGQtPm1fc291cE1lc3Nh Z2UtPnN0YXR1c19jb2RlKSkgeworICAgICAgICAgICAgQVNTRVJUKGQtPm1fcmVzcG9uc2UuaXNO dWxsKCkpOworCiAgICAgICAgICAgICBmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZShzb3VwTXNnLCAm ZC0+bV9yZXNwb25zZSk7CiAgICAgICAgICAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZSho YW5kbGUuZ2V0KCksIGQtPm1fcmVzcG9uc2UpOwogCkBAIC01MjYsMTggKzUzNSwxNCBAQCBzdGF0 aWMgdm9pZCBzZW5kUmVxdWVzdENhbGxiYWNrKEdPYmplY3QqIHNvdXJjZSwgR0FzeW5jUmVzdWx0 KiByZXMsIGdwb2ludGVyIHVzZQogICAgIC8vIHJlYWRDYWxsYmFjayBuZWVkcyBpdAogICAgIGdf b2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCkpLCAid2Via2l0 LXJlc291cmNlIiwgaGFuZGxlLmdldCgpKTsKIAotICAgIC8vIFdlIG5lZWQgdG8gY2hlY2sgaWYg aXQncyBhIGZpbGU6IFVSTCBhbmQgaWYgaXQgaXMgYSByZWd1bGFyCi0gICAgLy8gZmlsZSBhcyBp dCBjb3VsZCBiZSBhIGRpcmVjdG9yeS4gSW4gdGhhdCBjYXNlIFNvdXAgcHJvcGVybHkKLSAgICAv LyByZXR1cm5zIGEgc3RyZWFtIHdob3NlIGNvbnRlbnQgaXMgYSBIVE1MIHdpdGggYSBsaXN0IG9m IGZpbGVzCi0gICAgLy8gaW4gdGhlIGRpcmVjdG9yeQotICAgIGlmIChlcXVhbElnbm9yaW5nQ2Fz ZShoYW5kbGUtPmZpcnN0UmVxdWVzdCgpLnVybCgpLnByb3RvY29sKCksICJmaWxlIikKLSAgICAg ICAgJiYgR19JU19GSUxFX0lOUFVUX1NUUkVBTShpbikpIHsKLSAgICAgICAgUmVzb3VyY2VSZXNw b25zZSByZXNwb25zZTsKLQotICAgICAgICByZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJl cXVlc3QoKS51cmwoKSk7Ci0gICAgICAgIHJlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtpdF9zb3Vw X3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAg ICAgIHJlc3BvbnNlLnNldEV4cGVjdGVkQ29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0 X2dldF9jb250ZW50X2xlbmd0aChkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAgICAgIGNs aWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwgcmVzcG9uc2UpOworICAgIC8v IEVuc3VyZSBhIHJlc3BvbnNlIGlzIHNlbnQgZm9yIGFueSBwcm90b2NvbHMgdGhhdCBkb24ndCBl eHBsaWNpdGx5IHN1cHBvcnQgcmVzcG9uc2VzCisgICAgLy8gdGhyb3VnaCBnb3QtaGVhZGVycyBz aWduYWwgb3IgY29udGVudCBzbmlmZmluZy4KKyAgICAvLyAoZS5nLiBmaWxlIGFuZCBHSU8gYmFz ZWQgcHJvdG9jb2wpLgorICAgIGlmICghaGFuZGxlLT5zaG91bGRDb250ZW50U25pZmYoKSAmJiBk LT5tX3Jlc3BvbnNlLmlzTnVsbCgpKSB7CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0VVJMKGhh bmRsZS0+Zmlyc3RSZXF1ZXN0KCkudXJsKCkpOworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldE1p bWVUeXBlKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1 ZXN0LmdldCgpKSk7CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0RXhwZWN0ZWRDb250ZW50TGVu Z3RoKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfbGVuZ3RoKGQtPm1fc291cFJlcXVl c3QuZ2V0KCkpKTsKKyAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdl dCgpLCBkLT5tX3Jlc3BvbnNlKTsKIAogICAgICAgICBpZiAoZC0+bV9jYW5jZWxsZWQpIHsKICAg ICAgICAgICAgIGNsZWFudXBTb3VwUmVxdWVzdE9wZXJhdGlvbihoYW5kbGUuZ2V0KCkpOwpAQCAt ODEzLDYgKzgxOCw5IEBAIHN0YXRpYyB2b2lkIHJlYWRDYWxsYmFjayhHT2JqZWN0KiBzb3VyY2Us IEdBc3luY1Jlc3VsdCogYXN5bmNSZXN1bHQsIGdwb2ludGVyIGRhCiAgICAgICAgIHJldHVybjsK ICAgICB9CiAKKyAgICAvLyBJdCdzIG1hbmRhdG9yeSB0byBoYXZlIHNlbnQgYSByZXNwb25zZSBi ZWZvcmUgc2VuZGluZyBkYXRhCisgICAgQVNTRVJUKCFkLT5tX3Jlc3BvbnNlLmlzTnVsbCgpKTsK KwogICAgIGQtPm1fdG90YWwgKz0gYnl0ZXNSZWFkOwogICAgIGlmIChHX0xJS0VMWSghY29udmVy dFRvVVRGMTYpKQogICAgICAgICBjbGllbnQtPmRpZFJlY2VpdmVEYXRhKGhhbmRsZS5nZXQoKSwg ZC0+bV9idWZmZXIsIGJ5dGVzUmVhZCwgZC0+bV90b3RhbCk7Ci0tIAoxLjcuMy4yCgo= 74782 2010-11-24 11:23:44 -0800 2010-11-24 12:02:54 -0800 Same patch but with test moved to GTK platform test 0001-GTK-response.isNull-assert-when-using-directory-file.patch text/plain 9614 nicolas RnJvbSBjMGQ1NWI4YTQ4NmJmMzBhNjEwMzMyMzQ5Y2FkNDcyNTYyZTJmODlhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBOaWNvbGFzIER1ZnJlc25lIDxuaWNvbGFzLmR1ZnJlc25lQGNv bGxhYm9yYS5jby51az4KRGF0ZTogV2VkLCAxMCBOb3YgMjAxMCAxNjoyNjozMSAtMDUwMApTdWJq ZWN0OiBbUEFUQ0hdIFtHVEtdIHJlc3BvbnNlLmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRp cmVjdG9yeSBmaWxlIFVSSQoKaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTQ5MDE4CgpEbyBlbnN1cmUgdGhhdCBkaWRSZWNlaXZlUmVzcG9uc2UgaGFwcGVucyBiZWZvcmUg YW55IGNhbGwgdG8KZGlkUmVjZWl2ZURhdGEuIFRoYXQgd2FzIG5vdCB0cnVlIGZvciBmaWxlOi8v IFVSSXMgcG9pbnRpbmcgdG8KZGlyZWN0b3JpZXMgYW5kIHRodXMgd2FzIHRyaWdnZXJpbmcgYW4g YXNzZXJ0aW9uLgotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAxNCArKysrKysrCiAuLi4vY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3Rv cnktZXhwZWN0ZWQudHh0ICAgICB8ICAgIDUgKysKIC4uLi9mYXN0L2xvYWRlci9jcmFzaC1kaXNw bGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sIHwgICAyNiArKysrKysrKysrKysKIC4uLi9ndGsvZmFz dC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5IHwgICAgMiArCiBXZWJDb3Jl L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjAgKysrKysr KysrCiAuLi4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgICB8 ICAgNDIgKysrKysrKysrKysrLS0tLS0tLS0KIDYgZmlsZXMgY2hhbmdlZCwgOTIgaW5zZXJ0aW9u cygrKSwgMTcgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvcGxh dGZvcm0vZ3RrL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9jYWwtZGlyZWN0b3J5LWV4cGVj dGVkLnR4dAogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9mYXN0 L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sCiBjcmVhdGUgbW9kZSAx MDA2NDQgTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJl Y3Rvcnkva2VlcC1lbXB0eQoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiNjc0NThiLi5kODI3YWU0IDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTcgQEAKKzIwMTAtMTEtMTcgIE5pY29sYXMgRHVmcmVzbmUgIDxuaWNvbGFzLmR1ZnJlc25l QGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBbR1RLXSByZXNwb25zZS5pc051bGwoKSBhc3NlcnQgd2hlbiB1c2luZyBkaXJl Y3RvcnkgZmlsZSBVUkkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQ5MDE4CisKKyAgICAgICAgV2hlbiB1c2luZyBmaWxlOi8vLyAob3IgYW55IGRpcmVj dG9yeSksIFdlYktpdEdUSyB1c2UgdG8gYWJvcnQgb24KKyAgICAgICAgYXNzZXJ0aW9uLiBUaGlz IHRlc3QgZW5zdXJlIHRoYXQgbG9hZGluZyBhIGRpcmVjdG9yeSBpcyBwb3NzaWJsZS4KKworICAg ICAgICAqIHBsYXRmb3JtL2d0ay9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVj dG9yeS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9mYXN0L2xv YWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBwbGF0Zm9ybS9ndGsvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5 OiBBZGRlZC4KKwogMjAxMC0xMS0xNSAgQW5keSBFc3RlcyAgPGFlc3Rlc0BhcHBsZS5jb20+CiAK ICAgICAgICAgVW5za2lwIGZhc3QvZm9ybXMvc3VibWl0LWZvcm0tYXR0cmlidXRlcy5odG1sLgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Zhc3QvbG9hZGVyL2NyYXNoLWRp c3BsYXktbG9jYWwtZGlyZWN0b3J5LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3Jt L2d0ay9mYXN0L2xvYWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzU0ZWI1ZQotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9mYXN0L2xvYWRlci9jcmFzaC1kaXNw bGF5LWxvY2FsLWRpcmVjdG9yeS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw1IEBACitUaGlzIHRl c3QgaXMgdG8gc2VlIGlmIGEgbG9jYWwgZGlyZWN0b3J5IGluZGV4IGNhbiBiZSBkaXBsYXllZC4K KworUEFTUzogTG9jYWwgZGlyZWN0b3J5IGxvYWRlZC4KKworCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9ndGsvZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3Rv cnkuaHRtbCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9mYXN0L2xvYWRlci9jcmFzaC1kaXNw bGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjdmYTBjYjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsv ZmFzdC9sb2FkZXIvY3Jhc2gtZGlzcGxheS1sb2NhbC1kaXJlY3RvcnkuaHRtbApAQCAtMCwwICsx LDI2IEBACis8aHRtbD4KKzxoZWFkPgorICAgIDx0aXRsZT5UZXN0IGNyYXNoIG9uIGRpcmVjdG9y eSBkaXNwbGF5PC90aXRsZT4KKyAgICA8c2NyaXB0PgorICAgICAgICBmdW5jdGlvbiBkaXJlY3Rv cnlUZXN0KCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKKyAg ICAgICAgICAgIHZhciByZXN1bHQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0Iik7 CisKKyAgICAgICAgICAgIHZhciBkaXJlY3RvcnlEb2N1bWVudCA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJteURpcmVjdG9yeSIpLmNvbnRlbnREb2N1bWVudDsKKyAgICAgICAgICAgIGlmIChk aXJlY3RvcnlEb2N1bWVudCkKKyAgICAgICAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICJQQVNT OiBMb2NhbCBkaXJlY3RvcnkgbG9hZGVkLiI7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAg ICAgIHJlc3VsdC5pbm5lckhUTUwgPSAiRkFJTDogTG9jYWwgZGlyZWN0b3J5IGNhbm5vdCBiZSBs aXN0ZWQuIjsKKyAgICAgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CisgICAg PHA+VGhpcyB0ZXN0IGlzIHRvIHNlZSBpZiBhIGxvY2FsIGRpcmVjdG9yeSBpbmRleCBjYW4gYmUg ZGlwbGF5ZWQuPC9wPgorICAgIDxwIGlkPSJyZXN1bHQiPgorICAgICAgICBUZXN0IGhhcyBub3Qg cnVuLgorICAgIDwvcD4KKyAgICA8aWZyYW1lIGlkPSJteURpcmVjdG9yeSIgc3JjPSJyZXNvdXJj ZXMvZGlyZWN0b3J5IiB3aWR0aD0iNjAwcHgiIGhlaWdodD0iNDAwcHgiIG9ubG9hZD0iZGlyZWN0 b3J5VGVzdCgpIi8+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9ndGsvZmFzdC9sb2FkZXIvcmVzb3VyY2VzL2RpcmVjdG9yeS9rZWVwLWVtcHR5IGIv TGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Zhc3QvbG9hZGVyL3Jlc291cmNlcy9kaXJlY3Rvcnkv a2VlcC1lbXB0eQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hMjA5YTEyCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Zhc3QvbG9hZGVyL3Jl c291cmNlcy9kaXJlY3Rvcnkva2VlcC1lbXB0eQpAQCAtMCwwICsxLDIgQEAKK1RoaXMgZGlyZWN0 b3J5IGlzIHVzZWQgYnkgcGxhdGZvcm0vZ3RrL2Zhc3QvbG9hZGVyL2NyYXNoLWRpc3BsYXktbG9j YWwtZGlyZWN0b3J5Lmh0bWwKK1BsZWFzZSBkb24ndCBhZGQgYW55dGhpbmcgaW50byB0aGlzIGRp cmVjdG9yeS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VM b2cKaW5kZXggMDllNjZiYy4uZjRjMzQwYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0xMS0xNyAgTmlj b2xhcyBEdWZyZXNuZSAgPG5pY29sYXMuZHVmcmVzbmVAY29sbGFib3JhLmNvLnVrPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHVEtdIHJlc3BvbnNl LmlzTnVsbCgpIGFzc2VydCB3aGVuIHVzaW5nIGRpcmVjdG9yeSBmaWxlIFVSSQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDkwMTgKKworICAgICAgICBE byBlbnN1cmUgdGhhdCBkaWRSZWNlaXZlUmVzcG9uc2UgaGFwcGVucyBiZWZvcmUgYW55IGNhbGwg dG8KKyAgICAgICAgZGlkUmVjZWl2ZURhdGEuIFRoYXQgd2FzIG5vdCB0cnVlIGZvciBmaWxlOi8v IFVSSXMgcG9pbnRpbmcgdG8KKyAgICAgICAgZGlyZWN0b3JpZXMgYW5kIHRodXMgd2FzIHRyaWdn ZXJpbmcgYW4gYXNzZXJ0aW9uLgorCisgICAgICAgIFRlc3Q6IHBsYXRmb3JtL2d0ay9mYXN0L2xv YWRlci9jcmFzaC1kaXNwbGF5LWxvY2FsLWRpcmVjdG9yeS5odG1sCisKKyAgICAgICAgKiBwbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmdvdEhlYWRlcnNDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpjb250ZW50U25pZmZl ZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnBhcnNlRGF0YVVybCk6CisgICAgICAgIChX ZWJDb3JlOjpzZW5kUmVxdWVzdENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OnJlYWRDYWxs YmFjayk6CisKIDIwMTAtMTEtMTUgIEJldGggRGFraW4gIDxiZGFraW5AYXBwbGUuY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXggMGY5Nzg2Ny4uZTU3 OGE4ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VI YW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZUhhbmRsZVNvdXAuY3BwCkBAIC0yNDUsNiArMjQ1LDggQEAgc3RhdGljIHZvaWQgZ290SGVhZGVy c0NhbGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIGdwb2ludGVyIGRhdGEpCiAgICAgaWYgKCFjbGll bnQpCiAgICAgICAgIHJldHVybjsKIAorICAgIEFTU0VSVChkLT5tX3Jlc3BvbnNlLmlzTnVsbCgp KTsKKwogICAgIGZpbGxSZXNwb25zZUZyb21NZXNzYWdlKG1zZywgJmQtPm1fcmVzcG9uc2UpOwog ICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwgZC0+bV9yZXNwb25z ZSk7CiB9CkBAIC0yNzIsNiArMjc0LDggQEAgc3RhdGljIHZvaWQgY29udGVudFNuaWZmZWRDYWxs YmFjayhTb3VwTWVzc2FnZSogbXNnLCBjb25zdCBjaGFyKiBzbmlmZmVkVHlwZSwgR0gKICAgICBp ZiAoIWNsaWVudCkKICAgICAgICAgcmV0dXJuOwogCisgICAgQVNTRVJUKGQtPm1fcmVzcG9uc2Uu aXNOdWxsKCkpOworCiAgICAgZmlsbFJlc3BvbnNlRnJvbU1lc3NhZ2UobXNnLCAmZC0+bV9yZXNw b25zZSk7CiAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCBkLT5t X3Jlc3BvbnNlKTsKIH0KQEAgLTI5MSw2ICsyOTUsOCBAQCBzdGF0aWMgdm9pZCBnb3RDaHVua0Nh bGxiYWNrKFNvdXBNZXNzYWdlKiBtc2csIFNvdXBCdWZmZXIqIGNodW5rLCBncG9pbnRlciBkYXRh KQogICAgIGlmICghY2xpZW50KQogICAgICAgICByZXR1cm47CiAKKyAgICBBU1NFUlQoIWQtPm1f cmVzcG9uc2UuaXNOdWxsKCkpOworCiAgICAgY2xpZW50LT5kaWRSZWNlaXZlRGF0YShoYW5kbGUu Z2V0KCksIGNodW5rLT5kYXRhLCBjaHVuay0+bGVuZ3RoLCBmYWxzZSk7CiB9CiAKQEAgLTMyOSwx NCArMzM1LDE1IEBAIHN0YXRpYyBnYm9vbGVhbiBwYXJzZURhdGFVcmwoZ3BvaW50ZXIgY2FsbGJh Y2tEYXRhKQogICAgIFN0cmluZyBtaW1lVHlwZSA9IGV4dHJhY3RNSU1FVHlwZUZyb21NZWRpYVR5 cGUobWVkaWFUeXBlKTsKICAgICBTdHJpbmcgY2hhcnNldCA9IGV4dHJhY3RDaGFyc2V0RnJvbU1l ZGlhVHlwZShtZWRpYVR5cGUpOwogCi0gICAgUmVzb3VyY2VSZXNwb25zZSByZXNwb25zZTsKLSAg ICByZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJlcXVlc3QoKS51cmwoKSk7Ci0gICAgcmVz cG9uc2Uuc2V0TWltZVR5cGUobWltZVR5cGUpOworICAgIEFTU0VSVChkLT5tX3Jlc3BvbnNlLmlz TnVsbCgpKTsKKworICAgIGQtPm1fcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RSZXF1ZXN0 KCkudXJsKCkpOworICAgIGQtPm1fcmVzcG9uc2Uuc2V0TWltZVR5cGUobWltZVR5cGUpOwogCiAg ICAgLy8gRm9yIG5vbiBiYXNlNjQgZW5jb2RlZCBkYXRhIHdlIGhhdmUgdG8gY29udmVydCB0byBV VEYtMTYgZWFybHkKICAgICAvLyBkdWUgdG8gbGltaXRhdGlvbnMgaW4gS1VSTAotICAgIHJlc3Bv bnNlLnNldFRleHRFbmNvZGluZ05hbWUoaXNCYXNlNjQgPyBjaGFyc2V0IDogIlVURi0xNiIpOwot ICAgIGNsaWVudC0+ZGlkUmVjZWl2ZVJlc3BvbnNlKGhhbmRsZSwgcmVzcG9uc2UpOworICAgIGQt Pm1fcmVzcG9uc2Uuc2V0VGV4dEVuY29kaW5nTmFtZShpc0Jhc2U2NCA/IGNoYXJzZXQgOiAiVVRG LTE2Iik7CisgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLCBkLT5tX3Jlc3Bv bnNlKTsKIAogICAgIC8vIFRoZSBsb2FkIG1heSBiZSBjYW5jZWxsZWQsIGFuZCB0aGUgY2xpZW50 IG1heSBiZSBkZXN0cm95ZWQKICAgICAvLyBieSBhbnkgb2YgdGhlIGNsaWVudCByZXBvcnRpbmcg Y2FsbHMsIHNvIHdlIGNoZWNrLCBhbmQgYmFpbApAQCAtNDk2LDYgKzUwMyw4IEBAIHN0YXRpYyB2 b2lkIHNlbmRSZXF1ZXN0Q2FsbGJhY2soR09iamVjdCogc291cmNlLCBHQXN5bmNSZXN1bHQqIHJl cywgZ3BvaW50ZXIgdXNlCiAgICAgICAgIH0KIAogICAgICAgICBpZiAoZC0+bV9zb3VwTWVzc2Fn ZSAmJiBzdGF0dXNXaWxsQmVIYW5kbGVkQnlTb3VwKGQtPm1fc291cE1lc3NhZ2UtPnN0YXR1c19j b2RlKSkgeworICAgICAgICAgICAgQVNTRVJUKGQtPm1fcmVzcG9uc2UuaXNOdWxsKCkpOworCiAg ICAgICAgICAgICBmaWxsUmVzcG9uc2VGcm9tTWVzc2FnZShzb3VwTXNnLCAmZC0+bV9yZXNwb25z ZSk7CiAgICAgICAgICAgICBjbGllbnQtPmRpZFJlY2VpdmVSZXNwb25zZShoYW5kbGUuZ2V0KCks IGQtPm1fcmVzcG9uc2UpOwogCkBAIC01MjYsMTggKzUzNSwxNCBAQCBzdGF0aWMgdm9pZCBzZW5k UmVxdWVzdENhbGxiYWNrKEdPYmplY3QqIHNvdXJjZSwgR0FzeW5jUmVzdWx0KiByZXMsIGdwb2lu dGVyIHVzZQogICAgIC8vIHJlYWRDYWxsYmFjayBuZWVkcyBpdAogICAgIGdfb2JqZWN0X3NldF9k YXRhKEdfT0JKRUNUKGQtPm1faW5wdXRTdHJlYW0uZ2V0KCkpLCAid2Via2l0LXJlc291cmNlIiwg aGFuZGxlLmdldCgpKTsKIAotICAgIC8vIFdlIG5lZWQgdG8gY2hlY2sgaWYgaXQncyBhIGZpbGU6 IFVSTCBhbmQgaWYgaXQgaXMgYSByZWd1bGFyCi0gICAgLy8gZmlsZSBhcyBpdCBjb3VsZCBiZSBh IGRpcmVjdG9yeS4gSW4gdGhhdCBjYXNlIFNvdXAgcHJvcGVybHkKLSAgICAvLyByZXR1cm5zIGEg c3RyZWFtIHdob3NlIGNvbnRlbnQgaXMgYSBIVE1MIHdpdGggYSBsaXN0IG9mIGZpbGVzCi0gICAg Ly8gaW4gdGhlIGRpcmVjdG9yeQotICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZShoYW5kbGUtPmZp cnN0UmVxdWVzdCgpLnVybCgpLnByb3RvY29sKCksICJmaWxlIikKLSAgICAgICAgJiYgR19JU19G SUxFX0lOUFVUX1NUUkVBTShpbikpIHsKLSAgICAgICAgUmVzb3VyY2VSZXNwb25zZSByZXNwb25z ZTsKLQotICAgICAgICByZXNwb25zZS5zZXRVUkwoaGFuZGxlLT5maXJzdFJlcXVlc3QoKS51cmwo KSk7Ci0gICAgICAgIHJlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtpdF9zb3VwX3JlcXVlc3RfZ2V0 X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAgICAgIHJlc3BvbnNl LnNldEV4cGVjdGVkQ29udGVudExlbmd0aCh3ZWJraXRfc291cF9yZXF1ZXN0X2dldF9jb250ZW50 X2xlbmd0aChkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7Ci0gICAgICAgIGNsaWVudC0+ZGlkUmVj ZWl2ZVJlc3BvbnNlKGhhbmRsZS5nZXQoKSwgcmVzcG9uc2UpOworICAgIC8vIEVuc3VyZSBhIHJl c3BvbnNlIGlzIHNlbnQgZm9yIGFueSBwcm90b2NvbHMgdGhhdCBkb24ndCBleHBsaWNpdGx5IHN1 cHBvcnQgcmVzcG9uc2VzCisgICAgLy8gdGhyb3VnaCBnb3QtaGVhZGVycyBzaWduYWwgb3IgY29u dGVudCBzbmlmZmluZy4KKyAgICAvLyAoZS5nLiBmaWxlIGFuZCBHSU8gYmFzZWQgcHJvdG9jb2wp LgorICAgIGlmICghaGFuZGxlLT5zaG91bGRDb250ZW50U25pZmYoKSAmJiBkLT5tX3Jlc3BvbnNl LmlzTnVsbCgpKSB7CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0VVJMKGhhbmRsZS0+Zmlyc3RS ZXF1ZXN0KCkudXJsKCkpOworICAgICAgICBkLT5tX3Jlc3BvbnNlLnNldE1pbWVUeXBlKHdlYmtp dF9zb3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfdHlwZShkLT5tX3NvdXBSZXF1ZXN0LmdldCgpKSk7 CisgICAgICAgIGQtPm1fcmVzcG9uc2Uuc2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHdlYmtpdF9z b3VwX3JlcXVlc3RfZ2V0X2NvbnRlbnRfbGVuZ3RoKGQtPm1fc291cFJlcXVlc3QuZ2V0KCkpKTsK KyAgICAgICAgY2xpZW50LT5kaWRSZWNlaXZlUmVzcG9uc2UoaGFuZGxlLmdldCgpLCBkLT5tX3Jl c3BvbnNlKTsKIAogICAgICAgICBpZiAoZC0+bV9jYW5jZWxsZWQpIHsKICAgICAgICAgICAgIGNs ZWFudXBTb3VwUmVxdWVzdE9wZXJhdGlvbihoYW5kbGUuZ2V0KCkpOwpAQCAtODEzLDYgKzgxOCw5 IEBAIHN0YXRpYyB2b2lkIHJlYWRDYWxsYmFjayhHT2JqZWN0KiBzb3VyY2UsIEdBc3luY1Jlc3Vs dCogYXN5bmNSZXN1bHQsIGdwb2ludGVyIGRhCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKKyAg ICAvLyBJdCdzIG1hbmRhdG9yeSB0byBoYXZlIHNlbnQgYSByZXNwb25zZSBiZWZvcmUgc2VuZGlu ZyBkYXRhCisgICAgQVNTRVJUKCFkLT5tX3Jlc3BvbnNlLmlzTnVsbCgpKTsKKwogICAgIGQtPm1f dG90YWwgKz0gYnl0ZXNSZWFkOwogICAgIGlmIChHX0xJS0VMWSghY29udmVydFRvVVRGMTYpKQog ICAgICAgICBjbGllbnQtPmRpZFJlY2VpdmVEYXRhKGhhbmRsZS5nZXQoKSwgZC0+bV9idWZmZXIs IGJ5dGVzUmVhZCwgZC0+bV90b3RhbCk7Ci0tIAoxLjcuMy4yCgo=