107171 2013-01-17 13:40:43 -0800 shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom should return false on Android 2013-04-08 11:10:32 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 1 cjhopman webkit-unassigned abarth dglazkov eric fishd jamesr leviw mifenton peter rniwa tkent+wkapi webkit.review.bot oldest_to_newest 809719 0 cjhopman 2013-01-17 13:40:43 -0800 Add Android-specific EditingBehavior 809728 1 183266 cjhopman 2013-01-17 13:46:01 -0800 Created attachment 183266 Patch 809732 2 183268 cjhopman 2013-01-17 13:46:48 -0800 Created attachment 183268 Patch 809736 3 webkit.review.bot 2013-01-17 13:50:09 -0800 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 809752 4 183268 leviw 2013-01-17 13:58:34 -0800 Comment on attachment 183268 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review r=me > Source/WebCore/ChangeLog:13 > + No new tests (OOPS!). You'll have to change this. You can't lande with "OOPS!" in the ChangeLog. Ideally you should add a test that verifies this behavior, but I'd be content with an explanation of why you're not adding one. 809753 5 eric 2013-01-17 14:00:28 -0800 Android was adding some custom code to move the cursor. Is that no longer needed after thsi? or is this just tweaking other editing behaviors in webkit to be more android-like? 809756 6 183268 rniwa 2013-01-17 14:05:24 -0800 Comment on attachment 183268 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review I'm sorry but I have to r- this. > Source/WebCore/ChangeLog:11 > + On Android, EditingBehavior::shouldMoveCaret[...] controls the > + behavior of insertion handles. This change adds a new Android specific > + editing behavior type so that we can change these settings independent > + of behavior for other platforms. I don't think adding a new editing behavior makes sense here. r-. The only reason we decided to have these editing behaviors is so that we can test these behaviors in layout tests. Given that we're not doing it, ifdef will suffice. > Source/WebCore/editing/EditingBehavior.h:71 > - return m_type == EditingUnixBehavior; > + return m_type == EditingUnixBehavior || m_type == EditingAndroidBehavior; This code is never used in Android port. 809764 7 183268 leviw 2013-01-17 14:12:56 -0800 Comment on attachment 183268 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review >> Source/WebCore/ChangeLog:11 >> + of behavior for other platforms. > > I don't think adding a new editing behavior makes sense here. r-. > The only reason we decided to have these editing behaviors is so that we can test these behaviors in layout tests. > Given that we're not doing it, ifdef will suffice. I don't agree that encapsulating these classes of behavior in an enum makes less sense than adding ifdefs for them when the enum exists. I'd be happier covering this in layout tests than needing to disable/add specific expectations for Android, which would occur if just #ifdefing EditingUnixBehavior. 809765 8 183268 rniwa 2013-01-17 14:13:09 -0800 Comment on attachment 183268 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review > Source/WebCore/editing/EditingBehavior.h:44 > + return m_type != EditingWindowsBehavior && m_type != EditingAndroidBehavior; This patch doesn't just add an editing behavior but changes the behavior of WebCore on Android port. As such, it needs a test. 809767 9 rniwa 2013-01-17 14:14:12 -0800 (In reply to comment #7) > (From update of attachment 183268 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review > > >> Source/WebCore/ChangeLog:11 > >> + of behavior for other platforms. > > > > I don't think adding a new editing behavior makes sense here. r-. > > The only reason we decided to have these editing behaviors is so that we can test these behaviors in layout tests. > > Given that we're not doing it, ifdef will suffice. > > I don't agree that encapsulating these classes of behavior in an enum makes less sense than adding ifdefs for them when the enum exists. I'd be happier covering this in layout tests than needing to disable/add specific expectations for Android, which would occur if just #ifdefing EditingUnixBehavior. We already have an if-def for chromium. If we're adding a new editing behavior, then all existing layout tests need to be updated to test "android" editing behaviors as well as exiting ones. 809771 10 rniwa 2013-01-17 14:17:52 -0800 1. I would like to know why this behavior is desirable. 2. I would like to see a test that demonstrates the bug. 3. If we're adding a new editing behavior, then existing tests in LayoutTests/editing should be updated to test "android" editing behavior as well although I strongly advise against adding a new editing behavior in the first place. The criteria for whether we should add "android" editing behavior for this bug is whether such a behavior is platform de-facto standard and every sane Android browser should exhibit the same behavior or not. If not, i.e. this behavior is specific to Chromium Android port, then adding a new editing behavior is not the right solution. 809775 11 leviw 2013-01-17 14:19:39 -0800 (In reply to comment #9) > (In reply to comment #7) > > (From update of attachment 183268 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review > > > > >> Source/WebCore/ChangeLog:11 > > >> + of behavior for other platforms. > > > > > > I don't think adding a new editing behavior makes sense here. r-. > > > The only reason we decided to have these editing behaviors is so that we can test these behaviors in layout tests. > > > Given that we're not doing it, ifdef will suffice. > > > > I don't agree that encapsulating these classes of behavior in an enum makes less sense than adding ifdefs for them when the enum exists. I'd be happier covering this in layout tests than needing to disable/add specific expectations for Android, which would occur if just #ifdefing EditingUnixBehavior. > > We already have an if-def for chromium. If we're adding a new editing behavior, then all existing layout tests need to be updated to test "android" editing behaviors as well as exiting ones. The existing #ifdef seems like more of a design choice by Chromium than an editing behavior related to a platform. It seems to me that mobile does represent a new class of editing behavior. 809780 12 rniwa 2013-01-17 14:21:30 -0800 (In reply to comment #11) > The existing #ifdef seems like more of a design choice by Chromium than an editing behavior related to a platform. It seems to me that mobile does represent a new class of editing behavior. Right. So you're saying that this is not a design choose of Chromium port, and it's a platform standard? If so, could someone point to me to an application that exhibit this behavior? 809805 13 183268 cjhopman 2013-01-17 14:40:31 -0800 Comment on attachment 183268 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review >>>>> Source/WebCore/ChangeLog:11 >>>>> + of behavior for other platforms. >>>> >>>> I don't think adding a new editing behavior makes sense here. r-. >>>> The only reason we decided to have these editing behaviors is so that we can test these behaviors in layout tests. >>>> Given that we're not doing it, ifdef will suffice. >>> >>> I don't agree that encapsulating these classes of behavior in an enum makes less sense than adding ifdefs for them when the enum exists. I'd be happier covering this in layout tests than needing to disable/add specific expectations for Android, which would occur if just #ifdefing EditingUnixBehavior. >> >> We already have an if-def for chromium. If we're adding a new editing behavior, then all existing layout tests need to be updated to test "android" editing behaviors as well as exiting ones. > > The existing #ifdef seems like more of a design choice by Chromium than an editing behavior related to a platform. It seems to me that mobile does represent a new class of editing behavior. rniwa: Are you suggesting adding something like: "#if PLATFORM(CHROMIUM) && defined(ANDROID) \ return false; \ #endif" to EditingBehavior::shouldMove[...]? That seems reasonable to me. I think it would probably be best if these settings could be set individually (rather than as a group based on the existing EditingBehaviorTypes) by an embedder like all of WebCore::Settings, then we wouldn't need to stick any CHROMIUM stuff in here. What do you think? 809815 14 rniwa 2013-01-17 14:43:39 -0800 (In reply to comment #13) > (From update of attachment 183268 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183268&action=review > > I think it would probably be best if these settings could be set individually (rather than as a group based on the existing EditingBehaviorTypes) by an embedder like all of WebCore::Settings, then we wouldn't need to stick any CHROMIUM stuff in here. What do you think? The whole point of editing behavior is so that we don't have to add a new setting for every method we have in EditingBehavior.h, and each port doesn't need to figure things on their own. I would much prefer ifdef solution over adding new settings. 809824 15 leviw 2013-01-17 14:49:55 -0800 The ifdef solution seems a fine path for this. I agree with rniwa that complicating the test surface here would be a big disadvantage of adding an Android behavior. It does seem flawed to me that we have 3 editing behavior modes, but none of them really seem to fit mobile. 809850 16 rniwa 2013-01-17 15:05:25 -0800 (In reply to comment #15) > The ifdef solution seems a fine path for this. I agree with rniwa that complicating the test surface here would be a big disadvantage of adding an Android behavior. It does seem flawed to me that we have 3 editing behavior modes, but none of them really seem to fit mobile. I'm fine with adding a new editing behavior for mobile in general or Android (I'd expect Android and iOS have very different editing behavior though) but only if that's not specific to a particular browser. But if we're doing that, then we need to make sure all tests that explicitly set editing behaviors need to be updated to test the new value "android". Regardless, this bug really needs a reduced test case. 811074 17 183554 cjhopman 2013-01-18 14:57:18 -0800 Created attachment 183554 Patch 811085 18 183554 rniwa 2013-01-18 15:12:10 -0800 Comment on attachment 183554 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183554&action=review > LayoutTests/ChangeLog:12 > + * editing/selection/script-tests/test-if-should-move-caret-to-horizontal-boundary-forced-false.js: Added. > + (checkSelection): > + (clickShouldResultInRange): > + * editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false-expected.txt: Added. > + * editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false.html: Added. Please don't add a separate js file for the script tests. That's the old way. The new way is to put the script in the single html file. Also, this test will have a different result on Windows as well as Chromium Windows so you'll need to add test expectations there as well. > LayoutTests/editing/selection/script-tests/test-if-should-move-caret-to-horizontal-boundary-forced-false.js:40 > +function clickShouldResultInRange(x, y, offsetIfNormal, offsetIfForced) { > + if (window.eventSender) { > + clickAt(x, y); > + checkSelection(offsetIfNormal, offsetIfForced); > + } > +} A more idiomatic way of writing a test case like this is to add a helper function to verify things and call both of these functions inside assertEqual. e.g. assertEqual("clickAt(pointImmediatelyAfterText); locationOfCaretInTextNode()", "0"); But this isn't really great because the output depends on the platform. You might want your test to look something like: evalAndLog(" clickAt(pointImmediatelyAfterText);"); debug("Caret location:" + caretLocation()); > LayoutTests/editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false-expected.txt:10 > +PASS EditingBehavior::shouldMove[...] not forced to false. Selection is [anchorNode: [object Text](XX) anchorOffset: 0 focusNode: [object Text](XX) focusOffset: 0 isCollapsed: true] > +PASS EditingBehavior::shouldMove[...] not forced to false. Selection is [anchorNode: [object Text](XX) anchorOffset: 0 focusNode: [object Text](XX) focusOffset: 0 isCollapsed: true] > +PASS EditingBehavior::shouldMove[...] not forced to false. Selection is [anchorNode: [object Text](XX) anchorOffset: 2 focusNode: [object Text](XX) focusOffset: 2 isCollapsed: true] > +PASS EditingBehavior::shouldMove[...] not forced to false. Selection is [anchorNode: [object Text](XX) anchorOffset: 2 focusNode: [object Text](XX) focusOffset: 2 isCollapsed: true] > +PASS successfullyParsed is true Looking at this output, I can't tell what it's testing and why those outputs are correct. The test output should answer questions. Also, it's not clear to me using testPassed/testFailed is the right thing to do in this test given that the output depends on the platform. > LayoutTests/platform/chromium-android/TestExpectations:114 > +# On Android, EditingBehavior::shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() > +# always returns false. That breaks these tests. > +# https://bugs.webkit.org/show_bug.cgi?id=105574 > +# This may be revisited after http://crbug.com/135959 is finished. > +editing/selection/click-in-margins-inside-editable-div.html [ WontFix ] > +editing/selection/click-in-padding-with-multiple-line-boxes.html [ WontFix ] > +fast/writing-mode/flipped-blocks-hit-test-line-edges.html [ WontFix ] It doesn't seem like a good idea to regress these tests. If anything the said chromium issue should be fixed first. 811109 19 183554 cjhopman 2013-01-18 15:41:02 -0800 Comment on attachment 183554 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=183554&action=review >> LayoutTests/ChangeLog:12 >> + * editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false.html: Added. > > Please don't add a separate js file for the script tests. That's the old way. The new way is to put the script in the single html file. > Also, this test will have a different result on Windows as well as Chromium Windows so you'll need to add test expectations there as well. Sure, I'll combine them. I don't think this test has different results on Windows - see below. > LayoutTests/editing/selection/script-tests/test-if-should-move-caret-to-horizontal-boundary-forced-false.js:43 > + internals.settings.setEditingBehavior("mac"); My understanding is that this call will make the test use the mac editing behavior. I.e. the test behavior will be the same for all platforms except for chromium-android (which forces at compile time that EditingBehavior::shouldMoveCaret[...] returns false regardless of what editing behavior is set). >> LayoutTests/platform/chromium-android/TestExpectations:114 >> +fast/writing-mode/flipped-blocks-hit-test-line-edges.html [ WontFix ] > > It doesn't seem like a good idea to regress these tests. If anything the said chromium issue should be fixed first. These tests use internals.settings.setEditingBehavior("somePlatform") and then depend on EditingBehavior::shouldMoveCaret[...] to behave according to that platform's editing behavior. This is not the case if it is #ifdeffed for chromium-android to always return false. So I see 3 options: 1. Rebaseline the tests for the new behavior. I didn't like this because these tests use testPassed and testFailed and the new behavior has a lot of FAILs (i.e. for all the parts of the test that assume mac or linux editing behavior). That makes the expected behavior look wrong and I don't know of a good way to notify someone looking at that new expected behavior that the FAILs are actually "PASSes". 2. Change the test to detect that it's actually on chromium-android and then understand that they won't get mac or linux behavior for shouldMoveCaret[...] and change all their checks accordingly. With this approach, chromium-android would still need new baselines for these tests, but the expected behavior wouldn't look like it was wrong. However, I don't really like the idea of such an invasive change to the tests just to support this odd chromium-android behavior. 3. Let the tests fail and mark them WontFix. This is clean and we can have a notification at the same point saying what's wrong with the tests and when they should be fixed. However, it's major failing is that chromium-android loses the coverage of these tests. I did (1) and was working on (2) when I decided to go with (3). You know better than me, though, so if you'd prefer one of the other 2 options (or something else I didn't list) that'll be fine with me. The mentioned chromium issue is a rather long term goal. 811113 20 rniwa 2013-01-18 15:45:00 -0800 (In reply to comment #19) > (From update of attachment 183554 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183554&action=review > > >> LayoutTests/platform/chromium-android/TestExpectations:114 > >> +fast/writing-mode/flipped-blocks-hit-test-line-edges.html [ WontFix ] > > > > It doesn't seem like a good idea to regress these tests. If anything the said chromium issue should be fixed first. > > These tests use internals.settings.setEditingBehavior("somePlatform") and then depend on EditingBehavior::shouldMoveCaret[...] to behave according to that platform's editing behavior. This is not the case if it is #ifdeffed for chromium-android to always return false. So I see 3 options: > > 1. Rebaseline the tests for the new behavior. I didn't like this because these tests use testPassed and testFailed and the new behavior has a lot of FAILs (i.e. for all the parts of the test that assume mac or linux editing behavior). That makes the expected behavior look wrong and I don't know of a good way to notify someone looking at that new expected behavior that the FAILs are actually "PASSes". > > 2. Change the test to detect that it's actually on chromium-android and then understand that they won't get mac or linux behavior for shouldMoveCaret[...] and change all their checks accordingly. With this approach, chromium-android would still need new baselines for these tests, but the expected behavior wouldn't look like it was wrong. However, I don't really like the idea of such an invasive change to the tests just to support this odd chromium-android behavior. > > 3. Let the tests fail and mark them WontFix. This is clean and we can have a notification at the same point saying what's wrong with the tests and when they should be fixed. However, it's major failing is that chromium-android loses the coverage of these tests. > > I did (1) and was working on (2) when I decided to go with (3). You know better than me, though, so if you'd prefer one of the other 2 options (or something else I didn't list) that'll be fine with me. Option 1 is what we do in WebKit. When you land thrse changes, just mention that FAILs are expected. 813263 21 184024 cjhopman 2013-01-22 11:31:25 -0800 Created attachment 184024 Patch 813314 22 184024 rniwa 2013-01-22 12:29:54 -0800 Comment on attachment 184024 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=184024&action=review > LayoutTests/editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false-expected.txt:3 > +clickAt(782, 94) Doesn't this coordinate depend on how the text above wrap? You should probably hide the description text during the test so that it won't affect the clicked coordinate and make it platform dependent. > LayoutTests/editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false.html:32 > + var sel = window.getSelection(); Please don't use an abbreviation like sel. Spell out selection. Also, you don't need window. Simply call getSelection() as in: var anchorNode = getSelection().anchorNode; return anchorNode + ' ' + anchorNode.data + ' ' + getSelection().anchorOffset; You should also check that the resultant selection is collapsed. i.e. getSelection().isCollapsed is true. 813422 23 184048 cjhopman 2013-01-22 14:35:46 -0800 Created attachment 184048 Patch 813425 24 184048 rniwa 2013-01-22 14:37:42 -0800 Comment on attachment 184048 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=184048&action=review > LayoutTests/editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false-expected.txt:4 > +Caret location: [object Text] XX 0 true I can't tell what "true" means here. In general, the test output should be self explanatory such that someone who has never looked at the test should be able to tell what the test is testing and whether it's passing or failing and why. 813454 25 184048 cjhopman 2013-01-22 15:11:11 -0800 Comment on attachment 184048 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=184048&action=review >> LayoutTests/editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false-expected.txt:4 >> +Caret location: [object Text] XX 0 true > > I can't tell what "true" means here. In general, the test output should be self explanatory such that > someone who has never looked at the test should be able to tell what the test is testing and whether it's passing or failing and why. Ok, how about just not outputting isCollapsed? This test doesn't actually care about it, and if it's ever false then there is certainly something more fundamental wrong with selection. But, on that note, do you think I should label these other values (anchorNode, anchorNode.data, anchorOffset)? 813464 26 rniwa 2013-01-22 15:19:20 -0800 (In reply to comment #25) > (From update of attachment 184048 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=184048&action=review > > >> LayoutTests/editing/selection/test-if-should-move-caret-to-horizontal-boundary-forced-false-expected.txt:4 > >> +Caret location: [object Text] XX 0 true > > > > I can't tell what "true" means here. In general, the test output should be self explanatory such that > > someone who has never looked at the test should be able to tell what the test is testing and whether it's passing or failing and why. > > Ok, how about just not outputting isCollapsed? This test doesn't actually care about it, and if it's ever false then there is certainly something more fundamental wrong with selection. We do care about that because if isCollapsed is false, then we're getting a non-collapsed selection, which is clearly not intended. > But, on that note, do you think I should label these other values (anchorNode, anchorNode.data, anchorOffset)? Probably not. 813478 27 184048 darin 2013-01-22 15:32:48 -0800 Comment on attachment 184048 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=184048&action=review This is not > Source/WebCore/editing/EditingBehavior.h:49 > - bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return m_type != EditingWindowsBehavior; } > + bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const > + { > +#if PLATFORM(CHROMIUM) && defined(ANDROID) > + return false; > +#else > + return m_type != EditingWindowsBehavior; > +#endif > + } This is not the way to fix this. It’s really bad to be putting #if statements in this header. The whole idea here was to define editing behavior types instead of having a pile of ifdefs. I am extremely unhappy to see shouldAllowSpellingSuggestionsWithoutSelection special cased for Chromium; too bad I was not able to stop this then when it first happened. The right way to do this is to add more editing behavior types, not add #if statements. 813490 28 rniwa 2013-01-22 15:44:58 -0800 (In reply to comment #27) > (From update of attachment 184048 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=184048&action=review > > This is not > > > Source/WebCore/editing/EditingBehavior.h:49 > > - bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return m_type != EditingWindowsBehavior; } > > + bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const > > + { > > +#if PLATFORM(CHROMIUM) && defined(ANDROID) > > + return false; > > +#else > > + return m_type != EditingWindowsBehavior; > > +#endif > > + } > > This is not the way to fix this. It’s really bad to be putting #if statements in this header. The whole idea here was to define editing behavior types instead of having a pile of ifdefs. I am extremely unhappy to see shouldAllowSpellingSuggestionsWithoutSelection special cased for Chromium; too bad I was not able to stop this then when it first happened. The right way to do this is to add more editing behavior types, not add #if statements. I don't think that makes sense in this particular case because this behavior is specific to Chromium port. Namely, I don't think we want to be adding EditingChromiumWindowsBehavior, EditingChromiumMacBehavior, EditingChromiumLinuxBehavior, and EditingChromiumAndroidBehavior in addition to ones we already have. 814772 29 cjhopman 2013-01-23 16:06:01 -0800 (In reply to comment #27) > (From update of attachment 184048 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=184048&action=review > > This is not > > > Source/WebCore/editing/EditingBehavior.h:49 > > - bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const { return m_type != EditingWindowsBehavior; } > > + bool shouldMoveCaretToHorizontalBoundaryWhenPastTopOrBottom() const > > + { > > +#if PLATFORM(CHROMIUM) && defined(ANDROID) > > + return false; > > +#else > > + return m_type != EditingWindowsBehavior; > > +#endif > > + } > > This is not the way to fix this. It’s really bad to be putting #if statements in this header. The whole idea here was to define editing behavior types instead of having a pile of ifdefs. I am extremely unhappy to see shouldAllowSpellingSuggestionsWithoutSelection special cased for Chromium; too bad I was not able to stop this then when it first happened. The right way to do this is to add more editing behavior types, not add #if statements. Ok, so here's the problem: chromium-android needs EditingBehavior::shouldMoveCaret[...] to return true chromium-linux needs EditingBehavior::shouldAllowSpelling[...] to return false both of these otherwise want EditingUnixBehavior. I would really prefer if these two issues (and future cases where a specific port needs changes to EditingBehavior) were handled in a consistent way. Here are my thoughts on some possible approaches. The approach that has been taken in the past (i.e. for chromium-linux) is to add an ifdef in EditingBehavior.h. darin@ argues that that is wrong, we should not be adding #ifs here. I think that's a reasonable stance. We could introduce a new EditingBehaviorType each time we need behavior that diverges from the current types (i.e. we could add EditingChromiumLinuxBehavior and EditingChromiumAndroidBehavior), but I agree with rniwa@ that that is not a very good solution. We could require that every port use one of a small set of bundles of behavior (i.e. 3?). We already have 2 ports that want unique behavior, and I don't think this approach is practical. Every time that a port wants behavior for one of these functions that differs from the platform-default, we could move that function to WebCore::Settings and allow the port to set the behavior to whatever it wants. This weakens the benefit of bundling these together as platform editing behaviors. The approach that I would prefer/think is best would be to modify EditingBehavior such that each of the behaviors can be set individually by an embedder (like WebCore::Settings). We could keep the EditingBehaviorTypes and have a constructor (or setter) that takes an EditingBehaviorType and sets all of the behaviors based on that EditingBehaviorType. Then if a particular port (chromium-linux or chromium-android, for example) wanted different behavior for a single function, they could initialize the EditingBehavior based on a platform and then change only those (few) functions/behaviors that they wanted. You guys know better than I do what approach should be taken, so I'm happy to defer the decision to you, I just thought I'd get some ideas out there. 814864 30 rniwa 2013-01-23 17:17:20 -0800 (In reply to comment #29) > Ok, so here's the problem: > chromium-android needs EditingBehavior::shouldMoveCaret[...] to return true > chromium-linux needs EditingBehavior::shouldAllowSpelling[...] to return false > both of these otherwise want EditingUnixBehavior. First off, it's unclear to me why Chromium Linux wants to return false in shouldAllowSpellingSuggestionsWithoutSelection. As far as I can tell, nobody from Chromium port voiced such need: https://bugs.webkit.org/show_bug.cgi?id=103520 We need to see if we can make Chromium Linux behave like the rest of Linux ports. > The approach that I would prefer/think is best would be to modify EditingBehavior such that each of the behaviors can be set individually by an embedder (like WebCore::Settings). We could keep the EditingBehaviorTypes and have a constructor (or setter) that takes an EditingBehaviorType and sets all of the behaviors based on that EditingBehaviorType. Then if a particular port (chromium-linux or chromium-android, for example) wanted different behavior for a single function, they could initialize the EditingBehavior based on a platform and then change only those (few) functions/behaviors that they wanted. The whole point of editing behavior was so that we didn't have to add a setting for each new editing behavior we want. Given that, I don't think making everything configurable by each port appears to defeat the point of having this class. We might as well as use settings at that point. 870935 31 peter 2013-04-08 11:10:32 -0700 Resolving as WontFix given that Chromium moved to Blink. 183266 2013-01-17 13:46:01 -0800 2013-01-17 13:46:46 -0800 Patch bug-107171-20130117134301.patch text/plain 8232 cjhopman U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5ODM4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTE1ZDllZjQyOThmZjgw MWY5NzA3NWQ4YTgzMjMzODNmY2NjZDA5YS4uNTg3Y2I5NThlN2VlMmRjODcwYzQwMzFlNTE1ZTAw YjliNzg1NzcxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDEzLTAxLTE3ICBDaHJp cyBIb3BtYW4gIDxjamhvcG1hbkBnb29nbGUuY29tPgorCisgICAgICAgIEFkZCBBbmRyb2lkLXNw ZWNpZmljIEVkaXRpbmdCZWhhdmlvcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTA3MTcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgT24gQW5kcm9pZCwgRWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3ZlQ2Fy ZXRbLi4uXSBjb250cm9scyB0aGUKKyAgICAgICAgYmVoYXZpb3Igb2YgaW5zZXJ0aW9uIGhhbmRs ZXMuIFRoaXMgY2hhbmdlIGFkZHMgYSBuZXcgQW5kcm9pZCBzcGVjaWZpYworICAgICAgICBlZGl0 aW5nIGJlaGF2aW9yIHR5cGUgc28gdGhhdCB3ZSBjYW4gY2hhbmdlIHRoZXNlIHNldHRpbmdzIGlu ZGVwZW5kZW50CisgICAgICAgIG9mIGJlaGF2aW9yIGZvciBvdGhlciBwbGF0Zm9ybXMuCisKKyAg ICAgICAgTm8gbmV3IHRlc3RzIChPT1BTISkuCisKKyAgICAgICAgKiBlZGl0aW5nL0VkaXRpbmdC ZWhhdmlvci5oOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3Zl Q2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20pOgorICAgICAgICAo V2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRBbGxvd1NwZWxsaW5nU3VnZ2VzdGlvbnNX aXRob3V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvcjo6c2hv dWxkTmF2aWdhdGVCYWNrT25CYWNrc3BhY2UpOgorICAgICAgICAqIGVkaXRpbmcvRWRpdGluZ0Jl aGF2aW9yVHlwZXMuaDoKKyAgICAgICAgKiBwYWdlL1NldHRpbmdzLmNwcDoKKyAgICAgICAgKFdl YkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6ZWRpdGluZ0JlaGF2aW9yVHlwZUZvclBsYXRmb3Jt KToKKyAgICAgICAgKiB0ZXN0aW5nL0ludGVybmFsU2V0dGluZ3MuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6SW50ZXJuYWxTZXR0aW5nczo6c2V0RWRpdGluZ0JlaGF2aW9yKToKKwogMjAxMy0wMS0x NSAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBHVEsrIGFuZCBR dCBidWlsZCBmaXggYWZ0ZXIgcjEzOTgzMy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg NzE0YTZjMDRhOTQ0NWUyZGY0MjIyMDdlMjY5ZjI0MDY1NGJjZjNmZC4uMTk2MTkzZjA3ZTUwZDU4 MzQyZWY2NmJkMWYyN2Y4ZmYwMGEzOTVlOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxOSBAQAorMjAxMy0wMS0xNyAgQ2hyaXMgSG9wbWFuICA8Y2pob3BtYW5AZ29vZ2xl LmNvbT4KKworICAgICAgICBBZGQgQW5kcm9pZC1zcGVjaWZpYyBFZGl0aW5nQmVoYXZpb3IKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNzE3MQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE9uIEFuZHJvaWQs IEVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0Wy4uLl0gY29udHJvbHMgdGhlCisgICAg ICAgIGJlaGF2aW9yIG9mIGluc2VydGlvbiBoYW5kbGVzLiBUaGlzIGNoYW5nZSBhZGRzIGEgbmV3 IEFuZHJvaWQgc3BlY2lmaWMKKyAgICAgICAgZWRpdGluZyBiZWhhdmlvciB0eXBlIHNvIHRoYXQg d2UgY2FuIGNoYW5nZSB0aGVzZSBzZXR0aW5ncyBpbmRlcGVuZGVudAorICAgICAgICBvZiBiZWhh dmlvciBmb3Igb3RoZXIgcGxhdGZvcm1zLgorCisgICAgICAgICogcHVibGljL1dlYlNldHRpbmdz Lmg6CisgICAgICAgICogc3JjL0Fzc2VydE1hdGNoaW5nRW51bXMuY3BwOgorICAgICAgICBKdXN0 IGFkZCB0aGUgY29ycmVzcG9uZGluZyBhc3NlcnRpb24gZm9yIHRoZSBuZXcgZWRpdGluZyBiZWhh dmlvci4KKwogMjAxMy0wMS0xNSAgSWFuIFZvbGxpY2sgIDx2b2xsaWNrQGNocm9taXVtLm9yZz4K IAogICAgICAgICBbY2hyb21pdW1dIENyZWF0ZSBHcmFwaGljc0xheWVyQ2hyb21pdW1zIHVzaW5n IGEgZmFjdG9yeQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVo YXZpb3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKaW5kZXgg NTM4ZWUwZThiYzU4NzBlM2MxZTM0Mzk0YWRjMTEwNDc0OWIwNTMwYS4uMzZiODk1NmFhMTdjZmQ5 ZjI5MTQxMTljNzQ3OThhMGY3NWJjZjk5OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRp dGluZy9FZGl0aW5nQmVoYXZpb3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRp bmdCZWhhdmlvci5oCkBAIC0zOSw3ICszOSwxMCBAQCBwdWJsaWM6CiAgICAgLy8gV2hlbiBleHRl bmRpbmcgYSBzZWxlY3Rpb24gYmV5b25kIHRoZSB0b3Agb3IgYm90dG9tIGJvdW5kYXJ5IG9mIGFu IGVkaXRhYmxlIGFyZWEsCiAgICAgLy8gbWFpbnRhaW4gdGhlIGhvcml6b250YWwgcG9zaXRpb24g b24gV2luZG93cyBidXQgZXh0ZW5kIGl0IHRvIHRoZSBib3VuZGFyeSBvZiB0aGUgZWRpdGFibGUK ICAgICAvLyBjb250ZW50IG9uIE1hYy4KLSAgICBib29sIHNob3VsZE1vdmVDYXJldFRvSG9yaXpv bnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSAh PSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hv cml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdAorICAgIHsKKyAgICAg ICAgcmV0dXJuIG1fdHlwZSAhPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yICYmIG1fdHlwZSAhPSBF ZGl0aW5nQW5kcm9pZEJlaGF2aW9yOworICAgIH0KIAogICAgIC8vIE9uIFdpbmRvd3MsIHNlbGVj dGlvbnMgc2hvdWxkIGFsd2F5cyBiZSBjb25zaWRlcmVkIGFzIGRpcmVjdGlvbmFsLCByZWdhcmRs ZXNzIGlmIGl0IGlzCiAgICAgLy8gbW91c2UtYmFzZWQgb3Iga2V5Ym9hcmQtYmFzZWQuCkBAIC02 NSwxNCArNjgsMTcgQEAgcHVibGljOgogICAgIGJvb2wgc2hvdWxkQWxsb3dTcGVsbGluZ1N1Z2dl c3Rpb25zV2l0aG91dFNlbGVjdGlvbigpIGNvbnN0CiAgICAgewogI2lmICFQTEFURk9STShDSFJP TUlVTSkKLSAgICAgICAgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nVW5peEJlaGF2aW9yOworICAg ICAgICByZXR1cm4gbV90eXBlID09IEVkaXRpbmdVbml4QmVoYXZpb3IgfHwgbV90eXBlID09IEVk aXRpbmdBbmRyb2lkQmVoYXZpb3I7CiAjZWxzZQogICAgICAgICByZXR1cm4gZmFsc2U7CiAjZW5k aWYKICAgICB9CiAgICAgCiAgICAgLy8gT24gTWFjIGFuZCBXaW5kb3dzLCBwcmVzc2luZyBiYWNr c3BhY2UgKHdoZW4gaXQgaXNuJ3QgaGFuZGxlZCBvdGhlcndpc2UpIHNob3VsZCBuYXZpZ2F0ZSBi YWNrLgotICAgIGJvb2wgc2hvdWxkTmF2aWdhdGVCYWNrT25CYWNrc3BhY2UoKSBjb25zdCB7IHJl dHVybiBtX3R5cGUgIT0gRWRpdGluZ1VuaXhCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkTmF2 aWdhdGVCYWNrT25CYWNrc3BhY2UoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fdHlw ZSAhPSBFZGl0aW5nVW5peEJlaGF2aW9yICYmIG1fdHlwZSAhPSBFZGl0aW5nQW5kcm9pZEJlaGF2 aW9yOworICAgIH0KIAogICAgIC8vIE9uIE1hYywgc2VsZWN0aW5nIGJhY2t3YXJkcyBieSB3b3Jk L2xpbmUgZnJvbSB0aGUgbWlkZGxlIG9mIGEgd29yZC9saW5lLCBhbmQgdGhlbiBnb2luZwogICAg IC8vIGZvcndhcmQgbGVhdmVzIHRoZSBjYXJldCBiYWNrIGluIHRoZSBtaWRkbGUgd2l0aCBubyBz ZWxlY3Rpb24sIGluc3RlYWQgb2YgZGlyZWN0bHkgc2VsZWN0aW5nCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmggYi9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvclR5cGVzLmgKaW5kZXggMTEzNDVkYTVkNDc4OGJkYTIx OTdiYzA3MWU1OTJiMDZmNDE3NTcwNC4uYmUxOGUyNjllZTc5NWM0ZTlkODI4NzA2NTY3NGFhM2Fj YmE2MGU2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZp b3JUeXBlcy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yVHlw ZXMuaApAQCAtMzksNyArMzksOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBlbnVtIEVkaXRpbmdC ZWhhdmlvclR5cGUgewogICAgIEVkaXRpbmdNYWNCZWhhdmlvciwKICAgICBFZGl0aW5nV2luZG93 c0JlaGF2aW9yLAotICAgIEVkaXRpbmdVbml4QmVoYXZpb3IKKyAgICBFZGl0aW5nVW5peEJlaGF2 aW9yLAorICAgIEVkaXRpbmdBbmRyb2lkQmVoYXZpb3IKIH07CiAKIH0gLy8gV2ViQ29yZSBuYW1l c3BhY2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKaW5kZXggMjY4YzU4MjUyY2U0NDFmNGFkZWZj MDJiNjk1NTZmZGMyNGUwOWUyOC4uMGQ0YzI5ZTViZjNkODJlZDljNmFmNDM2MGMzY2Y1OWRmMDA1 N2NjOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGFnZS9TZXR0aW5ncy5jcHAKQEAgLTEwNyw3ICsxMDcsOCBAQCBib29s IFNldHRpbmdzOjpnU2hvdWxkUmVzcGVjdFByaW9yaXR5SW5DU1NBdHRyaWJ1dGVTZXR0ZXJzID0g ZmFsc2U7CiAvLyBOT1RFcwogLy8gIDEpIEVkaXRpbmdNYWNCZWhhdmlvciBjb21wcmlzZXMgVGln ZXIsIExlb3BhcmQsIFNub3dMZW9wYXJkIGFuZCBpT1MgYnVpbGRzLCBhcyB3ZWxsIFF0V2ViS2l0 IGFuZCBDaHJvbWl1bSB3aGVuIGJ1aWx0IG9uIE1hYzsKIC8vICAyKSBFZGl0aW5nV2luZG93c0Jl aGF2aW9yIGNvbXByaXNlcyBXaW4zMiBhbmQgV2luQ0UgYnVpbGRzLCBhcyB3ZWxsIGFzIFF0V2Vi S2l0IGFuZCBDaHJvbWl1bSB3aGVuIGJ1aWx0IG9uIFdpbmRvd3M7Ci0vLyAgMykgRWRpdGluZ1Vu aXhCZWhhdmlvciBjb21wcmlzZXMgYWxsIHVuaXgtYmFzZWQgc3lzdGVtcywgYnV0IERhcndpbi9N YWNPUyAoYW5kIHRoZW4gYWJ1c2luZyB0aGUgdGVybWlub2xvZ3kpOworLy8gIDMpIEVkaXRpbmdV bml4QmVoYXZpb3IgY29tcHJpc2VzIGFsbCB1bml4LWJhc2VkIHN5c3RlbXMsIGJ1dCBEYXJ3aW4v TWFjT1MvQW5kcm9pZCAoYW5kIHRoZW4gYWJ1c2luZyB0aGUgdGVybWlub2xvZ3kpOworLy8gIDQp IEVkaXRpbmdBbmRyb2lkQmVoYXZpb3IgY29tcHJpc2VzIEFuZHJvaWQgYnVpbGRzLgogLy8gOTkp IE1hY0VkaXRpbmdCZWhhdmlvciBpcyB1c2VkIGEgZmFsbGJhY2suCiBzdGF0aWMgRWRpdGluZ0Jl aGF2aW9yVHlwZSBlZGl0aW5nQmVoYXZpb3JUeXBlRm9yUGxhdGZvcm0oKQogewpAQCAtMTE2LDYg KzExNyw4IEBAIHN0YXRpYyBFZGl0aW5nQmVoYXZpb3JUeXBlIGVkaXRpbmdCZWhhdmlvclR5cGVG b3JQbGF0Zm9ybSgpCiAgICAgRWRpdGluZ01hY0JlaGF2aW9yCiAjZWxpZiBPUyhXSU5ET1dTKQog ICAgIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IKKyNlbGlmIE9TKEFORFJPSUQpCisgICAgRWRpdGlu Z0FuZHJvaWRCZWhhdmlvcgogI2VsaWYgT1MoVU5JWCkKICAgICBFZGl0aW5nVW5peEJlaGF2aW9y CiAjZWxzZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvdGVzdGluZy9JbnRlcm5hbFNldHRp bmdzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxTZXR0aW5ncy5jcHAKaW5k ZXggYmYzM2ExNGU0MTRjZTMyNmU2MDQ5YTA0NjkzODU5MWI3N2VmZGIwYi4uOTE5MTdiMWQ1ZTA5 NjE1NTE5NmJjZTlhOGE5MDY4Y2VkNzE4YmRlZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv dGVzdGluZy9JbnRlcm5hbFNldHRpbmdzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5n L0ludGVybmFsU2V0dGluZ3MuY3BwCkBAIC0zODIsNiArMzgyLDggQEAgdm9pZCBJbnRlcm5hbFNl dHRpbmdzOjpzZXRFZGl0aW5nQmVoYXZpb3IoY29uc3QgU3RyaW5nJiBlZGl0aW5nQmVoYXZpb3Is IEV4Y2VwdGkKICAgICAgICAgc2V0dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2aW9yVHlwZShFZGl0 aW5nTWFjQmVoYXZpb3IpOwogICAgIGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKGVkaXRpbmdC ZWhhdmlvciwgInVuaXgiKSkKICAgICAgICAgc2V0dGluZ3MoKS0+c2V0RWRpdGluZ0JlaGF2aW9y VHlwZShFZGl0aW5nVW5peEJlaGF2aW9yKTsKKyAgICBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2Fz ZShlZGl0aW5nQmVoYXZpb3IsICJhbmRyb2lkIikpCisgICAgICAgIHNldHRpbmdzKCktPnNldEVk aXRpbmdCZWhhdmlvclR5cGUoRWRpdGluZ0FuZHJvaWRCZWhhdmlvcik7CiAgICAgZWxzZQogICAg ICAgICBlYyA9IFNZTlRBWF9FUlI7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViU2V0dGluZ3MuaAppbmRleCA4OTRhMGMzMDdjYTNiN2ZjN2U1N2FlYjRlYTY4MTQ5OTUwNTFj MzViLi5mMzE4MzQ2ZTAxYWQ4YjY2YzliMzU2NDY5OGNkZTE3NGVlOGU3OGM2IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlNldHRpbmdzLmgKQEAgLTQ4LDcgKzQ4LDggQEAg cHVibGljOgogICAgIGVudW0gRWRpdGluZ0JlaGF2aW9yIHsKICAgICAgICAgRWRpdGluZ0JlaGF2 aW9yTWFjLAogICAgICAgICBFZGl0aW5nQmVoYXZpb3JXaW4sCi0gICAgICAgIEVkaXRpbmdCZWhh dmlvclVuaXgKKyAgICAgICAgRWRpdGluZ0JlaGF2aW9yVW5peCwKKyAgICAgICAgRWRpdGluZ0Jl aGF2aW9yQW5kcm9pZAogICAgIH07CiAKICAgICB2aXJ0dWFsIGJvb2wgc2Nyb2xsQW5pbWF0b3JF bmFibGVkKCkgY29uc3QgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvQXNzZXJ0TWF0Y2hpbmdFbnVtcy5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9B c3NlcnRNYXRjaGluZ0VudW1zLmNwcAppbmRleCBiMWY0NmE0NTQxZDQ1MzI4ZjYxYzQ4N2I0OGNh NWYyMTE3NDkzZjNjLi42NDAyMjUyYmU2OTgyMjRiNmJhNTc4MmYyYWM5ZTg0NjlkZTUzM2Q5IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NlcnRNYXRjaGluZ0VudW1z LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Bc3NlcnRNYXRjaGluZ0VudW1z LmNwcApAQCAtNDY1LDYgKzQ2NSw3IEBAIENPTVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2Vi U2Nyb2xsYmFyOjpTY3JvbGxiYXJPdmVybGF5U3R5bGVMaWdodCwgU2Nyb2xsYmFyCiBDT01QSUxF X0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlNldHRpbmdzOjpFZGl0aW5nQmVoYXZpb3JNYWMsIEVk aXRpbmdNYWNCZWhhdmlvcik7CiBDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlNldHRp bmdzOjpFZGl0aW5nQmVoYXZpb3JXaW4sIEVkaXRpbmdXaW5kb3dzQmVoYXZpb3IpOwogQ09NUElM RV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJTZXR0aW5nczo6RWRpdGluZ0JlaGF2aW9yVW5peCwg RWRpdGluZ1VuaXhCZWhhdmlvcik7CitDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVNKFdlYlNl dHRpbmdzOjpFZGl0aW5nQmVoYXZpb3JBbmRyb2lkLCBFZGl0aW5nQW5kcm9pZEJlaGF2aW9yKTsK IAogQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJUZXh0QWZmaW5pdHlVcHN0cmVhbSwg VVBTVFJFQU0pOwogQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJUZXh0QWZmaW5pdHlE b3duc3RyZWFtLCBET1dOU1RSRUFNKTsK 183268 2013-01-17 13:46:48 -0800 2013-01-18 14:57:14 -0800 Patch bug-107171-20130117134348.patch text/plain 8236 cjhopman U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5ODM4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNTE1ZDllZjQyOThmZjgw MWY5NzA3NWQ4YTgzMjMzODNmY2NjZDA5YS4uZTI4YWM5YjU3ZmI0MzFkZDg2Y2QwZTY2NTYwOGQy NmNjMjU5ZmU4OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDEzLTAxLTE3ICBDaHJp cyBIb3BtYW4gIDxjamhvcG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIEFuZHJvaWQt c3BlY2lmaWMgRWRpdGluZ0JlaGF2aW9yCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xMDcxNzEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBPbiBBbmRyb2lkLCBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVD YXJldFsuLi5dIGNvbnRyb2xzIHRoZQorICAgICAgICBiZWhhdmlvciBvZiBpbnNlcnRpb24gaGFu ZGxlcy4gVGhpcyBjaGFuZ2UgYWRkcyBhIG5ldyBBbmRyb2lkIHNwZWNpZmljCisgICAgICAgIGVk aXRpbmcgYmVoYXZpb3IgdHlwZSBzbyB0aGF0IHdlIGNhbiBjaGFuZ2UgdGhlc2Ugc2V0dGluZ3Mg aW5kZXBlbmRlbnQKKyAgICAgICAgb2YgYmVoYXZpb3IgZm9yIG90aGVyIHBsYXRmb3Jtcy4KKwor ICAgICAgICBObyBuZXcgdGVzdHMgKE9PUFMhKS4KKworICAgICAgICAqIGVkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yLmg6CisgICAgICAgIChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1v dmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSk6CisgICAgICAg IChXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3I6OnNob3VsZEFsbG93U3BlbGxpbmdTdWdnZXN0aW9u c1dpdGhvdXRTZWxlY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yOjpz aG91bGROYXZpZ2F0ZUJhY2tPbkJhY2tzcGFjZSk6CisgICAgICAgICogZWRpdGluZy9FZGl0aW5n QmVoYXZpb3JUeXBlcy5oOgorICAgICAgICAqIHBhZ2UvU2V0dGluZ3MuY3BwOgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjplZGl0aW5nQmVoYXZpb3JUeXBlRm9yUGxhdGZv cm0pOgorICAgICAgICAqIHRlc3RpbmcvSW50ZXJuYWxTZXR0aW5ncy5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpJbnRlcm5hbFNldHRpbmdzOjpzZXRFZGl0aW5nQmVoYXZpb3IpOgorCiAyMDEzLTAx LTE1ICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIEdUSysgYW5k IFF0IGJ1aWxkIGZpeCBhZnRlciByMTM5ODMzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRl eCA3MTRhNmMwNGE5NDQ1ZTJkZjQyMjIwN2UyNjlmMjQwNjU0YmNmM2ZkLi41YjlhNmU1NzFlMTVl OTE2OTgwMzNhOThkNzExODRhM2ZjMDI1YmZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDE5IEBACisyMDEzLTAxLTE3ICBDaHJpcyBIb3BtYW4gIDxjamhvcG1hbkBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgQWRkIEFuZHJvaWQtc3BlY2lmaWMgRWRpdGluZ0JlaGF2aW9y CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDcxNzEK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPbiBBbmRy b2lkLCBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFsuLi5dIGNvbnRyb2xzIHRoZQor ICAgICAgICBiZWhhdmlvciBvZiBpbnNlcnRpb24gaGFuZGxlcy4gVGhpcyBjaGFuZ2UgYWRkcyBh IG5ldyBBbmRyb2lkIHNwZWNpZmljCisgICAgICAgIGVkaXRpbmcgYmVoYXZpb3IgdHlwZSBzbyB0 aGF0IHdlIGNhbiBjaGFuZ2UgdGhlc2Ugc2V0dGluZ3MgaW5kZXBlbmRlbnQKKyAgICAgICAgb2Yg YmVoYXZpb3IgZm9yIG90aGVyIHBsYXRmb3Jtcy4KKworICAgICAgICAqIHB1YmxpYy9XZWJTZXR0 aW5ncy5oOgorICAgICAgICAqIHNyYy9Bc3NlcnRNYXRjaGluZ0VudW1zLmNwcDoKKyAgICAgICAg SnVzdCBhZGQgdGhlIGNvcnJlc3BvbmRpbmcgYXNzZXJ0aW9uIGZvciB0aGUgbmV3IGVkaXRpbmcg YmVoYXZpb3IuCisKIDIwMTMtMDEtMTUgIElhbiBWb2xsaWNrICA8dm9sbGlja0BjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgW2Nocm9taXVtXSBDcmVhdGUgR3JhcGhpY3NMYXllckNocm9taXVtcyB1 c2luZyBhIGZhY3RvcnkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGlu Z0JlaGF2aW9yLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCmlu ZGV4IDUzOGVlMGU4YmM1ODcwZTNjMWUzNDM5NGFkYzExMDQ3NDliMDUzMGEuLjM2Yjg5NTZhYTE3 Y2ZkOWYyOTE0MTE5Yzc0Nzk4YTBmNzViY2Y5OTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9F ZGl0aW5nQmVoYXZpb3IuaApAQCAtMzksNyArMzksMTAgQEAgcHVibGljOgogICAgIC8vIFdoZW4g ZXh0ZW5kaW5nIGEgc2VsZWN0aW9uIGJleW9uZCB0aGUgdG9wIG9yIGJvdHRvbSBib3VuZGFyeSBv ZiBhbiBlZGl0YWJsZSBhcmVhLAogICAgIC8vIG1haW50YWluIHRoZSBob3Jpem9udGFsIHBvc2l0 aW9uIG9uIFdpbmRvd3MgYnV0IGV4dGVuZCBpdCB0byB0aGUgYm91bmRhcnkgb2YgdGhlIGVkaXRh YmxlCiAgICAgLy8gY29udGVudCBvbiBNYWMuCi0gICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRUb0hv cml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdCB7IHJldHVybiBtX3R5 cGUgIT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvcjsgfQorICAgIGJvb2wgc2hvdWxkTW92ZUNhcmV0 VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tKCkgY29uc3QKKyAgICB7Cisg ICAgICAgIHJldHVybiBtX3R5cGUgIT0gRWRpdGluZ1dpbmRvd3NCZWhhdmlvciAmJiBtX3R5cGUg IT0gRWRpdGluZ0FuZHJvaWRCZWhhdmlvcjsKKyAgICB9CiAKICAgICAvLyBPbiBXaW5kb3dzLCBz ZWxlY3Rpb25zIHNob3VsZCBhbHdheXMgYmUgY29uc2lkZXJlZCBhcyBkaXJlY3Rpb25hbCwgcmVn YXJkbGVzcyBpZiBpdCBpcwogICAgIC8vIG1vdXNlLWJhc2VkIG9yIGtleWJvYXJkLWJhc2VkLgpA QCAtNjUsMTQgKzY4LDE3IEBAIHB1YmxpYzoKICAgICBib29sIHNob3VsZEFsbG93U3BlbGxpbmdT dWdnZXN0aW9uc1dpdGhvdXRTZWxlY3Rpb24oKSBjb25zdAogICAgIHsKICNpZiAhUExBVEZPUk0o Q0hST01JVU0pCi0gICAgICAgIHJldHVybiBtX3R5cGUgPT0gRWRpdGluZ1VuaXhCZWhhdmlvcjsK KyAgICAgICAgcmV0dXJuIG1fdHlwZSA9PSBFZGl0aW5nVW5peEJlaGF2aW9yIHx8IG1fdHlwZSA9 PSBFZGl0aW5nQW5kcm9pZEJlaGF2aW9yOwogI2Vsc2UKICAgICAgICAgcmV0dXJuIGZhbHNlOwog I2VuZGlmCiAgICAgfQogICAgIAogICAgIC8vIE9uIE1hYyBhbmQgV2luZG93cywgcHJlc3Npbmcg YmFja3NwYWNlICh3aGVuIGl0IGlzbid0IGhhbmRsZWQgb3RoZXJ3aXNlKSBzaG91bGQgbmF2aWdh dGUgYmFjay4KLSAgICBib29sIHNob3VsZE5hdmlnYXRlQmFja09uQmFja3NwYWNlKCkgY29uc3Qg eyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdVbml4QmVoYXZpb3I7IH0KKyAgICBib29sIHNob3Vs ZE5hdmlnYXRlQmFja09uQmFja3NwYWNlKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBt X3R5cGUgIT0gRWRpdGluZ1VuaXhCZWhhdmlvciAmJiBtX3R5cGUgIT0gRWRpdGluZ0FuZHJvaWRC ZWhhdmlvcjsKKyAgICB9CiAKICAgICAvLyBPbiBNYWMsIHNlbGVjdGluZyBiYWNrd2FyZHMgYnkg d29yZC9saW5lIGZyb20gdGhlIG1pZGRsZSBvZiBhIHdvcmQvbGluZSwgYW5kIHRoZW4gZ29pbmcK ICAgICAvLyBmb3J3YXJkIGxlYXZlcyB0aGUgY2FyZXQgYmFjayBpbiB0aGUgbWlkZGxlIHdpdGgg bm8gc2VsZWN0aW9uLCBpbnN0ZWFkIG9mIGRpcmVjdGx5IHNlbGVjdGluZwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3JUeXBlcy5oCmluZGV4IDExMzQ1ZGE1ZDQ3ODhi ZGEyMTk3YmMwNzFlNTkyYjA2ZjQxNzU3MDQuLmJlMThlMjY5ZWU3OTVjNGU5ZDgyODcwNjU2NzRh YTNhY2JhNjBlNjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0Jl aGF2aW9yVHlwZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlv clR5cGVzLmgKQEAgLTM5LDcgKzM5LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogZW51bSBFZGl0 aW5nQmVoYXZpb3JUeXBlIHsKICAgICBFZGl0aW5nTWFjQmVoYXZpb3IsCiAgICAgRWRpdGluZ1dp bmRvd3NCZWhhdmlvciwKLSAgICBFZGl0aW5nVW5peEJlaGF2aW9yCisgICAgRWRpdGluZ1VuaXhC ZWhhdmlvciwKKyAgICBFZGl0aW5nQW5kcm9pZEJlaGF2aW9yCiB9OwogCiB9IC8vIFdlYkNvcmUg bmFtZXNwYWNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1NldHRpbmdzLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCmluZGV4IDI2OGM1ODI1MmNlNDQxZjRh ZGVmYzAyYjY5NTU2ZmRjMjRlMDllMjguLjBkNGMyOWU1YmYzZDgyZWQ5YzZhZjQzNjBjM2NmNTlk ZjAwNTdjYzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvU2V0dGluZ3MuY3BwCkBAIC0xMDcsNyArMTA3LDggQEAg Ym9vbCBTZXR0aW5nczo6Z1Nob3VsZFJlc3BlY3RQcmlvcml0eUluQ1NTQXR0cmlidXRlU2V0dGVy cyA9IGZhbHNlOwogLy8gTk9URXMKIC8vICAxKSBFZGl0aW5nTWFjQmVoYXZpb3IgY29tcHJpc2Vz IFRpZ2VyLCBMZW9wYXJkLCBTbm93TGVvcGFyZCBhbmQgaU9TIGJ1aWxkcywgYXMgd2VsbCBRdFdl YktpdCBhbmQgQ2hyb21pdW0gd2hlbiBidWlsdCBvbiBNYWM7CiAvLyAgMikgRWRpdGluZ1dpbmRv d3NCZWhhdmlvciBjb21wcmlzZXMgV2luMzIgYW5kIFdpbkNFIGJ1aWxkcywgYXMgd2VsbCBhcyBR dFdlYktpdCBhbmQgQ2hyb21pdW0gd2hlbiBidWlsdCBvbiBXaW5kb3dzOwotLy8gIDMpIEVkaXRp bmdVbml4QmVoYXZpb3IgY29tcHJpc2VzIGFsbCB1bml4LWJhc2VkIHN5c3RlbXMsIGJ1dCBEYXJ3 aW4vTWFjT1MgKGFuZCB0aGVuIGFidXNpbmcgdGhlIHRlcm1pbm9sb2d5KTsKKy8vICAzKSBFZGl0 aW5nVW5peEJlaGF2aW9yIGNvbXByaXNlcyBhbGwgdW5peC1iYXNlZCBzeXN0ZW1zLCBidXQgRGFy d2luL01hY09TL0FuZHJvaWQgKGFuZCB0aGVuIGFidXNpbmcgdGhlIHRlcm1pbm9sb2d5KTsKKy8v ICA0KSBFZGl0aW5nQW5kcm9pZEJlaGF2aW9yIGNvbXByaXNlcyBBbmRyb2lkIGJ1aWxkcy4KIC8v IDk5KSBNYWNFZGl0aW5nQmVoYXZpb3IgaXMgdXNlZCBhIGZhbGxiYWNrLgogc3RhdGljIEVkaXRp bmdCZWhhdmlvclR5cGUgZWRpdGluZ0JlaGF2aW9yVHlwZUZvclBsYXRmb3JtKCkKIHsKQEAgLTEx Niw2ICsxMTcsOCBAQCBzdGF0aWMgRWRpdGluZ0JlaGF2aW9yVHlwZSBlZGl0aW5nQmVoYXZpb3JU eXBlRm9yUGxhdGZvcm0oKQogICAgIEVkaXRpbmdNYWNCZWhhdmlvcgogI2VsaWYgT1MoV0lORE9X UykKICAgICBFZGl0aW5nV2luZG93c0JlaGF2aW9yCisjZWxpZiBPUyhBTkRST0lEKQorICAgIEVk aXRpbmdBbmRyb2lkQmVoYXZpb3IKICNlbGlmIE9TKFVOSVgpCiAgICAgRWRpdGluZ1VuaXhCZWhh dmlvcgogI2Vsc2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxT ZXR0aW5ncy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFsU2V0dGluZ3MuY3Bw CmluZGV4IGJmMzNhMTRlNDE0Y2UzMjZlNjA0OWEwNDY5Mzg1OTFiNzdlZmRiMGIuLjkxOTE3YjFk NWUwOTYxNTUxOTZiY2U5YThhOTA2OGNlZDcxOGJkZWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3Rlc3RpbmcvSW50ZXJuYWxTZXR0aW5ncy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvdGVz dGluZy9JbnRlcm5hbFNldHRpbmdzLmNwcApAQCAtMzgyLDYgKzM4Miw4IEBAIHZvaWQgSW50ZXJu YWxTZXR0aW5nczo6c2V0RWRpdGluZ0JlaGF2aW9yKGNvbnN0IFN0cmluZyYgZWRpdGluZ0JlaGF2 aW9yLCBFeGNlcHRpCiAgICAgICAgIHNldHRpbmdzKCktPnNldEVkaXRpbmdCZWhhdmlvclR5cGUo RWRpdGluZ01hY0JlaGF2aW9yKTsKICAgICBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2FzZShlZGl0 aW5nQmVoYXZpb3IsICJ1bml4IikpCiAgICAgICAgIHNldHRpbmdzKCktPnNldEVkaXRpbmdCZWhh dmlvclR5cGUoRWRpdGluZ1VuaXhCZWhhdmlvcik7CisgICAgZWxzZSBpZiAoZXF1YWxJZ25vcmlu Z0Nhc2UoZWRpdGluZ0JlaGF2aW9yLCAiYW5kcm9pZCIpKQorICAgICAgICBzZXR0aW5ncygpLT5z ZXRFZGl0aW5nQmVoYXZpb3JUeXBlKEVkaXRpbmdBbmRyb2lkQmVoYXZpb3IpOwogICAgIGVsc2UK ICAgICAgICAgZWMgPSBTWU5UQVhfRVJSOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViU2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYlNldHRpbmdzLmgKaW5kZXggODk0YTBjMzA3Y2EzYjdmYzdlNTdhZWI0ZWE2ODE0OTk1 MDUxYzM1Yi4uZjMxODM0NmUwMWFkOGI2NmM5YjM1NjQ2OThjZGUxNzRlZThlNzhjNiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViU2V0dGluZ3MuaAorKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTZXR0aW5ncy5oCkBAIC00OCw3ICs0OCw4 IEBAIHB1YmxpYzoKICAgICBlbnVtIEVkaXRpbmdCZWhhdmlvciB7CiAgICAgICAgIEVkaXRpbmdC ZWhhdmlvck1hYywKICAgICAgICAgRWRpdGluZ0JlaGF2aW9yV2luLAotICAgICAgICBFZGl0aW5n QmVoYXZpb3JVbml4CisgICAgICAgIEVkaXRpbmdCZWhhdmlvclVuaXgsCisgICAgICAgIEVkaXRp bmdCZWhhdmlvckFuZHJvaWQKICAgICB9OwogCiAgICAgdmlydHVhbCBib29sIHNjcm9sbEFuaW1h dG9yRW5hYmxlZCgpIGNvbnN0ID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL0Fzc2VydE1hdGNoaW5nRW51bXMuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvQXNzZXJ0TWF0Y2hpbmdFbnVtcy5jcHAKaW5kZXggYjFmNDZhNDU0MWQ0NTMyOGY2MWM0ODdi NDhjYTVmMjExNzQ5M2YzYy4uNjQwMjI1MmJlNjk4MjI0YjZiYTU3ODJmMmFjOWU4NDY5ZGU1MzNk OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvQXNzZXJ0TWF0Y2hpbmdF bnVtcy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvQXNzZXJ0TWF0Y2hpbmdF bnVtcy5jcHAKQEAgLTQ2NSw2ICs0NjUsNyBAQCBDT01QSUxFX0FTU0VSVF9NQVRDSElOR19FTlVN KFdlYlNjcm9sbGJhcjo6U2Nyb2xsYmFyT3ZlcmxheVN0eWxlTGlnaHQsIFNjcm9sbGJhcgogQ09N UElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJTZXR0aW5nczo6RWRpdGluZ0JlaGF2aW9yTWFj LCBFZGl0aW5nTWFjQmVoYXZpb3IpOwogQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXZWJT ZXR0aW5nczo6RWRpdGluZ0JlaGF2aW9yV2luLCBFZGl0aW5nV2luZG93c0JlaGF2aW9yKTsKIENP TVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2ViU2V0dGluZ3M6OkVkaXRpbmdCZWhhdmlvclVu aXgsIEVkaXRpbmdVbml4QmVoYXZpb3IpOworQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShX ZWJTZXR0aW5nczo6RWRpdGluZ0JlaGF2aW9yQW5kcm9pZCwgRWRpdGluZ0FuZHJvaWRCZWhhdmlv cik7CiAKIENPTVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2ViVGV4dEFmZmluaXR5VXBzdHJl YW0sIFVQU1RSRUFNKTsKIENPTVBJTEVfQVNTRVJUX01BVENISU5HX0VOVU0oV2ViVGV4dEFmZmlu aXR5RG93bnN0cmVhbSwgRE9XTlNUUkVBTSk7Cg== 183554 2013-01-18 14:57:18 -0800 2013-01-22 11:31:21 -0800 Patch bug-107171-20130118145416.patch text/plain 11196 cjhopman U3VidmVyc2lvbiBSZXZpc2lvbjogMTQwMTk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzE4NWZjNDQ5ZWQ5N2Iw YTQ3MDU5MjEyMjZiYTNhYTBlMTg5MjA4MS4uYzMxZjA0M2Y4M2FjODg3NDMxNGViNDk2NGFmZmJi OTJmNjZmMDI4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDEzLTAxLTE4ICBDaHJp cyBIb3BtYW4gIDxjamhvcG1hbkBnb29nbGUuY29tPgorCisgICAgICAgIHNob3VsZE1vdmVDYXJl dFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSBzaG91bGQgcmV0dXJuIGZh bHNlIG9uIEFuZHJvaWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTEwNzE3MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFRlc3Q6IGVkaXRpbmcvc2VsZWN0aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQt dG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuaHRtbAorCisgICAgICAgICogZWRp dGluZy9FZGl0aW5nQmVoYXZpb3IuaDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlv cjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9t KToKKyAgICAgICAgTWFrZSBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVDYXJldFsuLi5dIGFs d2F5cyByZXR1cm4gZmFsc2Ugb24KKyAgICAgICAgQ2hyb21pdW0gQW5kcm9pZC4KKwogMjAxMy0w MS0xOCAgR2VvZmZyZXkgR2FyZW4gIDxnZ2FyZW5AYXBwbGUuY29tPgogCiAgICAgICAgIFdlYWsg R0MgbWFwcyBzaG91bGQgYmUgZWFzaWVyIHRvIHVzZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRp dGluZ0JlaGF2aW9yLmgKaW5kZXggNTM4ZWUwZThiYzU4NzBlM2MxZTM0Mzk0YWRjMTEwNDc0OWIw NTMwYS4uNmVhYzg1ZjVhNTNkMWZhNzA4ZTNjNGNhZTRhNTk4MjcyNDVhMDk3NyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCkBAIC0zOSw3ICszOSwxNCBAQCBwdWJs aWM6CiAgICAgLy8gV2hlbiBleHRlbmRpbmcgYSBzZWxlY3Rpb24gYmV5b25kIHRoZSB0b3Agb3Ig Ym90dG9tIGJvdW5kYXJ5IG9mIGFuIGVkaXRhYmxlIGFyZWEsCiAgICAgLy8gbWFpbnRhaW4gdGhl IGhvcml6b250YWwgcG9zaXRpb24gb24gV2luZG93cyBidXQgZXh0ZW5kIGl0IHRvIHRoZSBib3Vu ZGFyeSBvZiB0aGUgZWRpdGFibGUKICAgICAvLyBjb250ZW50IG9uIE1hYy4KLSAgICBib29sIHNo b3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNv bnN0IHsgcmV0dXJuIG1fdHlwZSAhPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOyB9CisgICAgYm9v bCBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20o KSBjb25zdAorICAgIHsKKyNpZiBQTEFURk9STShDSFJPTUlVTSkgJiYgZGVmaW5lZChBTkRST0lE KQorICAgICAgICByZXR1cm4gZmFsc2U7CisjZWxzZQorICAgICAgICByZXR1cm4gbV90eXBlICE9 IEVkaXRpbmdXaW5kb3dzQmVoYXZpb3I7CisjZW5kaWYKKyAgICB9CiAKICAgICAvLyBPbiBXaW5k b3dzLCBzZWxlY3Rpb25zIHNob3VsZCBhbHdheXMgYmUgY29uc2lkZXJlZCBhcyBkaXJlY3Rpb25h bCwgcmVnYXJkbGVzcyBpZiBpdCBpcwogICAgIC8vIG1vdXNlLWJhc2VkIG9yIGtleWJvYXJkLWJh c2VkLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCmluZGV4IDc0MmFjMmU5MmJjNWUzMTY3YzY5NGJkMzM4N2U0OTA2MWM1OTY2OWEuLjY0 MzdhM2FiNTQyZWZlOGM1ZTNmZmY0ODYzZGEzYzFlZWRjOWZjOTYgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy MyBAQAorMjAxMy0wMS0xOCAgQ2hyaXMgSG9wbWFuICA8Y2pob3BtYW5AZ29vZ2xlLmNvbT4KKwor ICAgICAgICBzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JC b3R0b20gc2hvdWxkIHJldHVybiBmYWxzZSBvbiBBbmRyb2lkCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDcxNzEKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3NjcmlwdC10 ZXN0cy90ZXN0LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9y Y2VkLWZhbHNlLmpzOiBBZGRlZC4KKyAgICAgICAgKGNoZWNrU2VsZWN0aW9uKToKKyAgICAgICAg KGNsaWNrU2hvdWxkUmVzdWx0SW5SYW5nZSk6CisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24v dGVzdC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1m YWxzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL3Rl c3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFs c2UuaHRtbDogQWRkZWQuCisgICAgICAgIFRoaXMgdGVzdCB1c2VzIG1hYyBlZGl0aW5nIGJlaGF2 aW9yIGFuZCBjaGVja3MgdGhlIGJlaGF2aW9yIG9mCisgICAgICAgIHNob3VsZE1vdmVDYXJldFsu Li5dLiBPbiBwbGF0Zm9ybXMgKGkuZS4gY2hyb21pdW0tYW5kcm9pZCkgd2hlcmUgdGhpcworICAg ICAgICBmdW5jdGlvbiBhbHdheXMgcmV0dXJucyBmYWxzZSwgdGhlIHJlc3VsdHMgd2lsbCByZWZs ZWN0IHRoYXQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9UZXN0RXhwZWN0 YXRpb25zOgorICAgICAgICBEaXNhYmxlIHNvbWUgdGVzdHMgdGhhdCBkZXBlbmQgb24gc2hvdWxk TW92ZUNhcmV0Wy4uLl0gb2JleWluZyB0aGUKKyAgICAgICAgcGxhdGZvcm0gZWRpdGluZyBiZWhh dmlvci4KKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2VkaXRpbmcvc2VsZWN0 aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3Jj ZWQtZmFsc2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKwogMjAxMy0wMS0xOCAgVGltIFZvbG9kaW5l ICA8dGltdm9sb2RpbmVAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFRleHQgQXV0b3NpemluZzog ZG9uJ3QgYXV0b3NpemUgaGVhZGVycyB3aXRoIG11bHRpcGxlIGlubGluZSBsaW5rcy4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NjcmlwdC10ZXN0cy90ZXN0LWlm LXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLmpz IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vc2NyaXB0LXRlc3RzL3Rlc3QtaWYtc2hv dWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuanMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uYWZjNGQxNzc3NTJkMmY4OTE4ZWQyZWYzNDdjZDdmMjVjMDA2YmM3ZgotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3NjcmlwdC10ZXN0cy90 ZXN0LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZh bHNlLmpzCkBAIC0wLDAgKzEsNjAgQEAKK2Rlc2NyaXB0aW9uKCJUZXN0IGlmIEVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90 dG9tIGlzIGZvcmNlZCB0byBmYWxzZS4iKQorCitkb2N1bWVudC5ib2R5LnN0eWxlLm1hcmdpbiA9 IDA7CisKK3ZhciBkaXYgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJkaXYiKTsKK2Rpdi5zdHls ZS5jc3NUZXh0ID0gImZvbnQtZmFtaWx5OiBhaGVtOyBmb250LXNpemU6IDIwcHg7IC13ZWJraXQt dGV4dC1maWxsLWNvbG9yOiB5ZWxsb3c7IHdpZHRoOiA0MHB4OyBoZWlnaHQ6IDgwcHg7IHBhZGRp bmc6IDIwcHg7IGJhY2tncm91bmQtY29sb3I6IGdyZWVuOyI7CitkaXYuY29udGVudEVkaXRhYmxl ID0gdHJ1ZTsKKwordmFyIGZpcnN0VGV4dCA9IGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKCJYWCIp OwordmFyIGZpcnN0RGl2ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CitmaXJzdERp di5hcHBlbmRDaGlsZChmaXJzdFRleHQpOworZmlyc3REaXYuc3R5bGUuY3NzVGV4dCA9ICJwYWRk aW5nLWJvdHRvbTogMTlweDsgYm9yZGVyLWJvdHRvbTogMXB4IHNvbGlkIHBpbms7IG1hcmdpbi1i b3R0b206IDIwcHgiOworZGl2LmFwcGVuZENoaWxkKGZpcnN0RGl2KTsKKworZG9jdW1lbnQuYm9k eS5pbnNlcnRCZWZvcmUoZGl2LCBkb2N1bWVudC5ib2R5LmZpcnN0Q2hpbGQpOworCit2YXIgaXNO b3JtYWwgPSBmYWxzZTsKK3ZhciBpc0ZvcmNlZCA9IGZhbHNlOworZnVuY3Rpb24gY2hlY2tTZWxl Y3Rpb24ob2Zmc2V0SWZOb3JtYWwsIG9mZnNldElmRm9yY2VkKSB7CisgICAgdmFyIHNlbCA9IHdp bmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICBpZiAoc2VsLmFuY2hvck5vZGUgIT0gZmlyc3RUZXh0 KSB7CisgICAgICAgIHRlc3RGYWlsZWQoIlNlbGVjdGlvbiBpcyAiICsgc2VsZWN0aW9uQXNTdHJp bmcoc2VsKSArICIgc2hvdWxkIGJlIGF0IGFuY2hvck5vZGU6ICIgKyBmaXJzdFRleHQpCisgICAg fQorICAgIGVsc2UgaWYgKHNlbC5hbmNob3JPZmZzZXQgPT0gb2Zmc2V0SWZOb3JtYWwpIHsKKyAg ICAgICAgaXNOb3JtYWwgPSB0cnVlOworICAgICAgICB0ZXN0UGFzc2VkKCJFZGl0aW5nQmVoYXZp b3I6OnNob3VsZE1vdmVbLi4uXSBub3QgZm9yY2VkIHRvIGZhbHNlLiBTZWxlY3Rpb24gaXMgIiAr IHNlbGVjdGlvbkFzU3RyaW5nKHNlbCkpOworICAgIH0gZWxzZSBpZiAoc2VsLmFuY2hvck9mZnNl dCA9PSBvZmZzZXRJZkZvcmNlZCkgeworICAgICAgICBpc0ZvcmNlZCA9IHRydWU7CisgICAgICAg IHRlc3RQYXNzZWQoIkVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZVsuLi5dIGlzIGZvcmNlZCB0 byBmYWxzZS4gU2VsZWN0aW9uIGlzICIgKyBzZWxlY3Rpb25Bc1N0cmluZyhzZWwpKTsKKyAgICB9 IGVsc2UgeworICAgICAgICB0ZXN0RmFpbGVkKCJTZWxlY3Rpb24gaXMgIiArIHNlbGVjdGlvbkFz U3RyaW5nKHNlbCkgKyAiIHNob3VsZCBiZSBhdCBhbmNob3JPZmZzZXQ6ICIgKyBvZmZzZXRJZk5v cm1hbCArICIgb3IgIiArIG9mZnNldElmRm9yY2VkKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIGNs aWNrU2hvdWxkUmVzdWx0SW5SYW5nZSh4LCB5LCBvZmZzZXRJZk5vcm1hbCwgb2Zmc2V0SWZGb3Jj ZWQpIHsKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKSB7CisgICAgICAgIGNsaWNrQXQoeCwg eSk7CisgICAgICAgIGNoZWNrU2VsZWN0aW9uKG9mZnNldElmTm9ybWFsLCBvZmZzZXRJZkZvcmNl ZCk7CisgICAgfQorfQorCitpZiAod2luZG93LmludGVybmFscykKKyAgICBpbnRlcm5hbHMuc2V0 dGluZ3Muc2V0RWRpdGluZ0JlaGF2aW9yKCJtYWMiKTsKKworY2xpY2tTaG91bGRSZXN1bHRJblJh bmdlKDQwLCAxMCwgMCwgMSk7CitjbGlja1Nob3VsZFJlc3VsdEluUmFuZ2UoNzAsIDEwLCAwLCAy KTsKKworY2xpY2tTaG91bGRSZXN1bHRJblJhbmdlKDEwLCA1MCwgMiwgMCk7CitjbGlja1Nob3Vs ZFJlc3VsdEluUmFuZ2UoNDAsIDUwLCAyLCAxKTsKKworaWYgKGlzRm9yY2VkICYmIGlzTm9ybWFs KSB7CisgICAgdGVzdEZhaWxlZCgiSW5jb25zaXN0ZW50IGJlaGF2aW9yIG9mIEVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkTW92ZVsuLi5dIik7Cit9CisKKy8vIENsZWFuIHVwIGFmdGVyIG91cnNlbHZl cyBpZiB3ZSdyZSBub3QgYmVpbmcgcnVuIGluIHRoZSBicm93c2VyCitpZiAod2luZG93LmV2ZW50 U2VuZGVyKSB7CisgICAgZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChkaXYpOworfQorCit2YXIg c3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3Vu ZGFyeS1mb3JjZWQtZmFsc2UtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxl Y3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZv cmNlZC1mYWxzZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZjliNjZlZTE3NTRjNWJmMmY4NjFh MTZhZjM1OWY0ZjFmNjk2ODI5ZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3Vu ZGFyeS1mb3JjZWQtZmFsc2UtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTMgQEAKK1Rlc3QgaWYg RWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5Q YXN0VG9wT3JCb3R0b20gaXMgZm9yY2VkIHRvIGZhbHNlLgorCitPbiBzdWNjZXNzLCB5b3Ugd2ls bCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01Q TEVURSIuCisKKworUEFTUyBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVbLi4uXSBub3QgZm9y Y2VkIHRvIGZhbHNlLiBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgp IGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0 OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVb Li4uXSBub3QgZm9yY2VkIHRvIGZhbHNlLiBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmpl Y3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgp IGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBFZGl0aW5nQmVoYXZpb3I6 OnNob3VsZE1vdmVbLi4uXSBub3QgZm9yY2VkIHRvIGZhbHNlLiBTZWxlY3Rpb24gaXMgW2FuY2hv ck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmpl Y3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBFZGl0 aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVbLi4uXSBub3QgZm9yY2VkIHRvIGZhbHNlLiBTZWxlY3Rp b24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMiBmb2N1 c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVl XQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Rlc3QtaWYtc2hvdWxkLW1v dmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuaHRtbCBiL0xheW91 dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9y aXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zM2FlOTU0NGU0 YWM0NTg4ZTNiMjdiZTY5MTc0MmYxYTQzZDlmZTRkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jp em9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1sCkBAIC0wLDAgKzEsMTMgQEAKKzwhRE9D VFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+ Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwv c2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9qcy10ZXN0LXNlbGVjdGlvbi1zaGFyZWQu anMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9InNjcmlwdC10ZXN0cy90ZXN0 LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNl LmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10 ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9UZXN0RXhwZWN0YXRpb25zIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9UZXN0RXhwZWN0YXRpb25zCmluZGV4 IGE1ZWNmMzk4OWRiODJjODc2MmQzOWFiMGQzZDU0YTE3NzA3ZmVhOTMuLmE2ZmVmMWRhYmFiOTU4 MDk0YTdjM2ZiM2U3N2YxMmNlMGRiODM5MDEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRm b3JtL2Nocm9taXVtLWFuZHJvaWQvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTEwNCwzICsxMDQs MTIgQEAgZmFzdC9tdWx0aWNvbC9pbWFnZS1pbnNpZGUtbmVzdGVkLWJsb2Nrcy13aXRoLWJvcmRl ci5odG1sIFsgV29udEZpeCBdCiBmYXN0L2xvYWRlci9sb2NhbC1pbWFnZS1mcm9tLWxvY2FsLmh0 bWwgWyBXb250Rml4IF0KIGZhc3QvbG9hZGVyL2xvY2FsLUphdmFTY3JpcHQtZnJvbS1sb2NhbC5o dG1sIFsgV29udEZpeCBdCiBmYXN0L2xvYWRlci9sb2NhbC1DU1MtZnJvbS1sb2NhbC5odG1sIFsg V29udEZpeCBdCisKKyMgT24gQW5kcm9pZCwgRWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3ZlQ2Fy ZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKQorIyBhbHdheXMgcmV0 dXJucyBmYWxzZS4gVGhhdCBicmVha3MgdGhlc2UgdGVzdHMuCisjIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDU1NzQKKyMgVGhpcyBtYXkgYmUgcmV2aXNpdGVkIGFm dGVyIGh0dHA6Ly9jcmJ1Zy5jb20vMTM1OTU5IGlzIGZpbmlzaGVkLgorZWRpdGluZy9zZWxlY3Rp b24vY2xpY2staW4tbWFyZ2lucy1pbnNpZGUtZWRpdGFibGUtZGl2Lmh0bWwgWyBXb250Rml4IF0K K2VkaXRpbmcvc2VsZWN0aW9uL2NsaWNrLWluLXBhZGRpbmctd2l0aC1tdWx0aXBsZS1saW5lLWJv eGVzLmh0bWwgWyBXb250Rml4IF0KK2Zhc3Qvd3JpdGluZy1tb2RlL2ZsaXBwZWQtYmxvY2tzLWhp dC10ZXN0LWxpbmUtZWRnZXMuaHRtbCBbIFdvbnRGaXggXQorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2VkaXRpbmcvc2VsZWN0aW9uL3Rlc3QtaWYt c2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5n L3NlbGVjdGlvbi90ZXN0LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRh cnktZm9yY2VkLWZhbHNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41MWFiNGM4MTQ5MDZjYzhi NjlmM2NjNTZjNTU2MzVmMDdlOTgwYzIyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNob3Vs ZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDEzIEBACitUZXN0IGlmIEVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92 ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tIGlzIGZvcmNlZCB0 byBmYWxzZS4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBt ZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1BBU1MgRWRpdGluZ0Jl aGF2aW9yOjpzaG91bGRNb3ZlWy4uLl0gaXMgZm9yY2VkIHRvIGZhbHNlLiBTZWxlY3Rpb24gaXMg W2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6 IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFT UyBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVbLi4uXSBpcyBmb3JjZWQgdG8gZmFsc2UuIFNl bGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAy IGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6 IHRydWVdCitQQVNTIEVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZVsuLi5dIGlzIGZvcmNlZCB0 byBmYWxzZS4gU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBhbmNo b3JPZmZzZXQ6IDAgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBmb2N1c09mZnNldDogMCBp c0NvbGxhcHNlZDogdHJ1ZV0KK1BBU1MgRWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3ZlWy4uLl0g aXMgZm9yY2VkIHRvIGZhbHNlLiBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4 dF0oWFgpIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3Vz T2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQorCitURVNUIENPTVBMRVRFCisK 184024 2013-01-22 11:31:25 -0800 2013-01-22 14:35:42 -0800 Patch bug-107171-20130122112819.patch text/plain 15726 cjhopman U3VidmVyc2lvbiBSZXZpc2lvbjogMTQwNDQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDhmM2ViNzJkZjU5MDFk OWMyY2U5Y2QyMWVhNzVkOTkxMzY2MjhhYy4uN2Y2ZDNlMDlmOTRkODY3MmJjNTY2ODlhZWY2ZjQ4 MWM2NmQyOWJiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDEzLTAxLTIyICBDaHJp cyBIb3BtYW4gIDxjamhvcG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgc2hvdWxkTW92ZUNh cmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tIHNob3VsZCByZXR1cm4g ZmFsc2Ugb24gQW5kcm9pZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTA3MTcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgVGVzdDogZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJl dC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1sCisKKyAgICAgICAgKiBl ZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yOjpzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0 b20pOgorICAgICAgICBNYWtlIEVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0Wy4uLl0g YWx3YXlzIHJldHVybiBmYWxzZSBvbgorICAgICAgICBDaHJvbWl1bSBBbmRyb2lkLgorCiAyMDEz LTAxLTIyICBDaHJpc3RvcGhlIER1bWV6ICA8Y2hyaXN0b3BoZS5kdW1lekBpbnRlbC5jb20+CiAK ICAgICAgICAgW2dzdHJlYW1lcl0gR3N0QnVzIHNpZ25hbCB3YXRjaCBzaG91bGQgYmUgcmVtb3Zl ZCBvbiBjbGVhbiB1cApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5n QmVoYXZpb3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKaW5k ZXggNTM4ZWUwZThiYzU4NzBlM2MxZTM0Mzk0YWRjMTEwNDc0OWIwNTMwYS4uNmVhYzg1ZjVhNTNk MWZhNzA4ZTNjNGNhZTRhNTk4MjcyNDVhMDk3NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Vk aXRpbmdCZWhhdmlvci5oCkBAIC0zOSw3ICszOSwxNCBAQCBwdWJsaWM6CiAgICAgLy8gV2hlbiBl eHRlbmRpbmcgYSBzZWxlY3Rpb24gYmV5b25kIHRoZSB0b3Agb3IgYm90dG9tIGJvdW5kYXJ5IG9m IGFuIGVkaXRhYmxlIGFyZWEsCiAgICAgLy8gbWFpbnRhaW4gdGhlIGhvcml6b250YWwgcG9zaXRp b24gb24gV2luZG93cyBidXQgZXh0ZW5kIGl0IHRvIHRoZSBib3VuZGFyeSBvZiB0aGUgZWRpdGFi bGUKICAgICAvLyBjb250ZW50IG9uIE1hYy4KLSAgICBib29sIHNob3VsZE1vdmVDYXJldFRvSG9y aXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlw ZSAhPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRU b0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdAorICAgIHsKKyNp ZiBQTEFURk9STShDSFJPTUlVTSkgJiYgZGVmaW5lZChBTkRST0lEKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisjZWxzZQorICAgICAgICByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdXaW5kb3dzQmVo YXZpb3I7CisjZW5kaWYKKyAgICB9CiAKICAgICAvLyBPbiBXaW5kb3dzLCBzZWxlY3Rpb25zIHNo b3VsZCBhbHdheXMgYmUgY29uc2lkZXJlZCBhcyBkaXJlY3Rpb25hbCwgcmVnYXJkbGVzcyBpZiBp dCBpcwogICAgIC8vIG1vdXNlLWJhc2VkIG9yIGtleWJvYXJkLWJhc2VkLgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDg0ODA5 NzA2NDNhZjE3OGRhMmYxYjkwYzZkOTEyYWE3MmU5YzhlNTMuLjBmM2YxNWJmOGEzOWFlYTgxNjA5 Y2IwM2M5NDA2YzgxYzRjMDM2NDggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZwor KysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxMy0wMS0yMiAg Q2hyaXMgSG9wbWFuICA8Y2pob3BtYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIHNob3VsZE1v dmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSBzaG91bGQgcmV0 dXJuIGZhbHNlIG9uIEFuZHJvaWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTEwNzE3MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2NyaXB0LXRlc3RzL3Rlc3QtaWYtc2hv dWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuanM6IEFk ZGVkLgorICAgICAgICAoY2hlY2tTZWxlY3Rpb24pOgorICAgICAgICAoY2xpY2tTaG91bGRSZXN1 bHRJblJhbmdlKToKKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNob3VsZC1t b3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92 ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2VkaXRpbmcvc2VsZWN0aW9uL3Rl c3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFs c2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgVGhpcyB0ZXN0IHVzZXMgbWFjIGVkaXRp bmcgYmVoYXZpb3IgYW5kIGNoZWNrcyB0aGUgYmVoYXZpb3Igb2YKKyAgICAgICAgc2hvdWxkTW92 ZUNhcmV0Wy4uLl0uIE9uIHBsYXRmb3JtcyAoaS5lLiBjaHJvbWl1bS1hbmRyb2lkKSB3aGVyZSB0 aGlzCisgICAgICAgIGZ1bmN0aW9uIGFsd2F5cyByZXR1cm5zIGZhbHNlLCB0aGUgcmVzdWx0cyB3 aWxsIHJlZmxlY3QgdGhhdC4KKworICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQv ZWRpdGluZy9zZWxlY3Rpb24vY2xpY2staW4tbWFyZ2lucy1pbnNpZGUtZWRpdGFibGUtZGl2LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9l ZGl0aW5nL3NlbGVjdGlvbi9jbGljay1pbi1wYWRkaW5nLXdpdGgtbXVsdGlwbGUtbGluZS1ib3hl cy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtLWFuZHJv aWQvZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9u dGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IHBsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQvZmFzdC93cml0aW5nLW1vZGUvZmxpcHBlZC1ibG9j a3MtaGl0LXRlc3QtbGluZS1lZGdlcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICBUaGVz ZSB0ZXN0cyBhbGwgZGVwZW5kIG9uIHNob3VsZE1vdmVDYXJldFsuLi5dIHVzaW5nIHRoZSBwbGF0 Zm9ybQorICAgICAgICBiZWhhdmlvci4gUmViYXNlbGluZSB0aGVzZSBmb3IgdGhlIG5ldyBjaHJv bWl1bS1hbmRyb2lkIGJlaGF2aW9yLgorCiAyMDEzLTAxLTIyICBTaGVyaWZmIEJvdCAgPHdlYmtp dC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91 dCByMTQwNDM1LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVz dC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxz ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNo b3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4xNjA0MTk1YWQ4NzNiZWZlZjAzMWI3YTZlOTg1OWVlNjdlMTY3 ZTk3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVz dC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxz ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyBpZiBFZGl0aW5nQmVo YXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJv dHRvbSBpcyBhbHdheXMgdHJ1ZSAocmVnYXJkbGVzcyBvZiBwbGF0Zm9ybSkuIElmIHRoaXMgZnVu Y3Rpb24gdXNlcyB0aGUgcGxhdGZvcm0gZWRpdGluZyBiZWhhdmlvciwgdGhlIGNhcmV0IGxvY2F0 aW9uIHdpbGwgYmUgYXQgb2Zmc2V0IDAgYWZ0ZXIgY2xpY2tpbmcgaW4gdGhlIHRvcCByaWdodCwg YW5kIGF0IG9mZnNldCAyIGFmdGVyIGNsaWNraW5nIGluIHRoZSBib3R0b20gbGVmdC4gSWYgdGhl IGZ1bmN0aW9uIGFsd2F5cyByZXR1cm5zIHRydWUsIHRoZSBvZmZzZXRzIHdpbGwgYmUgc3dhcHBl ZCAoMiB0aGVuIDApLgorCitjbGlja0F0KDc4MiwgOTQpCitDYXJldCBsb2NhdGlvbjogW29iamVj dCBUZXh0XSBYWCAwCitjbGlja0F0KDE4LCAxMzQpCitDYXJldCBsb2NhdGlvbjogW29iamVjdCBU ZXh0XSBYWCAyCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExF VEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1z aG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1s IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJl dC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjJk YTI1ODFkZTY1YWMyMDZlMWQxMmRjNjI5NmMxOWMzMmYwYjA5ZWYKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNob3VsZC1tb3ZlLWNhcmV0 LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLmh0bWwKQEAgLTAsMCArMSw1MiBA QAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+ Cis8aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKyAgPHAgaWQ9ImRlc2NyaXB0aW9uIj4K KyAgICBUaGlzIHRlc3RzIGlmCisgICAgRWRpdGluZ0JlaGF2aW9yOjpzaG91bGRNb3ZlQ2FyZXRU b0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20gaXMKKyAgICBhbHdheXMgdHJ1 ZSAocmVnYXJkbGVzcyBvZiBwbGF0Zm9ybSkuICBJZiB0aGlzIGZ1bmN0aW9uIHVzZXMgdGhlIHBs YXRmb3JtCisgICAgZWRpdGluZyBiZWhhdmlvciwgdGhlIGNhcmV0IGxvY2F0aW9uIHdpbGwgYmUg YXQgb2Zmc2V0IDAgYWZ0ZXIgY2xpY2tpbmcgaW4KKyAgICB0aGUgdG9wIHJpZ2h0LCBhbmQgYXQg b2Zmc2V0IDIgYWZ0ZXIgY2xpY2tpbmcgaW4gdGhlIGJvdHRvbSBsZWZ0LiAgSWYgdGhlCisgICAg ZnVuY3Rpb24gYWx3YXlzIHJldHVybnMgdHJ1ZSwgdGhlIG9mZnNldHMgd2lsbCBiZSBzd2FwcGVk ICgyIHRoZW4gMCkuCisgIDwvcD4KKzxkaXYgaWQ9ImNsaWNrTm9kZSIgY29udGVudEVkaXRhYmxl PSJ0cnVlIiBzdHlsZT0icGFkZGluZzogMjBweDsgYmFja2dyb3VuZC1jb2xvcjogZ3JlZW47Ij5Y WDwvZGl2PgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHR5cGU9InRleHQvamF2 YXNjcmlwdCI+CisKK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgaW50ZXJuYWxzLnNldHRp bmdzLnNldEVkaXRpbmdCZWhhdmlvcigibWFjIik7Cit9CisKK2Z1bmN0aW9uIGNsaWNrQXQoeCwg eSkgeworICAgIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAgICAgICAgZXZlbnRTZW5kZXIu bW91c2VNb3ZlVG8oeCwgeSk7CisgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlRG93bigpOworICAg ICAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7CisgICAgfQorfQorCitmdW5jdGlvbiBjYXJldExv Y2F0aW9uKCkgeworICAgIHZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CisgICAgcmV0 dXJuIHNlbC5hbmNob3JOb2RlICsgIiAiICsgc2VsLmFuY2hvck5vZGUuZGF0YSArICIgIiArIHNl bC5hbmNob3JPZmZzZXQ7Cit9CisKK3ZhciBub2RlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo ImNsaWNrTm9kZSIpOwordmFyIG9mZnNldExlZnQgPSBub2RlLm9mZnNldExlZnQsIG9mZnNldFJp Z2h0ID0gb2Zmc2V0TGVmdCArIG5vZGUuY2xpZW50V2lkdGg7Cit2YXIgb2Zmc2V0VG9wID0gbm9k ZS5vZmZzZXRUb3AsIG9mZnNldEJvdHRvbSA9IG9mZnNldFRvcCArIG5vZGUuY2xpZW50SGVpZ2h0 OworCitldmFsQW5kTG9nKCJjbGlja0F0KCIgKyAob2Zmc2V0UmlnaHQgLSAxMCkgKyAiLCAiICsg KG9mZnNldFRvcCArIDEwKSArICIpIik7CitkZWJ1ZygiQ2FyZXQgbG9jYXRpb246ICIgKyBjYXJl dExvY2F0aW9uKCkpOworZXZhbEFuZExvZygiY2xpY2tBdCgiICsgKG9mZnNldExlZnQgKyAxMCkg KyAiLCAiICsgKG9mZnNldEJvdHRvbSAtIDEwKSArICIpIik7CitkZWJ1ZygiQ2FyZXQgbG9jYXRp b246ICIgKyBjYXJldExvY2F0aW9uKCkpOworCitpZiAod2luZG93LmV2ZW50U2VuZGVyKSB7Cisg ICAgZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY2xp Y2tOb2RlIikpOworfQorCis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jl c291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5nL3Nl bGVjdGlvbi9jbGljay1pbi1tYXJnaW5zLWluc2lkZS1lZGl0YWJsZS1kaXYtZXhwZWN0ZWQudHh0 IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5nL3NlbGVjdGlv bi9jbGljay1pbi1tYXJnaW5zLWluc2lkZS1lZGl0YWJsZS1kaXYtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjhmOTBmNjAwYzUzYjA1OTAyMmY3ZWIxYjJhNThjMDBkNGQ3N2JiZTEKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2VkaXRpbmcv c2VsZWN0aW9uL2NsaWNrLWluLW1hcmdpbnMtaW5zaWRlLWVkaXRhYmxlLWRpdi1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSwzNyBAQAorRW5zdXJlIGN1cnNvciBwbGFjZW1lbnQgbWF0Y2hlcyBJRTYv SUU3L0ZGMyB3aGVuIGNsaWNraW5nIGFib3ZlL2JlbG93IGxpbmVzIGluIHBhZGRpbmcuCisKK09u IHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxv d2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9k ZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVjdCBU ZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6IHRydWVdCitGQUlMIFNlbGVjdGlv biBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAxIGZvY3Vz Tm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDEgaXNDb2xsYXBzZWQ6IHRydWVd IHNob3VsZCBiZSBhdCBhbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdIGFuY2hvck9mZnNldDogMCBm b2N1c05vZGU6IFtvYmplY3QgVGV4dF0gZm9jdXNPZmZzZXQ6IDAKK0ZBSUwgU2VsZWN0aW9uIGlz IFthbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBhbmNob3JPZmZzZXQ6IDIgZm9jdXNOb2Rl OiBbb2JqZWN0IFRleHRdKFhYKSBmb2N1c09mZnNldDogMiBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hv dWxkIGJlIGF0IGFuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAwIGZvY3Vz Tm9kZTogW29iamVjdCBUZXh0XSBmb2N1c09mZnNldDogMAorUEFTUyBTZWxlY3Rpb24gaXMgW2Fu Y2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtv YmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBT ZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDog MiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFwc2Vk OiB0cnVlXQorRkFJTCBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgp IGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0 OiAwIGlzQ29sbGFwc2VkOiB0cnVlXSBzaG91bGQgYmUgYXQgYW5jaG9yTm9kZTogW29iamVjdCBU ZXh0XSBhbmNob3JPZmZzZXQ6IDIgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdIGZvY3VzT2Zmc2V0 OiAyCitGQUlMIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5j aG9yT2Zmc2V0OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDEg aXNDb2xsYXBzZWQ6IHRydWVdIHNob3VsZCBiZSBhdCBhbmNob3JOb2RlOiBbb2JqZWN0IFRleHRd IGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0gZm9jdXNPZmZzZXQ6IDIK K1BBU1MgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBhbmNob3JP ZmZzZXQ6IDIgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBmb2N1c09mZnNldDogMiBpc0Nv bGxhcHNlZDogdHJ1ZV0KK1BBU1MgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0IFRl eHRdKFlZKSBhbmNob3JPZmZzZXQ6IDAgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKFlZKSBmb2N1 c09mZnNldDogMCBpc0NvbGxhcHNlZDogdHJ1ZV0KK0ZBSUwgU2VsZWN0aW9uIGlzIFthbmNob3JO b2RlOiBbb2JqZWN0IFRleHRdKFlZKSBhbmNob3JPZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0 IFRleHRdKFlZKSBmb2N1c09mZnNldDogMSBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hvdWxkIGJlIGF0 IGFuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29i amVjdCBUZXh0XSBmb2N1c09mZnNldDogMAorRkFJTCBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6 IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4 dF0oWVkpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVlXSBzaG91bGQgYmUgYXQgYW5j aG9yTm9kZTogW29iamVjdCBUZXh0XSBhbmNob3JPZmZzZXQ6IDAgZm9jdXNOb2RlOiBbb2JqZWN0 IFRleHRdIGZvY3VzT2Zmc2V0OiAwCitGQUlMIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29i amVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShZ WSkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6IHRydWVdIHNob3VsZCBiZSBhdCBhbmNob3JO b2RlOiBbb2JqZWN0IFRleHRdIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4 dF0gZm9jdXNPZmZzZXQ6IDIKK0ZBSUwgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0 IFRleHRdKFlZKSBhbmNob3JPZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKFlZKSBm b2N1c09mZnNldDogMSBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hvdWxkIGJlIGF0IGFuY2hvck5vZGU6 IFtvYmplY3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XSBm b2N1c09mZnNldDogMgorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4 dF0oWVkpIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGZvY3Vz T2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5v ZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3Qg VGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rp b24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMSBmb2N1 c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVl XQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hv ck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAyIGlz Q29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3Qg VGV4dF0oWFgpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZv Y3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hv ck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmpl Y3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxl Y3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMCBm b2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0 cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFu Y2hvck9mZnNldDogMSBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAx IGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmpl Y3QgVGV4dF0oWFgpIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgp IGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2Fu Y2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtv YmplY3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBT ZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDog MSBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2Vk OiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWVkp IGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0 OiAyIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtv YmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0o WVkpIGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMg W2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6 IFtvYmplY3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFT UyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNl dDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFw c2VkOiB0cnVlXQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBM RVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQv ZWRpdGluZy9zZWxlY3Rpb24vY2xpY2staW4tcGFkZGluZy13aXRoLW11bHRpcGxlLWxpbmUtYm94 ZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9l ZGl0aW5nL3NlbGVjdGlvbi9jbGljay1pbi1wYWRkaW5nLXdpdGgtbXVsdGlwbGUtbGluZS1ib3hl cy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uY2RkOGE0MWUzNzVhYjZmODMyYjhjNjgwYTk3YWMx NDM0NWRhMzE1YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9t aXVtLWFuZHJvaWQvZWRpdGluZy9zZWxlY3Rpb24vY2xpY2staW4tcGFkZGluZy13aXRoLW11bHRp cGxlLWxpbmUtYm94ZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTMgQEAKK0NsaWNrIGFib3Zl L2JlbmVhdGggdGhlIHdvcmQgRk9PLiBOb3RpY2UgaG93IHRoZSBjdXJzb3IgZ29lcyBpbiB0aGUg cmlnaHQgcGxhY2UgKGFmdGVyIHRoZSBsZXR0ZXIgRikuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxs IHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBM RVRFIi4KKworCitGQUlMIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShG T08pIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oRk9PKSBmb2N1c09m ZnNldDogMSBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hvdWxkIGJlIGF0IGFuY2hvck5vZGU6IFtvYmpl Y3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XSBmb2N1c09m ZnNldDogMAorRkFJTCBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oRk9P KSBhbmNob3JPZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKEZPTykgZm9jdXNPZmZz ZXQ6IDEgaXNDb2xsYXBzZWQ6IHRydWVdIHNob3VsZCBiZSBhdCBhbmNob3JOb2RlOiBbb2JqZWN0 IFRleHRdIGFuY2hvck9mZnNldDogMyBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0gZm9jdXNPZmZz ZXQ6IDMKK1BBU1MgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKEZPTykg YW5jaG9yT2Zmc2V0OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShGT08pIGZvY3VzT2Zmc2V0 OiAxIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtv YmplY3QgVGV4dF0oRk9PKSBhbmNob3JPZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRd KEZPTykgZm9jdXNPZmZzZXQ6IDEgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIHN1Y2Nlc3NmdWxs eVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNo b3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQvZWRpdGluZy9z ZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5 LWZvcmNlZC1mYWxzZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNWQ2ODQ4Mjg3NjQxMGZiNDE5 MzA0MmEzMWJjZjk4ZDRlOWUzMmE5MAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2Nocm9taXVtLWFuZHJvaWQvZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQt bW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyBpZiBFZGl0aW5nQmVoYXZpb3I6OnNob3Vs ZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSBpcyBhbHdh eXMgdHJ1ZSAocmVnYXJkbGVzcyBvZiBwbGF0Zm9ybSkuIElmIHRoaXMgZnVuY3Rpb24gdXNlcyB0 aGUgcGxhdGZvcm0gZWRpdGluZyBiZWhhdmlvciwgdGhlIGNhcmV0IGxvY2F0aW9uIHdpbGwgYmUg YXQgb2Zmc2V0IDAgYWZ0ZXIgY2xpY2tpbmcgaW4gdGhlIHRvcCByaWdodCwgYW5kIGF0IG9mZnNl dCAyIGFmdGVyIGNsaWNraW5nIGluIHRoZSBib3R0b20gbGVmdC4gSWYgdGhlIGZ1bmN0aW9uIGFs d2F5cyByZXR1cm5zIHRydWUsIHRoZSBvZmZzZXRzIHdpbGwgYmUgc3dhcHBlZCAoMiB0aGVuIDAp LgorCitjbGlja0F0KDc4MiwgOTQpCitDYXJldCBsb2NhdGlvbjogW29iamVjdCBUZXh0XSBYWCAy CitjbGlja0F0KDE4LCAxMzQpCitDYXJldCBsb2NhdGlvbjogW29iamVjdCBUZXh0XSBYWCAwCitQ QVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9mYXN0L3dyaXRpbmct bW9kZS9mbGlwcGVkLWJsb2Nrcy1oaXQtdGVzdC1saW5lLWVkZ2VzLWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQvZmFzdC93cml0aW5nLW1vZGUvZmxp cHBlZC1ibG9ja3MtaGl0LXRlc3QtbGluZS1lZGdlcy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u YTRmYmU5ZWZjNGY4MDM3YWRiN2U0ODdlNWVmMmNiNGZhZDkwN2NlYwotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQvZmFzdC93cml0aW5nLW1v ZGUvZmxpcHBlZC1ibG9ja3MtaGl0LXRlc3QtbGluZS1lZGdlcy1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwxMiBAQAorTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQKK1BBU1M6IG9mZnNldCBhdCAo MTAwLDEwNSkgd2FzIDQuCitQQVNTOiBvZmZzZXQgYXQgKDE2MCwxMDUpIHdhcyA1LgorUEFTUzog b2Zmc2V0IGF0ICgxMDAsMTA0KSB3YXMgMTAuCitQQVNTOiBvZmZzZXQgYXQgKDE2MCwxMDQpIHdh cyAxMS4KK1BBU1M6IG9mZnNldCBhdCAoNjAsMjYpIHdhcyAyNC4KK1BBU1M6IG9mZnNldCBhdCAo MTYwLDI2KSB3YXMgMjYuCitQQVNTOiBvZmZzZXQgYXQgKDYwLDI1KSB3YXMgMjQuCitQQVNTOiBv ZmZzZXQgYXQgKDE2MCwyNSkgd2FzIDI2LgorRkFJTDogb2Zmc2V0IGF0ICg2MCwyNCkgd2FzIDI0 LiBFeHBlY3RlZCAyNi4KK1BBU1M6IG9mZnNldCBhdCAoMTYwLDI0KSB3YXMgMjYuCisK 184048 2013-01-22 14:35:46 -0800 2013-01-22 15:32:48 -0800 Patch bug-107171-20130122143240.patch text/plain 15859 cjhopman U3VidmVyc2lvbiBSZXZpc2lvbjogMTQwNDQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDhmM2ViNzJkZjU5MDFk OWMyY2U5Y2QyMWVhNzVkOTkxMzY2MjhhYy4uN2Y2ZDNlMDlmOTRkODY3MmJjNTY2ODlhZWY2ZjQ4 MWM2NmQyOWJiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDEzLTAxLTIyICBDaHJp cyBIb3BtYW4gIDxjamhvcG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgc2hvdWxkTW92ZUNh cmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9yQm90dG9tIHNob3VsZCByZXR1cm4g ZmFsc2Ugb24gQW5kcm9pZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTA3MTcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgVGVzdDogZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJl dC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1sCisKKyAgICAgICAgKiBl ZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0JlaGF2 aW9yOjpzaG91bGRNb3ZlQ2FyZXRUb0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0 b20pOgorICAgICAgICBNYWtlIEVkaXRpbmdCZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0Wy4uLl0g YWx3YXlzIHJldHVybiBmYWxzZSBvbgorICAgICAgICBDaHJvbWl1bSBBbmRyb2lkLgorCiAyMDEz LTAxLTIyICBDaHJpc3RvcGhlIER1bWV6ICA8Y2hyaXN0b3BoZS5kdW1lekBpbnRlbC5jb20+CiAK ICAgICAgICAgW2dzdHJlYW1lcl0gR3N0QnVzIHNpZ25hbCB3YXRjaCBzaG91bGQgYmUgcmVtb3Zl ZCBvbiBjbGVhbiB1cApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5n QmVoYXZpb3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKaW5k ZXggNTM4ZWUwZThiYzU4NzBlM2MxZTM0Mzk0YWRjMTEwNDc0OWIwNTMwYS4uNmVhYzg1ZjVhNTNk MWZhNzA4ZTNjNGNhZTRhNTk4MjcyNDVhMDk3NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0Vk aXRpbmdCZWhhdmlvci5oCkBAIC0zOSw3ICszOSwxNCBAQCBwdWJsaWM6CiAgICAgLy8gV2hlbiBl eHRlbmRpbmcgYSBzZWxlY3Rpb24gYmV5b25kIHRoZSB0b3Agb3IgYm90dG9tIGJvdW5kYXJ5IG9m IGFuIGVkaXRhYmxlIGFyZWEsCiAgICAgLy8gbWFpbnRhaW4gdGhlIGhvcml6b250YWwgcG9zaXRp b24gb24gV2luZG93cyBidXQgZXh0ZW5kIGl0IHRvIHRoZSBib3VuZGFyeSBvZiB0aGUgZWRpdGFi bGUKICAgICAvLyBjb250ZW50IG9uIE1hYy4KLSAgICBib29sIHNob3VsZE1vdmVDYXJldFRvSG9y aXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlw ZSAhPSBFZGl0aW5nV2luZG93c0JlaGF2aW9yOyB9CisgICAgYm9vbCBzaG91bGRNb3ZlQ2FyZXRU b0hvcml6b250YWxCb3VuZGFyeVdoZW5QYXN0VG9wT3JCb3R0b20oKSBjb25zdAorICAgIHsKKyNp ZiBQTEFURk9STShDSFJPTUlVTSkgJiYgZGVmaW5lZChBTkRST0lEKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisjZWxzZQorICAgICAgICByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdXaW5kb3dzQmVo YXZpb3I7CisjZW5kaWYKKyAgICB9CiAKICAgICAvLyBPbiBXaW5kb3dzLCBzZWxlY3Rpb25zIHNo b3VsZCBhbHdheXMgYmUgY29uc2lkZXJlZCBhcyBkaXJlY3Rpb25hbCwgcmVnYXJkbGVzcyBpZiBp dCBpcwogICAgIC8vIG1vdXNlLWJhc2VkIG9yIGtleWJvYXJkLWJhc2VkLgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDg0ODA5 NzA2NDNhZjE3OGRhMmYxYjkwYzZkOTEyYWE3MmU5YzhlNTMuLjBmM2YxNWJmOGEzOWFlYTgxNjA5 Y2IwM2M5NDA2YzgxYzRjMDM2NDggMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZwor KysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxMy0wMS0yMiAg Q2hyaXMgSG9wbWFuICA8Y2pob3BtYW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIHNob3VsZE1v dmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSBzaG91bGQgcmV0 dXJuIGZhbHNlIG9uIEFuZHJvaWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTEwNzE3MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vc2NyaXB0LXRlc3RzL3Rlc3QtaWYtc2hv dWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuanM6IEFk ZGVkLgorICAgICAgICAoY2hlY2tTZWxlY3Rpb24pOgorICAgICAgICAoY2xpY2tTaG91bGRSZXN1 bHRJblJhbmdlKToKKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNob3VsZC1t b3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92 ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2VkaXRpbmcvc2VsZWN0aW9uL3Rl c3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFs c2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgVGhpcyB0ZXN0IHVzZXMgbWFjIGVkaXRp bmcgYmVoYXZpb3IgYW5kIGNoZWNrcyB0aGUgYmVoYXZpb3Igb2YKKyAgICAgICAgc2hvdWxkTW92 ZUNhcmV0Wy4uLl0uIE9uIHBsYXRmb3JtcyAoaS5lLiBjaHJvbWl1bS1hbmRyb2lkKSB3aGVyZSB0 aGlzCisgICAgICAgIGZ1bmN0aW9uIGFsd2F5cyByZXR1cm5zIGZhbHNlLCB0aGUgcmVzdWx0cyB3 aWxsIHJlZmxlY3QgdGhhdC4KKworICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQv ZWRpdGluZy9zZWxlY3Rpb24vY2xpY2staW4tbWFyZ2lucy1pbnNpZGUtZWRpdGFibGUtZGl2LWV4 cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9l ZGl0aW5nL3NlbGVjdGlvbi9jbGljay1pbi1wYWRkaW5nLXdpdGgtbXVsdGlwbGUtbGluZS1ib3hl cy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtLWFuZHJv aWQvZWRpdGluZy9zZWxlY3Rpb24vdGVzdC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9u dGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxzZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IHBsYXRmb3JtL2Nocm9taXVtLWFuZHJvaWQvZmFzdC93cml0aW5nLW1vZGUvZmxpcHBlZC1ibG9j a3MtaGl0LXRlc3QtbGluZS1lZGdlcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICBUaGVz ZSB0ZXN0cyBhbGwgZGVwZW5kIG9uIHNob3VsZE1vdmVDYXJldFsuLi5dIHVzaW5nIHRoZSBwbGF0 Zm9ybQorICAgICAgICBiZWhhdmlvci4gUmViYXNlbGluZSB0aGVzZSBmb3IgdGhlIG5ldyBjaHJv bWl1bS1hbmRyb2lkIGJlaGF2aW9yLgorCiAyMDEzLTAxLTIyICBTaGVyaWZmIEJvdCAgPHdlYmtp dC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91 dCByMTQwNDM1LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVz dC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxz ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNo b3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4zMDhhMWIyYmI4MzhlOWMxNDZkNjU1MzFkMDEzYTFhNjE0MzM4 NGRhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vdGVz dC1pZi1zaG91bGQtbW92ZS1jYXJldC10by1ob3Jpem9udGFsLWJvdW5kYXJ5LWZvcmNlZC1mYWxz ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMCBAQAorVGhpcyB0ZXN0cyBpZiBFZGl0aW5nQmVo YXZpb3I6OnNob3VsZE1vdmVDYXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJv dHRvbSBpcyBhbHdheXMgdHJ1ZSAocmVnYXJkbGVzcyBvZiBwbGF0Zm9ybSkuIElmIHRoaXMgZnVu Y3Rpb24gdXNlcyB0aGUgcGxhdGZvcm0gZWRpdGluZyBiZWhhdmlvciwgdGhlIGNhcmV0IGxvY2F0 aW9uIHdpbGwgYmUgYXQgb2Zmc2V0IDAgYWZ0ZXIgY2xpY2tpbmcgaW4gdGhlIHRvcCByaWdodCwg YW5kIGF0IG9mZnNldCAyIGFmdGVyIGNsaWNraW5nIGluIHRoZSBib3R0b20gbGVmdC4gSWYgdGhl IGZ1bmN0aW9uIGFsd2F5cyByZXR1cm5zIHRydWUsIHRoZSBvZmZzZXRzIHdpbGwgYmUgc3dhcHBl ZCAoMiB0aGVuIDApLgorCitjbGlja0F0KG9mZnNldFJpZ2h0IC0gMTAsIG9mZnNldFRvcCArIDEw KQorQ2FyZXQgbG9jYXRpb246IFtvYmplY3QgVGV4dF0gWFggMCB0cnVlCitjbGlja0F0KG9mZnNl dExlZnQgKyAxMCwgb2Zmc2V0Qm90dG9tIC0gMTApCitDYXJldCBsb2NhdGlvbjogW29iamVjdCBU ZXh0XSBYWCAyIHRydWUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBD T01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0 LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNl Lmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNob3VsZC1tb3Zl LWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uZTc0MTMzMjA5ZDIwOWY2ZWFkZGNiZDcxZDk0ZWMzMTE3NGJiMTZmOQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUt Y2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3JjZWQtZmFsc2UuaHRtbApAQCAtMCwwICsx LDUyIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8 aHRtbD4KKzxoZWFkPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorICA8cCBpZD0iZGVzY3JpcHRp b24iPgorICAgIFRoaXMgdGVzdHMgaWYKKyAgICBFZGl0aW5nQmVoYXZpb3I6OnNob3VsZE1vdmVD YXJldFRvSG9yaXpvbnRhbEJvdW5kYXJ5V2hlblBhc3RUb3BPckJvdHRvbSBpcworICAgIGFsd2F5 cyB0cnVlIChyZWdhcmRsZXNzIG9mIHBsYXRmb3JtKS4gIElmIHRoaXMgZnVuY3Rpb24gdXNlcyB0 aGUgcGxhdGZvcm0KKyAgICBlZGl0aW5nIGJlaGF2aW9yLCB0aGUgY2FyZXQgbG9jYXRpb24gd2ls bCBiZSBhdCBvZmZzZXQgMCBhZnRlciBjbGlja2luZyBpbgorICAgIHRoZSB0b3AgcmlnaHQsIGFu ZCBhdCBvZmZzZXQgMiBhZnRlciBjbGlja2luZyBpbiB0aGUgYm90dG9tIGxlZnQuICBJZiB0aGUK KyAgICBmdW5jdGlvbiBhbHdheXMgcmV0dXJucyB0cnVlLCB0aGUgb2Zmc2V0cyB3aWxsIGJlIHN3 YXBwZWQgKDIgdGhlbiAwKS4KKyAgPC9wPgorPGRpdiBpZD0iY2xpY2tOb2RlIiBjb250ZW50RWRp dGFibGU9InRydWUiIHN0eWxlPSJwYWRkaW5nOiAyMHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiBncmVl bjsiPlhYPC9kaXY+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4 dC9qYXZhc2NyaXB0Ij4KKworaWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICBpbnRlcm5hbHMu c2V0dGluZ3Muc2V0RWRpdGluZ0JlaGF2aW9yKCJtYWMiKTsKK30KKworZnVuY3Rpb24gY2xpY2tB dCh4LCB5KSB7CisgICAgaWYgKHdpbmRvdy5ldmVudFNlbmRlcikgeworICAgICAgICBldmVudFNl bmRlci5tb3VzZU1vdmVUbyh4LCB5KTsKKyAgICAgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7 CisgICAgICAgIGV2ZW50U2VuZGVyLm1vdXNlVXAoKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIGNh cmV0TG9jYXRpb24oKSB7CisgICAgdmFyIGFuY2hvck5vZGUgPSBnZXRTZWxlY3Rpb24oKS5hbmNo b3JOb2RlOworICAgIHJldHVybiBhbmNob3JOb2RlICsgIiAiICsgYW5jaG9yTm9kZS5kYXRhICsg IiAiICsgZ2V0U2VsZWN0aW9uKCkuYW5jaG9yT2Zmc2V0ICsgIiAiICsgZ2V0U2VsZWN0aW9uKCku aXNDb2xsYXBzZWQ7Cit9CisKK3ZhciBub2RlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNs aWNrTm9kZSIpOwordmFyIG9mZnNldExlZnQgPSBub2RlLm9mZnNldExlZnQsIG9mZnNldFJpZ2h0 ID0gb2Zmc2V0TGVmdCArIG5vZGUuY2xpZW50V2lkdGg7Cit2YXIgb2Zmc2V0VG9wID0gbm9kZS5v ZmZzZXRUb3AsIG9mZnNldEJvdHRvbSA9IG9mZnNldFRvcCArIG5vZGUuY2xpZW50SGVpZ2h0Owor CitldmFsQW5kTG9nKCJjbGlja0F0KG9mZnNldFJpZ2h0IC0gMTAsIG9mZnNldFRvcCArIDEwKSIp OworZGVidWcoIkNhcmV0IGxvY2F0aW9uOiAiICsgY2FyZXRMb2NhdGlvbigpKTsKK2V2YWxBbmRM b2coImNsaWNrQXQob2Zmc2V0TGVmdCArIDEwLCBvZmZzZXRCb3R0b20gLSAxMCkiKTsKK2RlYnVn KCJDYXJldCBsb2NhdGlvbjogIiArIGNhcmV0TG9jYXRpb24oKSk7CisKK2lmICh3aW5kb3cuZXZl bnRTZW5kZXIpIHsKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxkKGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJjbGlja05vZGUiKSk7Cit9CisKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+ Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRy b2lkL2VkaXRpbmcvc2VsZWN0aW9uL2NsaWNrLWluLW1hcmdpbnMtaW5zaWRlLWVkaXRhYmxlLWRp di1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2Vk aXRpbmcvc2VsZWN0aW9uL2NsaWNrLWluLW1hcmdpbnMtaW5zaWRlLWVkaXRhYmxlLWRpdi1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uOGY5MGY2MDBjNTNiMDU5MDIyZjdlYjFiMmE1OGMwMGQ0ZDc3 YmJlMQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWFu ZHJvaWQvZWRpdGluZy9zZWxlY3Rpb24vY2xpY2staW4tbWFyZ2lucy1pbnNpZGUtZWRpdGFibGUt ZGl2LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDM3IEBACitFbnN1cmUgY3Vyc29yIHBsYWNlbWVu dCBtYXRjaGVzIElFNi9JRTcvRkYzIHdoZW4gY2xpY2tpbmcgYWJvdmUvYmVsb3cgbGluZXMgaW4g cGFkZGluZy4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBt ZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1BBU1MgU2VsZWN0aW9u IGlzIFthbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBhbmNob3JPZmZzZXQ6IDAgZm9jdXNO b2RlOiBbb2JqZWN0IFRleHRdKFhYKSBmb2N1c09mZnNldDogMCBpc0NvbGxhcHNlZDogdHJ1ZV0K K0ZBSUwgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBhbmNob3JP ZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBmb2N1c09mZnNldDogMSBpc0Nv bGxhcHNlZDogdHJ1ZV0gc2hvdWxkIGJlIGF0IGFuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0gYW5j aG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XSBmb2N1c09mZnNldDogMAorRkFJ TCBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGFuY2hvck9mZnNl dDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3VzT2Zmc2V0OiAyIGlzQ29sbGFw c2VkOiB0cnVlXSBzaG91bGQgYmUgYXQgYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XSBhbmNob3JP ZmZzZXQ6IDAgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdIGZvY3VzT2Zmc2V0OiAwCitQQVNTIFNl bGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAw IGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6 IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkg YW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6 IDIgaXNDb2xsYXBzZWQ6IHRydWVdCitGQUlMIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29i amVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShY WCkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6IHRydWVdIHNob3VsZCBiZSBhdCBhbmNob3JO b2RlOiBbb2JqZWN0IFRleHRdIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4 dF0gZm9jdXNPZmZzZXQ6IDIKK0ZBSUwgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBbb2JqZWN0 IFRleHRdKFhYKSBhbmNob3JPZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKFhYKSBm b2N1c09mZnNldDogMSBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hvdWxkIGJlIGF0IGFuY2hvck5vZGU6 IFtvYmplY3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XSBm b2N1c09mZnNldDogMgorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4 dF0oWFgpIGFuY2hvck9mZnNldDogMiBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0oWFgpIGZvY3Vz T2Zmc2V0OiAyIGlzQ29sbGFwc2VkOiB0cnVlXQorUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5v ZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMCBmb2N1c05vZGU6IFtvYmplY3Qg VGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAwIGlzQ29sbGFwc2VkOiB0cnVlXQorRkFJTCBTZWxlY3Rp b24gaXMgW2FuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMSBmb2N1 c05vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVl XSBzaG91bGQgYmUgYXQgYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XSBhbmNob3JPZmZzZXQ6IDAg Zm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdIGZvY3VzT2Zmc2V0OiAwCitGQUlMIFNlbGVjdGlvbiBp cyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9k ZTogW29iamVjdCBUZXh0XShZWSkgZm9jdXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6IHRydWVdIHNo b3VsZCBiZSBhdCBhbmNob3JOb2RlOiBbb2JqZWN0IFRleHRdIGFuY2hvck9mZnNldDogMCBmb2N1 c05vZGU6IFtvYmplY3QgVGV4dF0gZm9jdXNPZmZzZXQ6IDAKK0ZBSUwgU2VsZWN0aW9uIGlzIFth bmNob3JOb2RlOiBbb2JqZWN0IFRleHRdKFlZKSBhbmNob3JPZmZzZXQ6IDAgZm9jdXNOb2RlOiBb b2JqZWN0IFRleHRdKFlZKSBmb2N1c09mZnNldDogMCBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hvdWxk IGJlIGF0IGFuY2hvck5vZGU6IFtvYmplY3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9k ZTogW29iamVjdCBUZXh0XSBmb2N1c09mZnNldDogMgorRkFJTCBTZWxlY3Rpb24gaXMgW2FuY2hv ck5vZGU6IFtvYmplY3QgVGV4dF0oWVkpIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6IFtvYmpl Y3QgVGV4dF0oWVkpIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVlXSBzaG91bGQgYmUg YXQgYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XSBhbmNob3JPZmZzZXQ6IDIgZm9jdXNOb2RlOiBb b2JqZWN0IFRleHRdIGZvY3VzT2Zmc2V0OiAyCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9k ZTogW29iamVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBU ZXh0XShZWSkgZm9jdXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlv biBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAwIGZvY3Vz Tm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6IHRydWVd CitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9y T2Zmc2V0OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDEgaXND b2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBU ZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9j dXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9y Tm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVj dCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVj dGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAyIGZv Y3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6IHRy dWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5j aG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDAg aXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVj dCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShYWCkg Zm9jdXNPZmZzZXQ6IDEgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5j aG9yTm9kZTogW29iamVjdCBUZXh0XShYWCkgYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29i amVjdCBUZXh0XShYWCkgZm9jdXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNl bGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0OiAw IGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShZWSkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6 IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShZWSkg YW5jaG9yT2Zmc2V0OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShZWSkgZm9jdXNPZmZzZXQ6 IDEgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29i amVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShZ WSkgZm9jdXNPZmZzZXQ6IDIgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBb YW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0OiAwIGZvY3VzTm9kZTog W29iamVjdCBUZXh0XShZWSkgZm9jdXNPZmZzZXQ6IDAgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNT IFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShZWSkgYW5jaG9yT2Zmc2V0 OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShZWSkgZm9jdXNPZmZzZXQ6IDEgaXNDb2xsYXBz ZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShZ WSkgYW5jaG9yT2Zmc2V0OiAyIGZvY3VzTm9kZTogW29iamVjdCBUZXh0XShZWSkgZm9jdXNPZmZz ZXQ6IDIgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl CisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hy b21pdW0tYW5kcm9pZC9lZGl0aW5nL3NlbGVjdGlvbi9jbGljay1pbi1wYWRkaW5nLXdpdGgtbXVs dGlwbGUtbGluZS1ib3hlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJv bWl1bS1hbmRyb2lkL2VkaXRpbmcvc2VsZWN0aW9uL2NsaWNrLWluLXBhZGRpbmctd2l0aC1tdWx0 aXBsZS1saW5lLWJveGVzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jZGQ4YTQxZTM3NWFiNmY4 MzJiOGM2ODBhOTdhYzE0MzQ1ZGEzMTVhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5nL3NlbGVjdGlvbi9jbGljay1pbi1wYWRk aW5nLXdpdGgtbXVsdGlwbGUtbGluZS1ib3hlcy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxMyBA QAorQ2xpY2sgYWJvdmUvYmVuZWF0aCB0aGUgd29yZCBGT08uIE5vdGljZSBob3cgdGhlIGN1cnNv ciBnb2VzIGluIHRoZSByaWdodCBwbGFjZSAoYWZ0ZXIgdGhlIGxldHRlciBGKS4KKworT24gc3Vj Y2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQg YnkgIlRFU1QgQ09NUExFVEUiLgorCisKK0ZBSUwgU2VsZWN0aW9uIGlzIFthbmNob3JOb2RlOiBb b2JqZWN0IFRleHRdKEZPTykgYW5jaG9yT2Zmc2V0OiAxIGZvY3VzTm9kZTogW29iamVjdCBUZXh0 XShGT08pIGZvY3VzT2Zmc2V0OiAxIGlzQ29sbGFwc2VkOiB0cnVlXSBzaG91bGQgYmUgYXQgYW5j aG9yTm9kZTogW29iamVjdCBUZXh0XSBhbmNob3JPZmZzZXQ6IDAgZm9jdXNOb2RlOiBbb2JqZWN0 IFRleHRdIGZvY3VzT2Zmc2V0OiAwCitGQUlMIFNlbGVjdGlvbiBpcyBbYW5jaG9yTm9kZTogW29i amVjdCBUZXh0XShGT08pIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6IFtvYmplY3QgVGV4dF0o Rk9PKSBmb2N1c09mZnNldDogMSBpc0NvbGxhcHNlZDogdHJ1ZV0gc2hvdWxkIGJlIGF0IGFuY2hv ck5vZGU6IFtvYmplY3QgVGV4dF0gYW5jaG9yT2Zmc2V0OiAzIGZvY3VzTm9kZTogW29iamVjdCBU ZXh0XSBmb2N1c09mZnNldDogMworUEFTUyBTZWxlY3Rpb24gaXMgW2FuY2hvck5vZGU6IFtvYmpl Y3QgVGV4dF0oRk9PKSBhbmNob3JPZmZzZXQ6IDEgZm9jdXNOb2RlOiBbb2JqZWN0IFRleHRdKEZP TykgZm9jdXNPZmZzZXQ6IDEgaXNDb2xsYXBzZWQ6IHRydWVdCitQQVNTIFNlbGVjdGlvbiBpcyBb YW5jaG9yTm9kZTogW29iamVjdCBUZXh0XShGT08pIGFuY2hvck9mZnNldDogMSBmb2N1c05vZGU6 IFtvYmplY3QgVGV4dF0oRk9PKSBmb2N1c09mZnNldDogMSBpc0NvbGxhcHNlZDogdHJ1ZV0KK1BB U1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2VkaXRpbmcvc2VsZWN0 aW9uL3Rlc3QtaWYtc2hvdWxkLW1vdmUtY2FyZXQtdG8taG9yaXpvbnRhbC1ib3VuZGFyeS1mb3Jj ZWQtZmFsc2UtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5k cm9pZC9lZGl0aW5nL3NlbGVjdGlvbi90ZXN0LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6 b250YWwtYm91bmRhcnktZm9yY2VkLWZhbHNlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xZDZm MDZlNDRjZDc2YjE4NGIyMDJhZDhjOTExNjBhYmM5NDQzYmJhCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tYW5kcm9pZC9lZGl0aW5nL3NlbGVjdGlvbi90 ZXN0LWlmLXNob3VsZC1tb3ZlLWNhcmV0LXRvLWhvcml6b250YWwtYm91bmRhcnktZm9yY2VkLWZh bHNlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlzIHRlc3RzIGlmIEVkaXRpbmdC ZWhhdmlvcjo6c2hvdWxkTW92ZUNhcmV0VG9Ib3Jpem9udGFsQm91bmRhcnlXaGVuUGFzdFRvcE9y Qm90dG9tIGlzIGFsd2F5cyB0cnVlIChyZWdhcmRsZXNzIG9mIHBsYXRmb3JtKS4gSWYgdGhpcyBm dW5jdGlvbiB1c2VzIHRoZSBwbGF0Zm9ybSBlZGl0aW5nIGJlaGF2aW9yLCB0aGUgY2FyZXQgbG9j YXRpb24gd2lsbCBiZSBhdCBvZmZzZXQgMCBhZnRlciBjbGlja2luZyBpbiB0aGUgdG9wIHJpZ2h0 LCBhbmQgYXQgb2Zmc2V0IDIgYWZ0ZXIgY2xpY2tpbmcgaW4gdGhlIGJvdHRvbSBsZWZ0LiBJZiB0 aGUgZnVuY3Rpb24gYWx3YXlzIHJldHVybnMgdHJ1ZSwgdGhlIG9mZnNldHMgd2lsbCBiZSBzd2Fw cGVkICgyIHRoZW4gMCkuCisKK2NsaWNrQXQob2Zmc2V0UmlnaHQgLSAxMCwgb2Zmc2V0VG9wICsg MTApCitDYXJldCBsb2NhdGlvbjogW29iamVjdCBUZXh0XSBYWCAyIHRydWUKK2NsaWNrQXQob2Zm c2V0TGVmdCArIDEwLCBvZmZzZXRCb3R0b20gLSAxMCkKK0NhcmV0IGxvY2F0aW9uOiBbb2JqZWN0 IFRleHRdIFhYIDAgdHJ1ZQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNU IENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWFu ZHJvaWQvZmFzdC93cml0aW5nLW1vZGUvZmxpcHBlZC1ibG9ja3MtaGl0LXRlc3QtbGluZS1lZGdl cy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRyb2lkL2Zh c3Qvd3JpdGluZy1tb2RlL2ZsaXBwZWQtYmxvY2tzLWhpdC10ZXN0LWxpbmUtZWRnZXMtZXhwZWN0 ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmE0ZmJlOWVmYzRmODAzN2FkYjdlNDg3ZTVlZjJjYjRmYWQ5MDdj ZWMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1hbmRy b2lkL2Zhc3Qvd3JpdGluZy1tb2RlL2ZsaXBwZWQtYmxvY2tzLWhpdC10ZXN0LWxpbmUtZWRnZXMt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTIgQEAKK0xvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0 CitQQVNTOiBvZmZzZXQgYXQgKDEwMCwxMDUpIHdhcyA0LgorUEFTUzogb2Zmc2V0IGF0ICgxNjAs MTA1KSB3YXMgNS4KK1BBU1M6IG9mZnNldCBhdCAoMTAwLDEwNCkgd2FzIDEwLgorUEFTUzogb2Zm c2V0IGF0ICgxNjAsMTA0KSB3YXMgMTEuCitQQVNTOiBvZmZzZXQgYXQgKDYwLDI2KSB3YXMgMjQu CitQQVNTOiBvZmZzZXQgYXQgKDE2MCwyNikgd2FzIDI2LgorUEFTUzogb2Zmc2V0IGF0ICg2MCwy NSkgd2FzIDI0LgorUEFTUzogb2Zmc2V0IGF0ICgxNjAsMjUpIHdhcyAyNi4KK0ZBSUw6IG9mZnNl dCBhdCAoNjAsMjQpIHdhcyAyNC4gRXhwZWN0ZWQgMjYuCitQQVNTOiBvZmZzZXQgYXQgKDE2MCwy NCkgd2FzIDI2LgorCg==