185253 2018-05-03 08:32:54 -0700 [WPE] Fix build for ENABLE_TOUCH_EVENTS=OFF 2018-05-07 07:18:50 -0700 1 1 1 Unclassified WebKit WPE WebKit WebKit Local Build Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 1 psaavedra webkit-unassigned aperez bugs-noreply cdumez cgarcia clopez keith_miller mcatanzaro zan oldest_to_newest 1420125 0 psaavedra 2018-05-03 08:32:54 -0700 Build with no-touch-events fails: Tools/Scripts/build-webkit --release --wpe --no-touch-events 1420127 1 339408 psaavedra 2018-05-03 08:44:07 -0700 Created attachment 339408 patch 1420130 2 339408 cdumez 2018-05-03 08:51:18 -0700 Comment on attachment 339408 patch View in context: https://bugs.webkit.org/attachment.cgi?id=339408&action=review > Source/WebKit/ChangeLog:6 > + This commit is a port of r190987 committed for GTK platform This should come below the review by line. > Source/WebKit/ChangeLog:7 > + (http://trac.webkit.org/changeset/190987) to WPE Missing period at the end. > Source/WebKit/ChangeLog:9 > + Reviewed by NOBODY (OOPS!). This should be above the commit message. > Source/WebKit/UIProcess/API/wpe/WPEView.cpp:34 > +#if ENABLE(TOUCH_EVENTS) Should be moved below other includes: #include <wpe/wpe.h> #if ENABLE(TOUCH_EVENTS) #include "NativeWebTouchEvent.h" #endif > Tools/ChangeLog:6 > + This commit is a port of r190987 committed for GTK platform Same comments as for other changelog. 1420132 3 339408 mcatanzaro 2018-05-03 08:53:44 -0700 Comment on attachment 339408 patch View in context: https://bugs.webkit.org/attachment.cgi?id=339408&action=review One more style nit: > Source/WebKit/Shared/wpe/NativeWebTouchEventWPE.cpp:29 > +#if ENABLE(TOUCH_EVENTS) Leave one blank line below here... > Source/WebKit/Shared/wpe/NativeWebTouchEventWPE.cpp:48 > +#endif // ENABLE(TOUCH_EVENTS) ...and one above here. 1420150 4 339414 psaavedra 2018-05-03 09:20:05 -0700 Created attachment 339414 patch 1420154 5 339415 psaavedra 2018-05-03 09:25:35 -0700 Created attachment 339415 patch 1420190 6 339415 mcatanzaro 2018-05-03 10:04:58 -0700 Comment on attachment 339415 patch Ooops, one more thing. I notice that ENABLE_TOUCH_EVENTS is actually forced on in OptionsWPE.cmake: WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PRIVATE ON) If we want to allow disabling touch support, that should be changed from PRIVATE to PUBLIC, and moved to the list of public options. And Zan should be the one to approve that. I guess there's not really any strong reason to support disabling touch events currently, because it doesn't add any new dependency. 1420245 7 psaavedra 2018-05-03 11:48:43 -0700 (In reply to Michael Catanzaro from comment #6) > Comment on attachment 339415 [details] > patch > > Ooops, one more thing. I notice that ENABLE_TOUCH_EVENTS is actually forced > on in OptionsWPE.cmake: > > WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PRIVATE ON) > > If we want to allow disabling touch support, that should be changed from > PRIVATE to PUBLIC, and moved to the list of public options. And Zan should > be the one to approve that. > > I guess there's not really any strong reason to support disabling touch > events currently, because it doesn't add any new dependency. I agree with your point. ... but curiously, this is not working as someone can expect: * Build latest Webkit with: Tools/Scripts/build-webkit --release --wpe --no-touch-events This generates a cmakeconfig which honors the --no-touch-events flag: #define ENABLE_TOUCH_EVENTS 0 #define ENABLE_TOUCH_SLIDER 0 (in the WebKitBuild/Release/cmakeconfig.h) //Toggle Touch Events support ENABLE_TOUCH_EVENTS:BOOL=OFF //Toggle Touch Slider support ENABLE_TOUCH_SLIDER:BOOL=OFF (in WebKitBuild/Release/CMakeCache.txt) Not sure about which is the reason of this buggy behavior. Anyway, for correctness and consistency: These are the default values: grep -r -e "(ENABLE_TOUCH_EVENTS " * cmake/OptionsGTK.cmake:WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PUBLIC ON) cmake/WebKitFeatures.cmake: WEBKIT_OPTION_DEFINE(ENABLE_TOUCH_EVENTS "Toggle Touch Events support" PRIVATE OFF) cmake/OptionsMac.cmake:WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PRIVATE OFF) cmake/OptionsWPE.cmake:WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PRIVATE ON) Should I also change `cmake/OptionsWPE.cmake` as follows?: cmake/OptionsWPE.cmake:WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PUBLIC ON) 1420256 8 mcatanzaro 2018-05-03 12:13:52 -0700 (In reply to Pablo Saavedra from comment #7) > * Build latest Webkit with: > > Tools/Scripts/build-webkit --release --wpe --no-touch-events Ah, those flags are not actually expected to work. The build-webkit level features list (FeatureList.pm) contains a subset of features that is not kept in sync with the real features list (in WebKitFeatures.cmake), and changing the values of the options it exposes is almost never supported. It'd be good to remove all these build-webkit flags to avoid confusion. > Should I also change `cmake/OptionsWPE.cmake` as follows?: Yes: (In reply to Michael Catanzaro from comment #6) > If we want to allow disabling touch support, that should be changed from > PRIVATE to PUBLIC, and moved to the list of public options. And Zan should > be the one to approve that. 1420328 9 clopez 2018-05-03 14:10:01 -0700 (In reply to Michael Catanzaro from comment #6) > Comment on attachment 339415 [details] > patch > > Ooops, one more thing. I notice that ENABLE_TOUCH_EVENTS is actually forced > on in OptionsWPE.cmake: > > WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_TOUCH_EVENTS PRIVATE ON) > > If we want to allow disabling touch support, that should be changed from > PRIVATE to PUBLIC, and moved to the list of public options. And Zan should > be the one to approve that. > > I guess there's not really any strong reason to support disabling touch > events currently, because it doesn't add any new dependency. Sorry, I don't agree with you at all This comes from the meta-wpe and meta-webkit recipe that provide this as configurable, as many other options that are not cmake public options. One thing is fixing the build with a private option disabled, and another one is moving the build option from public to private. Following your reasoning we should remove all the private cmake config options. I don't buy that, neither I think is a good idea. 1420333 10 clopez 2018-05-03 14:23:01 -0700 (In reply to Carlos Alberto Lopez Perez from comment #9) > One thing is fixing the build with a private option disabled, and another > one is moving the build option from public to private. > ......... ^ I meant: "and another one is moving the build option from private to public." 1420391 11 mcatanzaro 2018-05-03 16:04:18 -0700 (In reply to Carlos Alberto Lopez Perez from comment #9) > Following your reasoning we should remove all the private cmake config > options. I don't buy that, neither I think is a good idea. There's no point in having option visibility at all if we ignore the rules. It's simply not practical to expect that arbitrary ports build with arbitrary configurations of the 100+ private options defined in WebKitFeatures.cmake. It's definitely wrong for meta-webkit to expose PRIVATE options. If the options are interesting to expose, they should almost surely be made PUBLIC. (Again, this should be approved by Zan.) Otherwise, they should be removed from meta-webkit. If you want to support disabling ENABLE_TOUCH_EVENTS for WPE, you should make it PUBLIC. Otherwise, it's IMO wrong to add ENABLE_TOUCH_EVENT conditions in WPE-specific files. In the past, we've actively removed such conditions after discovering that the option is PRIVATE. Having such conditions creates the false impression that both codepaths are supported. Exposing options should be done with care; we have way too many with GTK, and don't want to repeat that mistake for WPE. Previously, for WPE we've often taken the approach that options should be PRIVATE unless making them PUBLIC allows disabling a dependency (e.g. ENABLE_XSLT). In contrast, it's not clear why you would ever want to disable touch event support. Don't say "because the target device has no touchscreen," because disabling ENABLE_TOUCH_EVENTS doesn't avoid any dependency, and there's hardly any code supporting it, so the impact on binary size is probably unnoticeable, so there's probably no good motivation to disable it even if touch events will never be generated. There should be a good reason to expose such options. (That said, I don't have a strong opinion about this; if Zan wants ENABLE_TOUCH_EVENTS to be PUBLIC, then that's fine with me.) 1420393 12 mcatanzaro 2018-05-03 16:06:19 -0700 (In reply to Michael Catanzaro from comment #11) > (That said, I don't have a strong opinion about this; if Zan wants > ENABLE_TOUCH_EVENTS to be PUBLIC, then that's fine with me.) Basically the tradeoffs I see to exposing it are: * Benefits: none(?) * Cost: one more configuration that can (and, obviously, will) often fail to build 1420510 13 clopez 2018-05-03 18:27:44 -0700 (In reply to Michael Catanzaro from comment #12) > (In reply to Michael Catanzaro from comment #11) > > (That said, I don't have a strong opinion about this; if Zan wants > > ENABLE_TOUCH_EVENTS to be PUBLIC, then that's fine with me.) > > Basically the tradeoffs I see to exposing it are: > > * Benefits: none(?) > > * Cost: one more configuration that can (and, obviously, will) often fail to > build I have never argued to make this option public. There is currently a build option (which is private), and building with it its broken. And here is a more than reasonable patch to fix that breakage. I don't know why you are mixing one thing with the other. If we aren't even going to accept patches for fixing the breakage for changing the value of private options, why having this private options at all? What is the point? Why we don't convert all private options to unconditional definitions that can't be changed of value? 1420606 14 psaavedra 2018-05-04 03:09:14 -0700 (In reply to Michael Catanzaro from comment #12) > (In reply to Michael Catanzaro from comment #11) > > (That said, I don't have a strong opinion about this; if Zan wants > > ENABLE_TOUCH_EVENTS to be PUBLIC, then that's fine with me.) > > Basically the tradeoffs I see to exposing it are: > > * Benefits: none(?) > > * Cost: one more configuration that can (and, obviously, will) often fail to > build What you usually refers like PUBLIC/PRIVATE is translated in cmake advance variables: option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) if (NOT ${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) mark_as_advanced(FORCE ${_name}) endif () (L257 in cmake/WebKitFeatures.cmake) This doesn't means you can't set this value in advanced mode, right? mark_as_advanced([CLEAR|FORCE] VAR [VAR2 ...]) Mark the named cached variables as advanced. An advanced variable will not be displayed in any of the cmake GUIs unless the show advanced option is on. If CLEAR is the first argument advanced variables are changed back to unadvanced. If FORCE is the first argument, then the variable is made advanced. If neither FORCE nor CLEAR is specified, new values will be marked as advanced, but if the variable already has an advanced/non-advanced state, it will not be changed. I'd suggest keep the option as PRIVATE (as in the current version of the patch) and allowing the advance users activate/deactivate this flag. It makes more sense to me. In opposite, if you don't prefer don't support touch events set to OFF, then I'd prefer inhibit set this as true with something like: SET_AND_EXPOSE_TO_BUILD(ENABLE_TOUCH_EVENTS TRUE) Anyway, I see interested enough keep the choice to swap off/on the touch events feature. ref: https://cmake.org/cmake/help/v3.0/command/mark_as_advanced.html 1420689 15 mcatanzaro 2018-05-04 09:20:12 -0700 I am going to leave a rather long comment here, because I designed the option visibility system, and have some strong opinions as to how it ought to work. When I added option visibility in bug #143572 and bug #143831 and bug #143558, I was trying to communicate to users that the PRIVATE/ADVANCED options should not be expected to work, but I never considered that it might be better to just remove the options entirely. At the time, our build system was fairly ad-hoc, the options list was huge, and distributors were building WebKit with many different defines that were not even in the options list. We've come quite a long way since then. I think there have been a lot of benefits to removing port-specific code backing PRIVATE options, so I will *very* strongly recommend that, if we land this, the patch should make ENABLE_TOUCH_EVENTS public in the same commit. (In reply to Carlos Alberto Lopez Perez from comment #13) > If we aren't even going to accept patches for fixing the breakage for > changing the value of private options, why having this private options at > all? What is the point? Because it's an option that's supported by other WebKit ports (in particular, GTK) and we have a shared WebKitFeatures.cmake file. > Why we don't convert all private options to unconditional definitions that > can't be changed of value? We actually could! The reason we have not is simple: nobody has suggested it to me before. Currently, leaving the options PRIVATE allows for developers to more easily play around with them. We use mark_as_advanced() to ensure that they don't appear in CMake GUIs and to hint that they are unsupported. I always figured that was sufficient to prevent people from trying to use the private options, but every once in a while, somebody tries and winds up filing a bug when one doesn't work. There was a bug related to this just last week (though I can't find it anymore, it was the motivation behind reporting bug #184973). So, back to your question: > Why we don't convert all private options to unconditional definitions that > can't be changed of value? You're right: you have a very strong argument for doing so. We could, for example, change this: option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) if (NOT ${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) mark_as_advanced(FORCE ${_name}) endif () To this: if (${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) endif () And then that would resolve this little debate. The disadvantage being that you would now have to modify the CMake build system if experimenting with the PRIVATE options as a developer. I have no strong preference as to whether we should change this or not. If you want to do it (and it doesn't break other ports' bots), I'll give r=me. (In reply to Pablo Saavedra from comment #14) > What you usually refers like PUBLIC/PRIVATE is translated in cmake advance > variables: > > > option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" > ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) > if (NOT ${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) > mark_as_advanced(FORCE ${_name}) > endif () > > (L257 in cmake/WebKitFeatures.cmake) > > This doesn't means you can't set this value in advanced mode, right? Of course it can be set in advanced mode. > I'd suggest keep the option as PRIVATE (as in the current version of the > patch) and allowing the advance users activate/deactivate this flag. It > makes more sense to me. But look at the list of options. There is no way you can expect all 100 options there to plausibly work in WPE. Probably some will build if toggled, but most likely won't. You're submitting a patch to make it possible to build with only one of these options toggled, out of a list of over 100 other options, where almost all of those are probably still broken. We can conclude that changing hidden, advanced options for arbitrary ports cannot possibly be supported. Why should ENABLE_TOUCH_EVENTS be special? At some point in the future, a developer who doesn't remember this bug will be looking over that file and notice that ENABLE_TOUCH_EVENTS is PRIVATE and ON for WPE, and remove all the conditionals that you've added here, then we'll be back to square one. Worse, this opens the floodgates for more similar "build fix" patches, for the other 100+ options. I would much rather simply not accept patches for the PRIVATE options, or implement Carlos Lopez's suggestion to take away the options entirely. > In opposite, if you don't prefer don't support touch events set to OFF, then > I'd prefer inhibit set this as true with something like: > > SET_AND_EXPOSE_TO_BUILD(ENABLE_TOUCH_EVENTS TRUE) That would be broken, because then you would wind up with ENABLE_TOUCH_EVENTS enabled even if you build with -DENABLE_TOUCH_EVENTS=OFF. --------------------------------------------------------------------------------- OK, now back to the question of whether ENABLE_TOUCH_EVENTS should be PUBLIC or PRIVATE. Since Zan has not weighed in here, I'd be willing to approve a patch that fixes the ENABLE_TOUCH_EVENTS build, if (a) it also makes the option PUBLIC, and if (b) you can state some benefit to disabling the option. > Anyway, I see interested enough keep the choice to swap off/on the touch > events feature. My question is: why the interest? As I wrote above: (In reply to Michael Catanzaro from comment #12) > Basically the tradeoffs I see to exposing it are: > > * Benefits: none(?) > > * Cost: one more configuration that can (and, obviously, will) often fail to > build The cost of exposing the option is clearly larger than none. So there should be some articulable benefit to disabling the option. So here is my challenge to you both: can you state some reason as to why it would be beneficial to disable ENABLE_TOUCH_EVENTS in your build? I'm skeptical that there is any such benefit. Is there a significant reduction in code size? (Highly doubtful.) Compilation time? (Highly doubtful.) Aren't touch events disabled at runtime if the device does not have a touch screen? I think they are for GTK, but if that's not working for WPE, then that might be a very good reason to expose the option as PUBLIC. But you can't find *any* good reason to disable the option, then surely instead of trying to make it work, you should just not use it. 1420693 16 mcatanzaro 2018-05-04 09:23:48 -0700 (In reply to Michael Catanzaro from comment #15) > But you can't find *any* good reason to disable the option, then surely > instead of trying to make it work, you should just not use it. And, conversely, if you *do* have a good reason for using -DENABLE_TOUCH_EVENTS=OFF, then surely it should be made PUBLIC so that others can see it and benefit from it. 1420694 17 mcatanzaro 2018-05-04 09:26:48 -0700 Oops, I meant to write: "But *if* you can't find any good reason to disable the option" 1421241 18 psaavedra 2018-05-07 02:50:32 -0700 Thanks for this pretty good explanation of the reasons behind PRIVATE/PUBLIC configuration. They seem convincing to me and I have no objections at this point. Of course, they are not reasonable reasons to make public this flag. I'm talking about in terms of disk, memory or performance optimizations. Even in terms of dependencies or so. I'd agree with to close this issue with a WONTFIX or equivalent. Let me share to you my congratulations with work done in this part. Maybe I'd suggest align the available flags in build-webkit Perl script respect the CMakelist options but this is of course another issue. Let me know if looks interesting enough for you. I could be happy to work on that. For example, implementing different subset of features in the @features list in the webkitperl/FeatureList.pm file. (In reply to Michael Catanzaro from comment #15) > I am going to leave a rather long comment here, because I designed the > option visibility system, and have some strong opinions as to how it ought > to work. When I added option visibility in bug #143572 and bug #143831 and > bug #143558, I was trying to communicate to users that the PRIVATE/ADVANCED > options should not be expected to work, but I never considered that it might > be better to just remove the options entirely. At the time, our build system > was fairly ad-hoc, the options list was huge, and distributors were building > WebKit with many different defines that were not even in the options list. > We've come quite a long way since then. > > I think there have been a lot of benefits to removing port-specific code > backing PRIVATE options, so I will *very* strongly recommend that, if we > land this, the patch should make ENABLE_TOUCH_EVENTS public in the same > commit. > > (In reply to Carlos Alberto Lopez Perez from comment #13) > > If we aren't even going to accept patches for fixing the breakage for > > changing the value of private options, why having this private options at > > all? What is the point? > > Because it's an option that's supported by other WebKit ports (in > particular, GTK) and we have a shared WebKitFeatures.cmake file. > > > Why we don't convert all private options to unconditional definitions that > > can't be changed of value? > > We actually could! The reason we have not is simple: nobody has suggested it > to me before. > > Currently, leaving the options PRIVATE allows for developers to more easily > play around with them. We use mark_as_advanced() to ensure that they don't > appear in CMake GUIs and to hint that they are unsupported. I always figured > that was sufficient to prevent people from trying to use the private > options, but every once in a while, somebody tries and winds up filing a bug > when one doesn't work. There was a bug related to this just last week > (though I can't find it anymore, it was the motivation behind reporting bug > #184973). > > So, back to your question: > > > Why we don't convert all private options to unconditional definitions that > > can't be changed of value? > > You're right: you have a very strong argument for doing so. We could, for > example, change this: > > option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" > ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) > if (NOT ${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) > mark_as_advanced(FORCE ${_name}) > endif () > > To this: > > if (${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) > option(${_name} > "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" > ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) > endif () > > And then that would resolve this little debate. The disadvantage being that > you would now have to modify the CMake build system if experimenting with > the PRIVATE options as a developer. > > I have no strong preference as to whether we should change this or not. If > you want to do it (and it doesn't break other ports' bots), I'll give r=me. > > (In reply to Pablo Saavedra from comment #14) > > What you usually refers like PUBLIC/PRIVATE is translated in cmake advance > > variables: > > > > > > option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" > > ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) > > if (NOT ${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) > > mark_as_advanced(FORCE ${_name}) > > endif () > > > > (L257 in cmake/WebKitFeatures.cmake) > > > > This doesn't means you can't set this value in advanced mode, right? > > Of course it can be set in advanced mode. > > > I'd suggest keep the option as PRIVATE (as in the current version of the > > patch) and allowing the advance users activate/deactivate this flag. It > > makes more sense to me. > > But look at the list of options. There is no way you can expect all 100 > options there to plausibly work in WPE. Probably some will build if toggled, > but most likely won't. You're submitting a patch to make it possible to > build with only one of these options toggled, out of a list of over 100 > other options, where almost all of those are probably still broken. We can > conclude that changing hidden, advanced options for arbitrary ports cannot > possibly be supported. > > Why should ENABLE_TOUCH_EVENTS be special? At some point in the future, a > developer who doesn't remember this bug will be looking over that file and > notice that ENABLE_TOUCH_EVENTS is PRIVATE and ON for WPE, and remove all > the conditionals that you've added here, then we'll be back to square one. > Worse, this opens the floodgates for more similar "build fix" patches, for > the other 100+ options. I would much rather simply not accept patches for > the PRIVATE options, or implement Carlos Lopez's suggestion to take away the > options entirely. > > > In opposite, if you don't prefer don't support touch events set to OFF, then > > I'd prefer inhibit set this as true with something like: > > > > SET_AND_EXPOSE_TO_BUILD(ENABLE_TOUCH_EVENTS TRUE) > > That would be broken, because then you would wind up with > ENABLE_TOUCH_EVENTS enabled even if you build with -DENABLE_TOUCH_EVENTS=OFF. > > ----------------------------------------------------------------------------- > ---- > > OK, now back to the question of whether ENABLE_TOUCH_EVENTS should be PUBLIC > or PRIVATE. Since Zan has not weighed in here, I'd be willing to approve a > patch that fixes the ENABLE_TOUCH_EVENTS build, if (a) it also makes the > option PUBLIC, and if (b) you can state some benefit to disabling the option. > > > Anyway, I see interested enough keep the choice to swap off/on the touch > > events feature. > > My question is: why the interest? As I wrote above: > > (In reply to Michael Catanzaro from comment #12) > > Basically the tradeoffs I see to exposing it are: > > > > * Benefits: none(?) > > > > * Cost: one more configuration that can (and, obviously, will) often fail to > > build > > The cost of exposing the option is clearly larger than none. So there should > be some articulable benefit to disabling the option. So here is my challenge > to you both: can you state some reason as to why it would be beneficial to > disable ENABLE_TOUCH_EVENTS in your build? > > I'm skeptical that there is any such benefit. Is there a significant > reduction in code size? (Highly doubtful.) Compilation time? (Highly > doubtful.) Aren't touch events disabled at runtime if the device does not > have a touch screen? I think they are for GTK, but if that's not working for > WPE, then that might be a very good reason to expose the option as PUBLIC. > But you can't find *any* good reason to disable the option, then surely > instead of trying to make it work, you should just not use it. 1421266 19 mcatanzaro 2018-05-07 07:01:54 -0700 (In reply to Pablo Saavedra from comment #18) > I'd agree with to close this issue with a WONTFIX or equivalent. OK then. > Let me share to you my congratulations with work done in this part. Maybe > I'd suggest align the available flags in build-webkit Perl script respect > the CMakelist options but this is of course another issue. Let me know if > looks interesting enough for you. I could be happy to work on that. For > example, implementing different subset of features in the @features list in > the > webkitperl/FeatureList.pm file. Yeah, I agree this is a problem. Unfortunately, the list of available options is different for different ports, so we can't just remove build options from build-webkit. I think it'd be desirable to remove all the --disable and --enable flags entirely, and require users to use --cmakeargs instead. But I'm not sure if Apple would be OK with that. It's not clear how we might be able to proceed here. Suggestions and assistance would be very welcome. 1421270 20 clopez 2018-05-07 07:12:23 -0700 (In reply to Michael Catanzaro from comment #15) > So, back to your question: > > > Why we don't convert all private options to unconditional definitions that > > can't be changed of value? > > You're right: you have a very strong argument for doing so. We could, for > example, change this: > > option(${_name} "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" > ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) > if (NOT ${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) > mark_as_advanced(FORCE ${_name}) > endif () > > To this: > > if (${_WEBKIT_AVAILABLE_OPTIONS_IS_PUBLIC_${_name}}) > option(${_name} > "${_WEBKIT_AVAILABLE_OPTIONS_DESCRIPTION_${_name}}" > ${_WEBKIT_AVAILABLE_OPTIONS_INITIAL_VALUE_${_name}}) > endif () > > And then that would resolve this little debate. The disadvantage being that > you would now have to modify the CMake build system if experimenting with > the PRIVATE options as a developer. > > I have no strong preference as to whether we should change this or not. If > you want to do it (and it doesn't break other ports' bots), I'll give r=me. > Definitively I think we should not allow to modify build options via a simple cmake switch argument (even if that is somehow hidden) and at the same time not accept patches to fix the breakage when that is modified. So, I think we should make the current private options not options anymore, but unconditional values. Or at least only allow this values to be modified when DEVELOPER_MODE is enabled. At the same time that means we will have to make options that are current private public (like woff2). And that will be better (IMHO) than the current status quo where there are lot of hidden options for which we don't accept patches to fix the breakage (which is kind of an unwritten rule), and where several downstream are toying with this config options. 1421274 21 mcatanzaro 2018-05-07 07:18:50 -0700 That all sounds good to me, if you want to submit a patch in a different bug, or repurpose this one. And good point about making ENABLE_WOFF2 public. I used it for buildroot-wpe in violation of my own rule. 339408 2018-05-03 08:44:07 -0700 2018-05-03 09:19:28 -0700 patch bug-185253-20180503174406.patch text/plain 8192 psaavedra U3VidmVyc2lvbiBSZXZpc2lvbjogMjMxMzA0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDllYWZkYTQ5MDhlYTYwNTYw OTQ3YmRmYTI4Njg2NzZlOTg5YmNmNjkuLjFmNTcxYjU5OTY4ZjE5NWNhYWU1ZDY5N2U1NWJkMDM2 NjI4ODM3NDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTgtMDUtMDMgIFBhYmxvIFNh YXZlZHJhICA8cHNhYXZlZHJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gRml4IGJ1aWxk IGZvciBFTkFCTEVfVE9VQ0hfRVZFTlRTPU9GRgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg1MjUzCisKKyAgICAgICAgVGhpcyBjb21taXQgaXMgYSBw b3J0IG9mIHIxOTA5ODcgY29tbWl0dGVkIGZvciBHVEsgcGxhdGZvcm0KKyAgICAgICAgKGh0dHA6 Ly90cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzE5MDk4NykgdG8gV1BFCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBTaGFyZWQvd3BlL05hdGl2ZVdl YlRvdWNoRXZlbnRXUEUuY3BwOgorICAgICAgICAqIFNoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5 LmNwcDoKKyAgICAgICAgKiBTaGFyZWQvd3BlL1dlYkV2ZW50RmFjdG9yeS5oOgorICAgICAgICAq IFVJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKiBVSVByb2Nl c3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1wbC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvd3Bl L1dQRVZpZXcuY3BwOgorICAgICAgICAoV0tXUEU6Om1fYmFja2VuZCk6CisKIDIwMTgtMDUtMDMg IEJyZW50IEZ1bGdoYW0gIDxiZnVsZ2hhbUBhcHBsZS5jb20+CiAKICAgICAgICAgUmUtZW5lYWJs ZSBOZXR3b3JrIEV4dGVuc2lvbiBzdXBwb3J0IGluIHRoZSBXZWJDb250ZW50IHByb2Nlc3MKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dwZS9OYXRpdmVXZWJUb3VjaEV2ZW50V1BF LmNwcCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dwZS9OYXRpdmVXZWJUb3VjaEV2ZW50V1BFLmNw cAppbmRleCAwY2M2NjU4Y2ZiNzUzNGU4NWQwMTU4MzZmNWRkNGRjMGZmN2QxM2Q4Li5lNWNjZmFm MTM5Y2MzMWI1MTUwYWFlZDE1ZWQyNTBhNDA3M2FhZTA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L1NoYXJlZC93cGUvTmF0aXZlV2ViVG91Y2hFdmVudFdQRS5jcHAKKysrIGIvU291cmNlL1dl YktpdC9TaGFyZWQvd3BlL05hdGl2ZVdlYlRvdWNoRXZlbnRXUEUuY3BwCkBAIC0yNiw2ICsyNiw3 IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5o IgogCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKICNpbmNsdWRlICJXZWJFdmVudEZhY3Rvcnku aCIKIAogbmFtZXNwYWNlIFdlYktpdCB7CkBAIC00NCwzICs0NSw0IEBAIE5hdGl2ZVdlYlRvdWNo RXZlbnQ6Ok5hdGl2ZVdlYlRvdWNoRXZlbnQoc3RydWN0IHdwZV9pbnB1dF90b3VjaF9ldmVudCog ZXZlbnQsIGZsCiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAorI2VuZGlmIC8vIEVOQUJMRShU T1VDSF9FVkVOVFMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZl bnRGYWN0b3J5LmNwcCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dwZS9XZWJFdmVudEZhY3Rvcnku Y3BwCmluZGV4IDdjZWFmNjY5N2IyNGIwNjlkYmNmOTZiYzQ4MWIzMDBkNGJlMWZjZmUuLmY2ZDAy ODA0MjIxZmYzY2E5ZDU0YzE5OThmNTI3MTAyZjNkMjUzOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvU2hhcmVkL3dwZS9XZWJFdmVudEZhY3RvcnkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv U2hhcmVkL3dwZS9XZWJFdmVudEZhY3RvcnkuY3BwCkBAIC0xNjgsNiArMTY4LDcgQEAgV2ViV2hl ZWxFdmVudCBXZWJFdmVudEZhY3Rvcnk6OmNyZWF0ZVdlYldoZWVsRXZlbnQoc3RydWN0IHdwZV9p bnB1dF9heGlzX2V2ZW50KgogICAgICAgICBkZWx0YSwgd2hlZWxUaWNrcywgV2ViV2hlZWxFdmVu dDo6U2Nyb2xsQnlQaXhlbFdoZWVsRXZlbnQsIHN0YXRpY19jYXN0PFdlYkV2ZW50OjpNb2RpZmll cnM+KDApLCB3YWxsVGltZUZvckV2ZW50VGltZShldmVudC0+dGltZSkpOwogfQogCisjaWYgRU5B QkxFKFRPVUNIX0VWRU5UUykKIHN0YXRpYyBXZWJLaXQ6OldlYlBsYXRmb3JtVG91Y2hQb2ludDo6 VG91Y2hQb2ludFN0YXRlIHN0YXRlRm9yVG91Y2hQb2ludChpbnQgbWFpbkV2ZW50SWQsIGNvbnN0 IHN0cnVjdCB3cGVfaW5wdXRfdG91Y2hfZXZlbnRfcmF3KiBwb2ludCkKIHsKICAgICBpZiAocG9p bnQtPmlkICE9IG1haW5FdmVudElkKQpAQCAtMjIyLDUgKzIyMyw2IEBAIFdlYlRvdWNoRXZlbnQg V2ViRXZlbnRGYWN0b3J5OjpjcmVhdGVXZWJUb3VjaEV2ZW50KHN0cnVjdCB3cGVfaW5wdXRfdG91 Y2hfZXZlbnQqCiAKICAgICByZXR1cm4gV2ViVG91Y2hFdmVudCh0eXBlLCBXVEZNb3ZlKHRvdWNo UG9pbnRzKSwgV2ViRXZlbnQ6Ok1vZGlmaWVycygwKSwgd2FsbFRpbWVGb3JFdmVudFRpbWUoZXZl bnQtPnRpbWUpKTsKIH0KKyNlbmRpZgogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dwZS9XZWJFdmVudEZhY3RvcnkuaCBiL1NvdXJjZS9X ZWJLaXQvU2hhcmVkL3dwZS9XZWJFdmVudEZhY3RvcnkuaAppbmRleCBhMmFhMDM0NTBkMzhmMzRi MTFjMTJmZmNiMWVmYjUwY2FjMGRmNzkxLi5mNGIwNTUwYjViZTMwNTVlYjIxMDJhMDQwMGUwNjc3 MjJmYzgzYTU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRG YWN0b3J5LmgKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvd3BlL1dlYkV2ZW50RmFjdG9yeS5o CkBAIC0zOSw3ICszOSw5IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgV2ViS2V5Ym9hcmRFdmVudCBj cmVhdGVXZWJLZXlib2FyZEV2ZW50KHN0cnVjdCB3cGVfaW5wdXRfa2V5Ym9hcmRfZXZlbnQqKTsK ICAgICBzdGF0aWMgV2ViTW91c2VFdmVudCBjcmVhdGVXZWJNb3VzZUV2ZW50KHN0cnVjdCB3cGVf aW5wdXRfcG9pbnRlcl9ldmVudCosIGZsb2F0IGRldmljZVNjYWxlRmFjdG9yKTsKICAgICBzdGF0 aWMgV2ViV2hlZWxFdmVudCBjcmVhdGVXZWJXaGVlbEV2ZW50KHN0cnVjdCB3cGVfaW5wdXRfYXhp c19ldmVudCosIGZsb2F0IGRldmljZVNjYWxlRmFjdG9yKTsKKyNpZiBFTkFCTEUoVE9VQ0hfRVZF TlRTKQogICAgIHN0YXRpYyBXZWJUb3VjaEV2ZW50IGNyZWF0ZVdlYlRvdWNoRXZlbnQoc3RydWN0 IHdwZV9pbnB1dF90b3VjaF9ldmVudCosIGZsb2F0IGRldmljZVNjYWxlRmFjdG9yKTsKKyNlbmRp ZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS93cGUvUGFnZUNsaWVudEltcGwuY3BwCmluZGV4IDU5Y2NiNDAxMzNiNzY1MzEz NDZlMGE1MzU4MTcyZWMzYzBmOTE3NjUuLmFkMjQ5YTZiMDBjMDQ5MWUzMWI5ZTc4MTQ0MTcyYjcz NWNjNzFlYjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvUGFn ZUNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvUGFn ZUNsaWVudEltcGwuY3BwCkBAIC0xNzYsNiArMTc2LDcgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbDo6 ZG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCkKIHsK IH0KIAorI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiB2b2lkIFBhZ2VDbGllbnRJbXBsOjpkb25l V2l0aFRvdWNoRXZlbnQoY29uc3QgTmF0aXZlV2ViVG91Y2hFdmVudCYgdG91Y2hFdmVudCwgYm9v bCB3YXNFdmVudEhhbmRsZWQpCiB7CiAgICAgaWYgKHdhc0V2ZW50SGFuZGxlZCkKQEAgLTIyMCw2 ICsyMjEsNyBAQCB2b2lkIFBhZ2VDbGllbnRJbXBsOjpkb25lV2l0aFRvdWNoRXZlbnQoY29uc3Qg TmF0aXZlV2ViVG91Y2hFdmVudCYgdG91Y2hFdmVudCwgYgogCiAgICAgcGFnZS5oYW5kbGVNb3Vz ZUV2ZW50KE5hdGl2ZVdlYk1vdXNlRXZlbnQoJnBvaW50ZXJFdmVudCwgcGFnZS5kZXZpY2VTY2Fs ZUZhY3RvcigpKSk7CiB9CisjZW5kaWYgLy8gRU5BQkxFKFRPVUNIX0VWRU5UUykKIAogdm9pZCBQ YWdlQ2xpZW50SW1wbDo6d2hlZWxFdmVudFdhc05vdEhhbmRsZWRCeVdlYkNvcmUoY29uc3QgTmF0 aXZlV2ViV2hlZWxFdmVudCYpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1BhZ2VDbGllbnRJbXBsLmgKaW5kZXggMTY3ZTU2NTZlMjgwNGFlYTI5MjkwZGUzNDcxMmIx NjYwOWI0Y2JhNy4uYmZiNzY4NDgyNGIzZWU5NWVhMjFlZTc4YjViNWQ0MzhkNmJhOWYyYSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1wbC5o CisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvUGFnZUNsaWVudEltcGwuaApA QCAtNzgsNyArNzgsOSBAQCBwcml2YXRlOgogICAgIFdlYkNvcmU6OkludFJlY3Qgcm9vdFZpZXdU b1NjcmVlbihjb25zdCBXZWJDb3JlOjpJbnRSZWN0Jikgb3ZlcnJpZGU7CiAKICAgICB2b2lkIGRv bmVXaXRoS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJvb2wpIG92ZXJy aWRlOworI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiAgICAgdm9pZCBkb25lV2l0aFRvdWNoRXZl bnQoY29uc3QgTmF0aXZlV2ViVG91Y2hFdmVudCYsIGJvb2wpIG92ZXJyaWRlOworI2VuZGlmCiAg ICAgdm9pZCB3aGVlbEV2ZW50V2FzTm90SGFuZGxlZEJ5V2ViQ29yZShjb25zdCBOYXRpdmVXZWJX aGVlbEV2ZW50Jikgb3ZlcnJpZGU7CiAKICAgICBSZWZQdHI8V2ViUG9wdXBNZW51UHJveHk+IGNy ZWF0ZVBvcHVwTWVudVByb3h5KFdlYlBhZ2VQcm94eSYpIG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XUEVWaWV3LmNwcCBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS93cGUvV1BFVmlldy5jcHAKaW5kZXggNDhkODA0NDEzNWZkM2NjZmVl MWY2OTFkZTgyMDg0NjZmM2NhODdhNS4uNTJmZjFlZjJkYTkwZTEwNDRhYTUyYzRjZDEwMDhjNmRl NTU2YmFhMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XUEVW aWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1dQRVZpZXcuY3Bw CkBAIC0zMSw3ICszMSw5IEBACiAjaW5jbHVkZSAiRHJhd2luZ0FyZWFQcm94eS5oIgogI2luY2x1 ZGUgIk5hdGl2ZVdlYktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJOYXRpdmVXZWJNb3VzZUV2 ZW50LmgiCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKICNpbmNsdWRlICJOYXRpdmVXZWJUb3Vj aEV2ZW50LmgiCisjZW5kaWYgLy8gRU5BQkxFKFRPVUNIX0VWRU5UUykKICNpbmNsdWRlICJOYXRp dmVXZWJXaGVlbEV2ZW50LmgiCiAjaW5jbHVkZSAiV2ViUGFnZUdyb3VwLmgiCiAjaW5jbHVkZSAi V2ViUHJvY2Vzc1Bvb2wuaCIKQEAgLTEyMywxMiArMTI1LDE2IEBAIFZpZXc6OlZpZXcoc3RydWN0 IHdwZV92aWV3X2JhY2tlbmQqIGJhY2tlbmQsIGNvbnN0IEFQSTo6UGFnZUNvbmZpZ3VyYXRpb24m IGJhc2VDCiAgICAgICAgICAgICBhdXRvJiBwYWdlID0gcmVpbnRlcnByZXRfY2FzdDxWaWV3Kj4o ZGF0YSktPnBhZ2UoKTsKICAgICAgICAgICAgIHBhZ2UuaGFuZGxlV2hlZWxFdmVudChXZWJLaXQ6 Ok5hdGl2ZVdlYldoZWVsRXZlbnQoZXZlbnQsIHBhZ2UuZGV2aWNlU2NhbGVGYWN0b3IoKSkpOwog ICAgICAgICB9LAorI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiAgICAgICAgIC8vIGhhbmRsZV90 b3VjaF9ldmVudAogICAgICAgICBbXSh2b2lkKiBkYXRhLCBzdHJ1Y3Qgd3BlX2lucHV0X3RvdWNo X2V2ZW50KiBldmVudCkKICAgICAgICAgewogICAgICAgICAgICAgYXV0byYgcGFnZSA9IHJlaW50 ZXJwcmV0X2Nhc3Q8Vmlldyo+KGRhdGEpLT5wYWdlKCk7CiAgICAgICAgICAgICBwYWdlLmhhbmRs ZVRvdWNoRXZlbnQoV2ViS2l0OjpOYXRpdmVXZWJUb3VjaEV2ZW50KGV2ZW50LCBwYWdlLmRldmlj ZVNjYWxlRmFjdG9yKCkpKTsKICAgICAgICAgfSwKKyNlbHNlCisgICAgICAgIG51bGxwdHIsCisj ZW5kaWYgLy8gRU5BQkxFKFRPVUNIX0VWRU5UUykKICAgICAgICAgLy8gcGFkZGluZwogICAgICAg ICBudWxscHRyLAogICAgICAgICBudWxscHRyLApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDI3YWE3ZGMxM2E1YjZiN2E4ZTViYWNjMDIyNmM5M2Q2 ZjJhZWQyMGYuLmY3M2QwNDVhMjkxNzBiMjFjZmY3YTc4ZDFlZWM5NWZhM2FiZDQyNjUgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NSBAQAorMjAxOC0wNS0wMyAgUGFibG8gU2FhdmVkcmEgIDxwc2FhdmVkcmFAaWdhbGlhLmNvbT4K KworICAgICAgICBbV1BFXSBGaXggYnVpbGQgZm9yIEVOQUJMRV9UT1VDSF9FVkVOVFM9T0ZGCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xODUyNTMKKwor ICAgICAgICBUaGlzIGNvbW1pdCBpcyBhIHBvcnQgb2YgcjE5MDk4NyBjb21taXR0ZWQgZm9yIEdU SyBwbGF0Zm9ybQorICAgICAgICAoaHR0cDovL3RyYWMud2Via2l0Lm9yZy9jaGFuZ2VzZXQvMTkw OTg3KSB0byBXUEUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIFdlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJveHlXUEUuY3BwOgorCiAy MDE4LTA1LTAzICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAog ICAgICAgICBSRUdSRVNTSU9OKHIyMjI3NzIpOiBbR1RLXVtXUEVdIFdlYlByb2Nlc3MgZnJvbSBX ZWJLaXRHdGsrIDIuMTkuOXggU0lHU0VWcyBpbiBXZWJLaXQ6OldlYlByb2Nlc3M6OmVuc3VyZU5l dHdvcmtQcm9jZXNzQ29ubmVjdGlvbigpIGF0IFNvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQ cm9jZXNzLmNwcDoxMTI3CmRpZmYgLS1naXQgYS9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9F dmVudFNlbmRlclByb3h5V1BFLmNwcCBiL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50 U2VuZGVyUHJveHlXUEUuY3BwCmluZGV4IGFhYjExZTc1NTE1NDA4NTUzYjdjZWJlMWNmYjNlNjE1 ZDRjNDNjNmUuLjUwNmM0Y2E2MDQ1Zjc0ZDNmZWIwNDZkZGI2MjlhODRmMDBiZTg1NGIgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJveHlXUEUuY3Bw CisrKyBiL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvd3BlL0V2ZW50U2VuZGVyUHJveHlXUEUuY3Bw CkBAIC0yODAsNiArMjgwLDcgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5OjprZXlEb3duKFdLU3Ry aW5nUmVmIGtleVJlZiwgV0tFdmVudE1vZGlmaWVycyB3a01vZGlmaWVycywKICAgICB3cGVfdmll d19iYWNrZW5kX2Rpc3BhdGNoX2tleWJvYXJkX2V2ZW50KG1fdmlld0JhY2tlbmQsICZldmVudCk7 CiB9CiAKKyNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogdm9pZCBFdmVudFNlbmRlclByb3h5Ojph ZGRUb3VjaFBvaW50KGludCB4LCBpbnQgeSkKIHsKICAgICBzdHJ1Y3Qgd3BlX2lucHV0X3RvdWNo X2V2ZW50X3JhdyByYXdFdmVudCB7IHdwZV9pbnB1dF90b3VjaF9ldmVudF90eXBlX2Rvd24sIHN0 YXRpY19jYXN0PHVpbnQzMl90PihtX3RpbWUpLCBzdGF0aWNfY2FzdDxpbnQ+KG1fdG91Y2hFdmVu dHMuc2l6ZSgpKSwgc3RhdGljX2Nhc3Q8aW50MzJfdD4oeCksIHN0YXRpY19jYXN0PGludDMyX3Q+ KHkpIH07CkBAIC0zNzYsNSArMzc3LDYgQEAgdm9pZCBFdmVudFNlbmRlclByb3h5OjpjYW5jZWxU b3VjaFBvaW50KGludCkKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQorI2VuZGlmIC8vIEVO QUJMRShUT1VDSF9FVkVOVFMpCiAKIH0gLy8gbmFtZXNwYWNlIFdUUgo= 339414 2018-05-03 09:20:05 -0700 2018-05-03 09:24:55 -0700 patch bug-185253-20180503182003.patch text/plain 8001 psaavedra U3VidmVyc2lvbiBSZXZpc2lvbjogMjMxMzA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDZiYjk4ZWFlYjlkZTBkNDVk ZTlmZWU2MzU0ZWRjNjEyMGJkMTVmYjcuLmQwZWQyMzExYmJiMjg3ZGI0ZTExOGQxOWYxMjE5Mjdj NTIyYzM0YTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTgtMDUtMDMgIFBhYmxvIFNh YXZlZHJhICA8cHNhYXZlZHJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gRml4IGJ1aWxk IGZvciBFTkFCTEVfVE9VQ0hfRVZFTlRTPU9GRgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg1MjUzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBjb21taXQgaXMgYSBwb3J0IG9mIHIxOTA5ODcgY29t bWl0dGVkIGZvciBHVEsgcGxhdGZvcm0KKyAgICAgICAgKGh0dHA6Ly90cmFjLndlYmtpdC5vcmcv Y2hhbmdlc2V0LzE5MDk4NykgdG8gV1BFCisKKyAgICAgICAgKiBTaGFyZWQvd3BlL05hdGl2ZVdl YlRvdWNoRXZlbnRXUEUuY3BwOgorICAgICAgICAqIFNoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5 LmNwcDoKKyAgICAgICAgKiBTaGFyZWQvd3BlL1dlYkV2ZW50RmFjdG9yeS5oOgorICAgICAgICAq IFVJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKiBVSVByb2Nl c3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1wbC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvd3Bl L1dQRVZpZXcuY3BwOgorICAgICAgICAoV0tXUEU6Om1fYmFja2VuZCk6CisKIDIwMTgtMDUtMDMg IFJ5YW4gSGFkZGFkICA8cnlhbmhhZGRhZEBhcHBsZS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjIzMTI1My4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVk L3dwZS9OYXRpdmVXZWJUb3VjaEV2ZW50V1BFLmNwcCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dw ZS9OYXRpdmVXZWJUb3VjaEV2ZW50V1BFLmNwcAppbmRleCAwY2M2NjU4Y2ZiNzUzNGU4NWQwMTU4 MzZmNWRkNGRjMGZmN2QxM2Q4Li4zNDhjZGEwYzZlMGFkMDBlMTc3MGJlNTIzNzhiZGE2ODYwNTE2 OGZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvTmF0aXZlV2ViVG91Y2hF dmVudFdQRS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvd3BlL05hdGl2ZVdlYlRvdWNo RXZlbnRXUEUuY3BwCkBAIC0yNiw2ICsyNiw4IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5j bHVkZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5oIgogCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykK KwogI2luY2x1ZGUgIldlYkV2ZW50RmFjdG9yeS5oIgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAg LTQ0LDMgKzQ2LDUgQEAgTmF0aXZlV2ViVG91Y2hFdmVudDo6TmF0aXZlV2ViVG91Y2hFdmVudChz dHJ1Y3Qgd3BlX2lucHV0X3RvdWNoX2V2ZW50KiBldmVudCwgZmwKIH0KIAogfSAvLyBuYW1lc3Bh Y2UgV2ViS2l0CisjZW5kaWYKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvd3Bl L1dlYkV2ZW50RmFjdG9yeS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRG YWN0b3J5LmNwcAppbmRleCA3Y2VhZjY2OTdiMjRiMDY5ZGJjZjk2YmM0ODFiMzAwZDRiZTFmY2Zl Li5mNmQwMjgwNDIyMWZmM2NhOWQ1NGMxOTk4ZjUyNzEwMmYzZDI1MzljIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmNwcApAQCAtMTY4LDYgKzE2OCw3IEBA IFdlYldoZWVsRXZlbnQgV2ViRXZlbnRGYWN0b3J5OjpjcmVhdGVXZWJXaGVlbEV2ZW50KHN0cnVj dCB3cGVfaW5wdXRfYXhpc19ldmVudCoKICAgICAgICAgZGVsdGEsIHdoZWVsVGlja3MsIFdlYldo ZWVsRXZlbnQ6OlNjcm9sbEJ5UGl4ZWxXaGVlbEV2ZW50LCBzdGF0aWNfY2FzdDxXZWJFdmVudDo6 TW9kaWZpZXJzPigwKSwgd2FsbFRpbWVGb3JFdmVudFRpbWUoZXZlbnQtPnRpbWUpKTsKIH0KIAor I2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiBzdGF0aWMgV2ViS2l0OjpXZWJQbGF0Zm9ybVRvdWNo UG9pbnQ6OlRvdWNoUG9pbnRTdGF0ZSBzdGF0ZUZvclRvdWNoUG9pbnQoaW50IG1haW5FdmVudElk LCBjb25zdCBzdHJ1Y3Qgd3BlX2lucHV0X3RvdWNoX2V2ZW50X3JhdyogcG9pbnQpCiB7CiAgICAg aWYgKHBvaW50LT5pZCAhPSBtYWluRXZlbnRJZCkKQEAgLTIyMiw1ICsyMjMsNiBAQCBXZWJUb3Vj aEV2ZW50IFdlYkV2ZW50RmFjdG9yeTo6Y3JlYXRlV2ViVG91Y2hFdmVudChzdHJ1Y3Qgd3BlX2lu cHV0X3RvdWNoX2V2ZW50KgogCiAgICAgcmV0dXJuIFdlYlRvdWNoRXZlbnQodHlwZSwgV1RGTW92 ZSh0b3VjaFBvaW50cyksIFdlYkV2ZW50OjpNb2RpZmllcnMoMCksIHdhbGxUaW1lRm9yRXZlbnRU aW1lKGV2ZW50LT50aW1lKSk7CiB9CisjZW5kaWYKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmggYi9T b3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmgKaW5kZXggYTJhYTAzNDUw ZDM4ZjM0YjExYzEyZmZjYjFlZmI1MGNhYzBkZjc5MS4uZjRiMDU1MGI1YmUzMDU1ZWIyMTAyYTA0 MDBlMDY3NzIyZmM4M2E1OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvd3BlL1dl YkV2ZW50RmFjdG9yeS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dwZS9XZWJFdmVudEZh Y3RvcnkuaApAQCAtMzksNyArMzksOSBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFdlYktleWJvYXJk RXZlbnQgY3JlYXRlV2ViS2V5Ym9hcmRFdmVudChzdHJ1Y3Qgd3BlX2lucHV0X2tleWJvYXJkX2V2 ZW50Kik7CiAgICAgc3RhdGljIFdlYk1vdXNlRXZlbnQgY3JlYXRlV2ViTW91c2VFdmVudChzdHJ1 Y3Qgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnQqLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3Rvcik7CiAg ICAgc3RhdGljIFdlYldoZWVsRXZlbnQgY3JlYXRlV2ViV2hlZWxFdmVudChzdHJ1Y3Qgd3BlX2lu cHV0X2F4aXNfZXZlbnQqLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3Rvcik7CisjaWYgRU5BQkxFKFRP VUNIX0VWRU5UUykKICAgICBzdGF0aWMgV2ViVG91Y2hFdmVudCBjcmVhdGVXZWJUb3VjaEV2ZW50 KHN0cnVjdCB3cGVfaW5wdXRfdG91Y2hfZXZlbnQqLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3Rvcik7 CisjZW5kaWYKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmNwcAppbmRleCA1OWNjYjQwMTMz Yjc2NTMxMzQ2ZTBhNTM1ODE3MmVjM2MwZjkxNzY1Li40OTgyMmM0YWYzNmNlZjQzMDY0NDJlY2Zh OWE5Y2YxOGEyYjViZjkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1BhZ2VDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1BhZ2VDbGllbnRJbXBsLmNwcApAQCAtMTc2LDYgKzE3Niw3IEBAIHZvaWQgUGFnZUNsaWVu dEltcGw6OmRvbmVXaXRoS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJv b2wpCiB7CiB9CiAKKyNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogdm9pZCBQYWdlQ2xpZW50SW1w bDo6ZG9uZVdpdGhUb3VjaEV2ZW50KGNvbnN0IE5hdGl2ZVdlYlRvdWNoRXZlbnQmIHRvdWNoRXZl bnQsIGJvb2wgd2FzRXZlbnRIYW5kbGVkKQogewogICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCkBA IC0yMjAsNiArMjIxLDcgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhUb3VjaEV2ZW50 KGNvbnN0IE5hdGl2ZVdlYlRvdWNoRXZlbnQmIHRvdWNoRXZlbnQsIGIKIAogICAgIHBhZ2UuaGFu ZGxlTW91c2VFdmVudChOYXRpdmVXZWJNb3VzZUV2ZW50KCZwb2ludGVyRXZlbnQsIHBhZ2UuZGV2 aWNlU2NhbGVGYWN0b3IoKSkpOwogfQorI2VuZGlmCiAKIHZvaWQgUGFnZUNsaWVudEltcGw6Ondo ZWVsRXZlbnRXYXNOb3RIYW5kbGVkQnlXZWJDb3JlKGNvbnN0IE5hdGl2ZVdlYldoZWVsRXZlbnQm KQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xp ZW50SW1wbC5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1w bC5oCmluZGV4IDE2N2U1NjU2ZTI4MDRhZWEyOTI5MGRlMzQ3MTJiMTY2MDliNGNiYTcuLmJmYjc2 ODQ4MjRiM2VlOTVlYTIxZWU3OGI1YjVkNDM4ZDZiYTlmMmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvUGFnZUNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmgKQEAgLTc4LDcgKzc4LDkgQEAg cHJpdmF0ZToKICAgICBXZWJDb3JlOjpJbnRSZWN0IHJvb3RWaWV3VG9TY3JlZW4oY29uc3QgV2Vi Q29yZTo6SW50UmVjdCYpIG92ZXJyaWRlOwogCiAgICAgdm9pZCBkb25lV2l0aEtleUV2ZW50KGNv bnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmLCBib29sKSBvdmVycmlkZTsKKyNpZiBFTkFCTEUo VE9VQ0hfRVZFTlRTKQogICAgIHZvaWQgZG9uZVdpdGhUb3VjaEV2ZW50KGNvbnN0IE5hdGl2ZVdl YlRvdWNoRXZlbnQmLCBib29sKSBvdmVycmlkZTsKKyNlbmRpZgogICAgIHZvaWQgd2hlZWxFdmVu dFdhc05vdEhhbmRsZWRCeVdlYkNvcmUoY29uc3QgTmF0aXZlV2ViV2hlZWxFdmVudCYpIG92ZXJy aWRlOwogCiAgICAgUmVmUHRyPFdlYlBvcHVwTWVudVByb3h5PiBjcmVhdGVQb3B1cE1lbnVQcm94 eShXZWJQYWdlUHJveHkmKSBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS93cGUvV1BFVmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1dQRVZpZXcuY3BwCmluZGV4IDQ4ZDgwNDQxMzVmZDNjY2ZlZTFmNjkxZGU4MjA4NDY2ZjNj YTg3YTUuLmY2M2RiNTNkZjRjMjg3N2Q0NmNkNGNjM2YxMDI0NDFhZGMyMDJhYzAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV1BFVmlldy5jcHAKKysrIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XUEVWaWV3LmNwcApAQCAtMzEsMTIgKzMxLDE1 IEBACiAjaW5jbHVkZSAiRHJhd2luZ0FyZWFQcm94eS5oIgogI2luY2x1ZGUgIk5hdGl2ZVdlYktl eWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJOYXRpdmVXZWJNb3VzZUV2ZW50LmgiCi0jaW5jbHVk ZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5oIgogI2luY2x1ZGUgIk5hdGl2ZVdlYldoZWVsRXZlbnQu aCIKICNpbmNsdWRlICJXZWJQYWdlR3JvdXAuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUG9vbC5o IgogI2luY2x1ZGUgPHdwZS93cGUuaD4KIAorI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCisjaW5j bHVkZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5oIgorI2VuZGlmCisKIHVzaW5nIG5hbWVzcGFjZSBX ZWJLaXQ7CiAKIG5hbWVzcGFjZSBXS1dQRSB7CkBAIC0xMjMsMTIgKzEyNiwxNiBAQCBWaWV3OjpW aWV3KHN0cnVjdCB3cGVfdmlld19iYWNrZW5kKiBiYWNrZW5kLCBjb25zdCBBUEk6OlBhZ2VDb25m aWd1cmF0aW9uJiBiYXNlQwogICAgICAgICAgICAgYXV0byYgcGFnZSA9IHJlaW50ZXJwcmV0X2Nh c3Q8Vmlldyo+KGRhdGEpLT5wYWdlKCk7CiAgICAgICAgICAgICBwYWdlLmhhbmRsZVdoZWVsRXZl bnQoV2ViS2l0OjpOYXRpdmVXZWJXaGVlbEV2ZW50KGV2ZW50LCBwYWdlLmRldmljZVNjYWxlRmFj dG9yKCkpKTsKICAgICAgICAgfSwKKyNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogICAgICAgICAv LyBoYW5kbGVfdG91Y2hfZXZlbnQKICAgICAgICAgW10odm9pZCogZGF0YSwgc3RydWN0IHdwZV9p bnB1dF90b3VjaF9ldmVudCogZXZlbnQpCiAgICAgICAgIHsKICAgICAgICAgICAgIGF1dG8mIHBh Z2UgPSByZWludGVycHJldF9jYXN0PFZpZXcqPihkYXRhKS0+cGFnZSgpOwogICAgICAgICAgICAg cGFnZS5oYW5kbGVUb3VjaEV2ZW50KFdlYktpdDo6TmF0aXZlV2ViVG91Y2hFdmVudChldmVudCwg cGFnZS5kZXZpY2VTY2FsZUZhY3RvcigpKSk7CiAgICAgICAgIH0sCisjZWxzZQorICAgICAgICBu dWxscHRyLAorI2VuZGlmCiAgICAgICAgIC8vIHBhZGRpbmcKICAgICAgICAgbnVsbHB0ciwKICAg ICAgICAgbnVsbHB0ciwKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5n ZUxvZwppbmRleCBjZjJiZDMyZjJkNjNhNDM0Mzk3Y2JlZjc3YzYwMjM1OTJlZTBiNDdhLi44N2Mw NDgyMzlhMDZmYzUwZTdlNWU5MGQ2NDIwNTIwNGFiODUwODdhIDEwMDY0NAotLS0gYS9Ub29scy9D aGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTgtMDUt MDMgIFBhYmxvIFNhYXZlZHJhICA8cHNhYXZlZHJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQ RV0gRml4IGJ1aWxkIGZvciBFTkFCTEVfVE9VQ0hfRVZFTlRTPU9GRgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg1MjUzCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBjb21taXQgaXMgYSBwb3J0IG9m IHIxOTA5ODcgY29tbWl0dGVkIGZvciBHVEsgcGxhdGZvcm0KKyAgICAgICAgKGh0dHA6Ly90cmFj LndlYmtpdC5vcmcvY2hhbmdlc2V0LzE5MDk4NykgdG8gV1BFCisKKyAgICAgICAgKiBXZWJLaXRU ZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BFLmNwcDoKKwogMjAxOC0wNS0wMyAgUnlh biBIYWRkYWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCBy b2xsaW5nIG91dCByMjMxMjUzLgpkaWZmIC0tZ2l0IGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93 cGUvRXZlbnRTZW5kZXJQcm94eVdQRS5jcHAgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9F dmVudFNlbmRlclByb3h5V1BFLmNwcAppbmRleCBhYWIxMWU3NTUxNTQwODU1M2I3Y2ViZTFjZmIz ZTYxNWQ0YzQzYzZlLi5iMzY4MWVlYjY2MTJjODY0YzZhODVhZTg2MWU0ZDg5YmFmYzdhYzM4IDEw MDY0NAotLS0gYS9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BF LmNwcAorKysgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BF LmNwcApAQCAtMjgwLDYgKzI4MCw3IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6a2V5RG93bihX S1N0cmluZ1JlZiBrZXlSZWYsIFdLRXZlbnRNb2RpZmllcnMgd2tNb2RpZmllcnMsCiAgICAgd3Bl X3ZpZXdfYmFja2VuZF9kaXNwYXRjaF9rZXlib2FyZF9ldmVudChtX3ZpZXdCYWNrZW5kLCAmZXZl bnQpOwogfQogCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKIHZvaWQgRXZlbnRTZW5kZXJQcm94 eTo6YWRkVG91Y2hQb2ludChpbnQgeCwgaW50IHkpCiB7CiAgICAgc3RydWN0IHdwZV9pbnB1dF90 b3VjaF9ldmVudF9yYXcgcmF3RXZlbnQgeyB3cGVfaW5wdXRfdG91Y2hfZXZlbnRfdHlwZV9kb3du LCBzdGF0aWNfY2FzdDx1aW50MzJfdD4obV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3RvdWNo RXZlbnRzLnNpemUoKSksIHN0YXRpY19jYXN0PGludDMyX3Q+KHgpLCBzdGF0aWNfY2FzdDxpbnQz Ml90Pih5KSB9OwpAQCAtMzc2LDUgKzM3Nyw2IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6Y2Fu Y2VsVG91Y2hQb2ludChpbnQpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KKyNlbmRpZgog CiB9IC8vIG5hbWVzcGFjZSBXVFIK 339415 2018-05-03 09:25:35 -0700 2018-05-03 10:04:58 -0700 patch bug-185253-20180503182534.patch text/plain 8001 psaavedra U3VidmVyc2lvbiBSZXZpc2lvbjogMjMxMzA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDZiYjk4ZWFlYjlkZTBkNDVk ZTlmZWU2MzU0ZWRjNjEyMGJkMTVmYjcuLmQwZWQyMzExYmJiMjg3ZGI0ZTExOGQxOWYxMjE5Mjdj NTIyYzM0YTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTgtMDUtMDMgIFBhYmxvIFNh YXZlZHJhICA8cHNhYXZlZHJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQRV0gRml4IGJ1aWxk IGZvciBFTkFCTEVfVE9VQ0hfRVZFTlRTPU9GRgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg1MjUzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBjb21taXQgaXMgYSBwb3J0IG9mIHIxOTA5ODcgY29t bWl0dGVkIGZvciBHVEsgcGxhdGZvcm0KKyAgICAgICAgKGh0dHA6Ly90cmFjLndlYmtpdC5vcmcv Y2hhbmdlc2V0LzE5MDk4NykgdG8gV1BFCisKKyAgICAgICAgKiBTaGFyZWQvd3BlL05hdGl2ZVdl YlRvdWNoRXZlbnRXUEUuY3BwOgorICAgICAgICAqIFNoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5 LmNwcDoKKyAgICAgICAgKiBTaGFyZWQvd3BlL1dlYkV2ZW50RmFjdG9yeS5oOgorICAgICAgICAq IFVJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKiBVSVByb2Nl c3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1wbC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvd3Bl L1dQRVZpZXcuY3BwOgorICAgICAgICAoV0tXUEU6Om1fYmFja2VuZCk6CisKIDIwMTgtMDUtMDMg IFJ5YW4gSGFkZGFkICA8cnlhbmhhZGRhZEBhcHBsZS5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjIzMTI1My4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVk L3dwZS9OYXRpdmVXZWJUb3VjaEV2ZW50V1BFLmNwcCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dw ZS9OYXRpdmVXZWJUb3VjaEV2ZW50V1BFLmNwcAppbmRleCAwY2M2NjU4Y2ZiNzUzNGU4NWQwMTU4 MzZmNWRkNGRjMGZmN2QxM2Q4Li5mZjQxNjgwN2QyYzcyNTFiYWNjOTM3NjM4NTU2M2I4NjZkYTE3 OWU0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvTmF0aXZlV2ViVG91Y2hF dmVudFdQRS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvd3BlL05hdGl2ZVdlYlRvdWNo RXZlbnRXUEUuY3BwCkBAIC0yNiw2ICsyNiw4IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5j bHVkZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5oIgogCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykK KwogI2luY2x1ZGUgIldlYkV2ZW50RmFjdG9yeS5oIgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAg LTQ0LDMgKzQ2LDUgQEAgTmF0aXZlV2ViVG91Y2hFdmVudDo6TmF0aXZlV2ViVG91Y2hFdmVudChz dHJ1Y3Qgd3BlX2lucHV0X3RvdWNoX2V2ZW50KiBldmVudCwgZmwKIH0KIAogfSAvLyBuYW1lc3Bh Y2UgV2ViS2l0CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvd3Bl L1dlYkV2ZW50RmFjdG9yeS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRG YWN0b3J5LmNwcAppbmRleCA3Y2VhZjY2OTdiMjRiMDY5ZGJjZjk2YmM0ODFiMzAwZDRiZTFmY2Zl Li5mNmQwMjgwNDIyMWZmM2NhOWQ1NGMxOTk4ZjUyNzEwMmYzZDI1MzljIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmNwcApAQCAtMTY4LDYgKzE2OCw3IEBA IFdlYldoZWVsRXZlbnQgV2ViRXZlbnRGYWN0b3J5OjpjcmVhdGVXZWJXaGVlbEV2ZW50KHN0cnVj dCB3cGVfaW5wdXRfYXhpc19ldmVudCoKICAgICAgICAgZGVsdGEsIHdoZWVsVGlja3MsIFdlYldo ZWVsRXZlbnQ6OlNjcm9sbEJ5UGl4ZWxXaGVlbEV2ZW50LCBzdGF0aWNfY2FzdDxXZWJFdmVudDo6 TW9kaWZpZXJzPigwKSwgd2FsbFRpbWVGb3JFdmVudFRpbWUoZXZlbnQtPnRpbWUpKTsKIH0KIAor I2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiBzdGF0aWMgV2ViS2l0OjpXZWJQbGF0Zm9ybVRvdWNo UG9pbnQ6OlRvdWNoUG9pbnRTdGF0ZSBzdGF0ZUZvclRvdWNoUG9pbnQoaW50IG1haW5FdmVudElk LCBjb25zdCBzdHJ1Y3Qgd3BlX2lucHV0X3RvdWNoX2V2ZW50X3JhdyogcG9pbnQpCiB7CiAgICAg aWYgKHBvaW50LT5pZCAhPSBtYWluRXZlbnRJZCkKQEAgLTIyMiw1ICsyMjMsNiBAQCBXZWJUb3Vj aEV2ZW50IFdlYkV2ZW50RmFjdG9yeTo6Y3JlYXRlV2ViVG91Y2hFdmVudChzdHJ1Y3Qgd3BlX2lu cHV0X3RvdWNoX2V2ZW50KgogCiAgICAgcmV0dXJuIFdlYlRvdWNoRXZlbnQodHlwZSwgV1RGTW92 ZSh0b3VjaFBvaW50cyksIFdlYkV2ZW50OjpNb2RpZmllcnMoMCksIHdhbGxUaW1lRm9yRXZlbnRU aW1lKGV2ZW50LT50aW1lKSk7CiB9CisjZW5kaWYKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmggYi9T b3VyY2UvV2ViS2l0L1NoYXJlZC93cGUvV2ViRXZlbnRGYWN0b3J5LmgKaW5kZXggYTJhYTAzNDUw ZDM4ZjM0YjExYzEyZmZjYjFlZmI1MGNhYzBkZjc5MS4uZjRiMDU1MGI1YmUzMDU1ZWIyMTAyYTA0 MDBlMDY3NzIyZmM4M2E1OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvd3BlL1dl YkV2ZW50RmFjdG9yeS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL3dwZS9XZWJFdmVudEZh Y3RvcnkuaApAQCAtMzksNyArMzksOSBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFdlYktleWJvYXJk RXZlbnQgY3JlYXRlV2ViS2V5Ym9hcmRFdmVudChzdHJ1Y3Qgd3BlX2lucHV0X2tleWJvYXJkX2V2 ZW50Kik7CiAgICAgc3RhdGljIFdlYk1vdXNlRXZlbnQgY3JlYXRlV2ViTW91c2VFdmVudChzdHJ1 Y3Qgd3BlX2lucHV0X3BvaW50ZXJfZXZlbnQqLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3Rvcik7CiAg ICAgc3RhdGljIFdlYldoZWVsRXZlbnQgY3JlYXRlV2ViV2hlZWxFdmVudChzdHJ1Y3Qgd3BlX2lu cHV0X2F4aXNfZXZlbnQqLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3Rvcik7CisjaWYgRU5BQkxFKFRP VUNIX0VWRU5UUykKICAgICBzdGF0aWMgV2ViVG91Y2hFdmVudCBjcmVhdGVXZWJUb3VjaEV2ZW50 KHN0cnVjdCB3cGVfaW5wdXRfdG91Y2hfZXZlbnQqLCBmbG9hdCBkZXZpY2VTY2FsZUZhY3Rvcik7 CisjZW5kaWYKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmNwcAppbmRleCA1OWNjYjQwMTMz Yjc2NTMxMzQ2ZTBhNTM1ODE3MmVjM2MwZjkxNzY1Li40OTgyMmM0YWYzNmNlZjQzMDY0NDJlY2Zh OWE5Y2YxOGEyYjViZjkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1BhZ2VDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1BhZ2VDbGllbnRJbXBsLmNwcApAQCAtMTc2LDYgKzE3Niw3IEBAIHZvaWQgUGFnZUNsaWVu dEltcGw6OmRvbmVXaXRoS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJv b2wpCiB7CiB9CiAKKyNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogdm9pZCBQYWdlQ2xpZW50SW1w bDo6ZG9uZVdpdGhUb3VjaEV2ZW50KGNvbnN0IE5hdGl2ZVdlYlRvdWNoRXZlbnQmIHRvdWNoRXZl bnQsIGJvb2wgd2FzRXZlbnRIYW5kbGVkKQogewogICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCkBA IC0yMjAsNiArMjIxLDcgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhUb3VjaEV2ZW50 KGNvbnN0IE5hdGl2ZVdlYlRvdWNoRXZlbnQmIHRvdWNoRXZlbnQsIGIKIAogICAgIHBhZ2UuaGFu ZGxlTW91c2VFdmVudChOYXRpdmVXZWJNb3VzZUV2ZW50KCZwb2ludGVyRXZlbnQsIHBhZ2UuZGV2 aWNlU2NhbGVGYWN0b3IoKSkpOwogfQorI2VuZGlmCiAKIHZvaWQgUGFnZUNsaWVudEltcGw6Ondo ZWVsRXZlbnRXYXNOb3RIYW5kbGVkQnlXZWJDb3JlKGNvbnN0IE5hdGl2ZVdlYldoZWVsRXZlbnQm KQogewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xp ZW50SW1wbC5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9QYWdlQ2xpZW50SW1w bC5oCmluZGV4IDE2N2U1NjU2ZTI4MDRhZWEyOTI5MGRlMzQ3MTJiMTY2MDliNGNiYTcuLmJmYjc2 ODQ4MjRiM2VlOTVlYTIxZWU3OGI1YjVkNDM4ZDZiYTlmMmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvUGFnZUNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9BUEkvd3BlL1BhZ2VDbGllbnRJbXBsLmgKQEAgLTc4LDcgKzc4LDkgQEAg cHJpdmF0ZToKICAgICBXZWJDb3JlOjpJbnRSZWN0IHJvb3RWaWV3VG9TY3JlZW4oY29uc3QgV2Vi Q29yZTo6SW50UmVjdCYpIG92ZXJyaWRlOwogCiAgICAgdm9pZCBkb25lV2l0aEtleUV2ZW50KGNv bnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmLCBib29sKSBvdmVycmlkZTsKKyNpZiBFTkFCTEUo VE9VQ0hfRVZFTlRTKQogICAgIHZvaWQgZG9uZVdpdGhUb3VjaEV2ZW50KGNvbnN0IE5hdGl2ZVdl YlRvdWNoRXZlbnQmLCBib29sKSBvdmVycmlkZTsKKyNlbmRpZgogICAgIHZvaWQgd2hlZWxFdmVu dFdhc05vdEhhbmRsZWRCeVdlYkNvcmUoY29uc3QgTmF0aXZlV2ViV2hlZWxFdmVudCYpIG92ZXJy aWRlOwogCiAgICAgUmVmUHRyPFdlYlBvcHVwTWVudVByb3h5PiBjcmVhdGVQb3B1cE1lbnVQcm94 eShXZWJQYWdlUHJveHkmKSBvdmVycmlkZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL0FQSS93cGUvV1BFVmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv d3BlL1dQRVZpZXcuY3BwCmluZGV4IDQ4ZDgwNDQxMzVmZDNjY2ZlZTFmNjkxZGU4MjA4NDY2ZjNj YTg3YTUuLmY2M2RiNTNkZjRjMjg3N2Q0NmNkNGNjM2YxMDI0NDFhZGMyMDJhYzAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS93cGUvV1BFVmlldy5jcHAKKysrIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL3dwZS9XUEVWaWV3LmNwcApAQCAtMzEsMTIgKzMxLDE1 IEBACiAjaW5jbHVkZSAiRHJhd2luZ0FyZWFQcm94eS5oIgogI2luY2x1ZGUgIk5hdGl2ZVdlYktl eWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJOYXRpdmVXZWJNb3VzZUV2ZW50LmgiCi0jaW5jbHVk ZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5oIgogI2luY2x1ZGUgIk5hdGl2ZVdlYldoZWVsRXZlbnQu aCIKICNpbmNsdWRlICJXZWJQYWdlR3JvdXAuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUG9vbC5o IgogI2luY2x1ZGUgPHdwZS93cGUuaD4KIAorI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCisjaW5j bHVkZSAiTmF0aXZlV2ViVG91Y2hFdmVudC5oIgorI2VuZGlmCisKIHVzaW5nIG5hbWVzcGFjZSBX ZWJLaXQ7CiAKIG5hbWVzcGFjZSBXS1dQRSB7CkBAIC0xMjMsMTIgKzEyNiwxNiBAQCBWaWV3OjpW aWV3KHN0cnVjdCB3cGVfdmlld19iYWNrZW5kKiBiYWNrZW5kLCBjb25zdCBBUEk6OlBhZ2VDb25m aWd1cmF0aW9uJiBiYXNlQwogICAgICAgICAgICAgYXV0byYgcGFnZSA9IHJlaW50ZXJwcmV0X2Nh c3Q8Vmlldyo+KGRhdGEpLT5wYWdlKCk7CiAgICAgICAgICAgICBwYWdlLmhhbmRsZVdoZWVsRXZl bnQoV2ViS2l0OjpOYXRpdmVXZWJXaGVlbEV2ZW50KGV2ZW50LCBwYWdlLmRldmljZVNjYWxlRmFj dG9yKCkpKTsKICAgICAgICAgfSwKKyNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogICAgICAgICAv LyBoYW5kbGVfdG91Y2hfZXZlbnQKICAgICAgICAgW10odm9pZCogZGF0YSwgc3RydWN0IHdwZV9p bnB1dF90b3VjaF9ldmVudCogZXZlbnQpCiAgICAgICAgIHsKICAgICAgICAgICAgIGF1dG8mIHBh Z2UgPSByZWludGVycHJldF9jYXN0PFZpZXcqPihkYXRhKS0+cGFnZSgpOwogICAgICAgICAgICAg cGFnZS5oYW5kbGVUb3VjaEV2ZW50KFdlYktpdDo6TmF0aXZlV2ViVG91Y2hFdmVudChldmVudCwg cGFnZS5kZXZpY2VTY2FsZUZhY3RvcigpKSk7CiAgICAgICAgIH0sCisjZWxzZQorICAgICAgICBu dWxscHRyLAorI2VuZGlmCiAgICAgICAgIC8vIHBhZGRpbmcKICAgICAgICAgbnVsbHB0ciwKICAg ICAgICAgbnVsbHB0ciwKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5n ZUxvZwppbmRleCBjZjJiZDMyZjJkNjNhNDM0Mzk3Y2JlZjc3YzYwMjM1OTJlZTBiNDdhLi44N2Mw NDgyMzlhMDZmYzUwZTdlNWU5MGQ2NDIwNTIwNGFiODUwODdhIDEwMDY0NAotLS0gYS9Ub29scy9D aGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTgtMDUt MDMgIFBhYmxvIFNhYXZlZHJhICA8cHNhYXZlZHJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dQ RV0gRml4IGJ1aWxkIGZvciBFTkFCTEVfVE9VQ0hfRVZFTlRTPU9GRgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTg1MjUzCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBjb21taXQgaXMgYSBwb3J0IG9m IHIxOTA5ODcgY29tbWl0dGVkIGZvciBHVEsgcGxhdGZvcm0KKyAgICAgICAgKGh0dHA6Ly90cmFj LndlYmtpdC5vcmcvY2hhbmdlc2V0LzE5MDk4NykgdG8gV1BFCisKKyAgICAgICAgKiBXZWJLaXRU ZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BFLmNwcDoKKwogMjAxOC0wNS0wMyAgUnlh biBIYWRkYWQgIDxyeWFuaGFkZGFkQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCBy b2xsaW5nIG91dCByMjMxMjUzLgpkaWZmIC0tZ2l0IGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci93 cGUvRXZlbnRTZW5kZXJQcm94eVdQRS5jcHAgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9F dmVudFNlbmRlclByb3h5V1BFLmNwcAppbmRleCBhYWIxMWU3NTUxNTQwODU1M2I3Y2ViZTFjZmIz ZTYxNWQ0YzQzYzZlLi5iMzY4MWVlYjY2MTJjODY0YzZhODVhZTg2MWU0ZDg5YmFmYzdhYzM4IDEw MDY0NAotLS0gYS9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BF LmNwcAorKysgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL3dwZS9FdmVudFNlbmRlclByb3h5V1BF LmNwcApAQCAtMjgwLDYgKzI4MCw3IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6a2V5RG93bihX S1N0cmluZ1JlZiBrZXlSZWYsIFdLRXZlbnRNb2RpZmllcnMgd2tNb2RpZmllcnMsCiAgICAgd3Bl X3ZpZXdfYmFja2VuZF9kaXNwYXRjaF9rZXlib2FyZF9ldmVudChtX3ZpZXdCYWNrZW5kLCAmZXZl bnQpOwogfQogCisjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKIHZvaWQgRXZlbnRTZW5kZXJQcm94 eTo6YWRkVG91Y2hQb2ludChpbnQgeCwgaW50IHkpCiB7CiAgICAgc3RydWN0IHdwZV9pbnB1dF90 b3VjaF9ldmVudF9yYXcgcmF3RXZlbnQgeyB3cGVfaW5wdXRfdG91Y2hfZXZlbnRfdHlwZV9kb3du LCBzdGF0aWNfY2FzdDx1aW50MzJfdD4obV90aW1lKSwgc3RhdGljX2Nhc3Q8aW50PihtX3RvdWNo RXZlbnRzLnNpemUoKSksIHN0YXRpY19jYXN0PGludDMyX3Q+KHgpLCBzdGF0aWNfY2FzdDxpbnQz Ml90Pih5KSB9OwpAQCAtMzc2LDUgKzM3Nyw2IEBAIHZvaWQgRXZlbnRTZW5kZXJQcm94eTo6Y2Fu Y2VsVG91Y2hQb2ludChpbnQpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KKyNlbmRpZgog CiB9IC8vIG5hbWVzcGFjZSBXVFIK