151007 2015-11-08 07:04:10 -0800 [EFL] Add UserAgentEFl.cpp|h 2015-11-13 00:53:45 -0800 1 1 1 Unclassified WebKit WebKit EFL WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 gyuyoung.kim gyuyoung.kim commit-queue darin lucas.de.marchi oldest_to_newest 1140256 0 gyuyoung.kim 2015-11-08 07:04:10 -0800 As other ports EFL port starts to have UserAgentEfl class in order to support more detailed UA. 1140258 1 265016 gyuyoung.kim 2015-11-08 07:06:47 -0800 Created attachment 265016 Patch 1140267 2 265016 darin 2015-11-08 10:40:40 -0800 Comment on attachment 265016 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=265016&action=review Strange that we are actually using the prefix "Efl" instead of "EFL". I think acronyms are easier to read when they are capitalized as such. I’m OK with this patch, but there is a lot of room for improvement. Many small things done wrong. > Source/WebCore/platform/efl/UserAgentEfl.cpp:38 > +static const String platformForUAString() I suggest const char* as the return type rather than String. We don’t need to allocate this string each time we call this function just to carry an ASCII literal to the caller and then get destroyed. > Source/WebCore/platform/efl/UserAgentEfl.cpp:41 > + return String("X11"); Should be ASCIILiteral, not String, but neither is needed if you are changing return type to const char*. > Source/WebCore/platform/efl/UserAgentEfl.cpp:43 > + return String("Unknown"); Should be ASCIILiteral, not String. > Source/WebCore/platform/efl/UserAgentEfl.cpp:47 > +static const String platformVersionForUAString() Return type should be String, not const String. All String are immutable; const String doesn’t really mean anything except that you can’t assign with the another string. Having this return const String is like having a function that returns const int. What’s the point? You can store the result in an int or a const int whether you type it int or const int, so there’s no point of including the const there, or here. > Source/WebCore/platform/efl/UserAgentEfl.cpp:49 > + String osVersion; I’d just name the local variable “version”; not sure this is really an “OS version” and even if it was don’t need to name it like that. > Source/WebCore/platform/efl/UserAgentEfl.cpp:52 > + osVersion = WTF::String(name.sysname) + " " + WTF::String(name.machine); WTF:: prefix is used here, but nowhere else in the file. It should not be. The better way to write this is: version = makeString(name.sysname, ' ', name.machine); It’s more efficient, doesn’t waste memory allocating two intermediate strings. > Source/WebCore/platform/efl/UserAgentEfl.cpp:54 > + osVersion = "Unknown"; Should be ASCIILiteral("Unknown"). > Source/WebCore/platform/efl/UserAgentEfl.cpp:62 > +static const String versionForUAString() > +{ > + static NeverDestroyed<const String> version(String::format("%i.%i", WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION)); > + return version; > +} Would like to avoid new uses of String::format; we plan to deprecate this, since it’s not type checked. Given those are compile time constants, I think this entire function can just be something like this using stringifying and token pasting instead of doing anything at runtime: static const char* versionForUAString() { return #WEBKIT_MAJOR_VERSION "." #WEBKIT_MINOR_VERSION; } Or possibly: static const char* versionForUAString() { #define VERSION #WEBKIT_MAJOR_VERSION "." #WEBKIT_MINOR_VERSION return VERSION; #undef VERSION } No real benefit do doing NeverDestroyed<const String> instead of NeverDestroyed<String>, but you really don’t need either here. > Source/WebCore/platform/efl/UserAgentEfl.cpp:68 > + String version = versionForUAString(); > + String standardUserAgentString = "Mozilla/5.0 (" + platformForUAString() + "; " + platformVersionForUAString() > + + ") AppleWebKit/" + version + " (KHTML, like Gecko) Version/8.0 Safari/" + version; Why not make the user agent string be a NeverDestroyed<String>. There’s no reason for this to recompute the string each time the function is called. It’s kind of silly to cache inside versionForUAString, which is only called here, instead of caching the string we compute here. This code should just be: static NeverDestroyed<String> string = makeString("Mozilla/5.0 (", platformForUAString(), "; ", platformVersionForUAString(), ") AppleWebKit/", version, " (KHTML, like Gecko) Version/8.0 Safari/", version); That will work even if the functions return const char* rather than String. It is a bizarre strategy to repeat the EFL WebKit version twice, once as a WebKit version and a second time as a Safari version; Safari versions use a different numbering scheme so using the WebKit version for it is questionable and likely to fail at some point; if a given Safari and WebKit version seem to correspond that’s just a coincidence. You’d be better off with a hardcoded Safari version, I think. Also wish you didn’t need to make your non-Safari browser pretend to be Safari at all! Not good. > Source/WebCore/platform/efl/UserAgentEfl.cpp:70 > + return applicationName.isEmpty() ? standardUserAgentString : standardUserAgentString + ' ' + applicationName; Do you leave out the application version for some good reason? 1140300 3 265016 gyuyoung.kim 2015-11-08 21:39:51 -0800 Comment on attachment 265016 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=265016&action=review >> Source/WebCore/platform/efl/UserAgentEfl.cpp:47 >> +static const String platformVersionForUAString() > > Return type should be String, not const String. All String are immutable; const String doesn’t really mean anything except that you can’t assign with the another string. > > Having this return const String is like having a function that returns const int. What’s the point? You can store the result in an int or a const int whether you type it int or const int, so there’s no point of including the const there, or here. Done. >> Source/WebCore/platform/efl/UserAgentEfl.cpp:49 >> + String osVersion; > > I’d just name the local variable “version”; not sure this is really an “OS version” and even if it was don’t need to name it like that. Done. >> Source/WebCore/platform/efl/UserAgentEfl.cpp:52 >> + osVersion = WTF::String(name.sysname) + " " + WTF::String(name.machine); > > WTF:: prefix is used here, but nowhere else in the file. It should not be. The better way to write this is: > > version = makeString(name.sysname, ' ', name.machine); > > It’s more efficient, doesn’t waste memory allocating two intermediate strings. Done. >> Source/WebCore/platform/efl/UserAgentEfl.cpp:54 >> + osVersion = "Unknown"; > > Should be ASCIILiteral("Unknown"). Done. >> Source/WebCore/platform/efl/UserAgentEfl.cpp:62 >> +} > > Would like to avoid new uses of String::format; we plan to deprecate this, since it’s not type checked. Given those are compile time constants, I think this entire function can just be something like this using stringifying and token pasting instead of doing anything at runtime: > > static const char* versionForUAString() > { > return #WEBKIT_MAJOR_VERSION "." #WEBKIT_MINOR_VERSION; > } > > Or possibly: > > static const char* versionForUAString() > { > #define VERSION #WEBKIT_MAJOR_VERSION "." #WEBKIT_MINOR_VERSION > return VERSION; > #undef VERSION > } > > No real benefit do doing NeverDestroyed<const String> instead of NeverDestroyed<String>, but you really don’t need either here. Hmm.. When I use given suggestion, there is build break on gcc 4.9.2. Any other solution ? If not, I would like to land this patch as is at the moment. >> Source/WebCore/platform/efl/UserAgentEfl.cpp:68 >> + + ") AppleWebKit/" + version + " (KHTML, like Gecko) Version/8.0 Safari/" + version; > > Why not make the user agent string be a NeverDestroyed<String>. There’s no reason for this to recompute the string each time the function is called. It’s kind of silly to cache inside versionForUAString, which is only called here, instead of caching the string we compute here. > > This code should just be: > > static NeverDestroyed<String> string = makeString("Mozilla/5.0 (", platformForUAString(), "; ", platformVersionForUAString(), > ") AppleWebKit/", version, " (KHTML, like Gecko) Version/8.0 Safari/", version); > > That will work even if the functions return const char* rather than String. > > It is a bizarre strategy to repeat the EFL WebKit version twice, once as a WebKit version and a second time as a Safari version; Safari versions use a different numbering scheme so using the WebKit version for it is questionable and likely to fail at some point; if a given Safari and WebKit version seem to correspond that’s just a coincidence. You’d be better off with a hardcoded Safari version, I think. Also wish you didn’t need to make your non-Safari browser pretend to be Safari at all! Not good. > Why not make the user agent string be a NeverDestroyed<String>. There’s no reason for this to recompute the string each time the function is called. It’s kind of silly to cache inside versionForUAString, which is only called here, instead of caching the string we compute here. This code should just be: static NeverDestroyed<String> string = makeString("Mozilla/5.0 (", > platformForUAString(), "; ", platformVersionForUAString(), ") AppleWebKit/", version, " (KHTML, like Gecko) Version/8.0 Safari/", version); Thanks, done. > It is a bizarre strategy to repeat the EFL WebKit version twice, once as a WebKit version and a second time as a Safari version; Safari versions use a different numbering scheme so using the WebKit version for it is questionable and likely to fail at some point; if a given Safari and WebKit version seem to correspond that’s just a coincidence. You’d be better off with a > hardcoded Safari version, I think. Also wish you didn’t need to make your non-Safari browser pretend to be Safari at all! Not good. I just followed usage. However it looks your comment seems correct. I hardcorded safari version. Thank you for pointing it out ! >> Source/WebCore/platform/efl/UserAgentEfl.cpp:70 >> + return applicationName.isEmpty() ? standardUserAgentString : standardUserAgentString + ' ' + applicationName; > > Do you leave out the application version for some good reason? This patch is just to adjust existing implementation into UserAgentFoo class. The application version is going to upload on new bug. 1140301 4 265031 gyuyoung.kim 2015-11-08 21:52:09 -0800 Created attachment 265031 Patch 1140307 5 265031 commit-queue 2015-11-08 23:03:17 -0800 Comment on attachment 265031 Patch Clearing flags on attachment: 265031 Committed r192148: <http://trac.webkit.org/changeset/192148> 1140308 6 commit-queue 2015-11-08 23:03:21 -0800 All reviewed patches have been landed. Closing bug. 1140382 7 darin 2015-11-09 09:11:15 -0800 Thanks, glad you made some changes after considering my comments. On the patch as landed, I still see three minor things: + version = "Unknown"; This could be: version = ASCIILiteral("Unknown"); to be slightly more efficient. +static const String versionForUAString() The above type should be "const String&", not "const String". + String version = versionForUAString(); The type here should be const String& or auto& to avoid unnecessary reference count churn every time this function is called. I’m also sad that the token pasting solution didn’t work. I’m sure someone can come back and get that working without String::format; I’m not sure exactly why it didn’t work. Would be good to know exactly what the compiler errors were when you tried my suggestions. 1140600 8 gyuyoung.kim 2015-11-09 16:43:49 -0800 (In reply to comment #7) > Thanks, glad you made some changes after considering my comments. On the > patch as landed, I still see three minor things: > > + version = "Unknown"; > > This could be: > > version = ASCIILiteral("Unknown"); > > to be slightly more efficient. > > +static const String versionForUAString() > > The above type should be "const String&", not "const String". > > + String version = versionForUAString(); > > The type here should be const String& or auto& to avoid unnecessary > reference count churn every time this function is called. Oops, sorry for missing those things. I fix those things in Bug 151060 together with supporting *applicationVersion* parameter. Please take a look it as well. > I’m also sad that the token pasting solution didn’t work. I’m sure someone > can come back and get that working without String::format; I’m not sure > exactly why it didn’t work. Would be good to know exactly what the compiler > errors were when you tried my suggestions. Basically it looks gcc doesn't recognize # keyword. When I removed # keyword, there are some build errors. If I fix it, let me upstream it again ! ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:12: error: stray ‘#’ in program return VERSION; ^ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:21: error: stray ‘#’ in program return VERSION; ^ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp: In function ‘const WTF::String& WebCore::versionForUAString()’: ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:13: error: conversion from ‘int’ to ‘const WTF::String’ is ambiguous return VERSION; ^ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:13: note: candidates are: In file included from ../../Source/WebCore/platform/efl/UserAgentEfl.h:29:0, from ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:27: ../../Source/WTF/wtf/text/WTFString.h:463:5: note: WTF::String::String(WTF::HashTableDeletedValueType) <near match> String(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { } ^ ../../Source/WTF/wtf/text/WTFString.h:463:5: note: no known conversion for argument 1 from ‘int’ to ‘WTF::HashTableDeletedValueType’ ../../Source/WTF/wtf/text/WTFString.h:540:8: note: WTF::String::String(WTF::StringImpl*) <near match> inline String::String(StringImpl* impl) ^ ../../Source/WTF/wtf/text/WTFString.h:540:8: note: no known conversion for argument 1 from ‘int’ to ‘WTF::StringImpl*’ In file included from ../../Source/WebCore/platform/efl/UserAgentEfl.h:29:0, from ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:27: ../../Source/WTF/wtf/text/WTFString.h:112:5: note: WTF::String::String(const char*) <near match> WTF_EXPORT_STRING_API String(const char* characters); ^ ../../Source/WTF/wtf/text/WTFString.h:112:5: note: no known conversion for argument 1 from ‘int’ to ‘const char*’ ../../Source/WTF/wtf/text/WTFString.h:111:5: note: WTF::String::String(const LChar*) <near match> WTF_EXPORT_STRING_API String(const LChar* characters); ^ ../../Source/WTF/wtf/text/WTFString.h:111:5: note: no known conversion for argument 1 from ‘int’ to ‘const LChar* {aka const unsigned char*}’ ../../Source/WTF/wtf/text/WTFString.h:104:5: note: WTF::String::String(const UChar*) <near match> WTF_EXPORT_STRING_API String(const UChar*); ^ ../../Source/WTF/wtf/text/WTFString.h:104:5: note: no known conversion for argument 1 from ‘int’ to ‘const UChar* {aka const short unsigned int*}’ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:17: error: expected ‘;’ before string constant return VERSION; ^ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:22: error: expected ‘;’ before numeric constant return VERSION; ^ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:23: error: statement has no effect [-Werror=unused-value] return VERSION; ^ ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:65:1: error: control reaches end of non-void function [-Werror=return-type] } 1140783 9 darin 2015-11-10 08:56:43 -0800 OK. Makes sense. Try this: static const char* versionForUAString() { #define MAKE_VERSION(major, minor) #major "." #minor return MAKE_VERSION(WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION); #undef MAKE_VERSION } 1141791 10 gyuyoung.kim 2015-11-13 00:40:52 -0800 (In reply to comment #9) > OK. Makes sense. Try this: > > static const char* versionForUAString() > { > #define MAKE_VERSION(major, minor) #major "." #minor > return MAKE_VERSION(WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION); > #undef MAKE_VERSION > } When I adjust this code to EFL port, there was below compile error. ../../Source/WebCore/platform/efl/UserAgentEfl.cpp: In function ‘const WTF::String& WebCore::versionForUAString()’: ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:43: error: returning reference to temporary [-Werror=return-local-addr] return MAKE_VERSION(WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION); ^ cc1plus: all warnings being treated as errors However this works well if we use a local variable. Is this fine for you ? #define MAKE_VERSION(major, minor) #major "." #minor const String& version = MAKE_VERSION(WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION); return version; #undef MAKE_VERSION 1141796 11 gyuyoung.kim 2015-11-13 00:53:45 -0800 (In reply to comment #10) > (In reply to comment #9) > > OK. Makes sense. Try this: > > > > static const char* versionForUAString() > > { > > #define MAKE_VERSION(major, minor) #major "." #minor > > return MAKE_VERSION(WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION); > > #undef MAKE_VERSION > > } > > When I adjust this code to EFL port, there was below compile error. > > ../../Source/WebCore/platform/efl/UserAgentEfl.cpp: In function ‘const > WTF::String& WebCore::versionForUAString()’: > ../../Source/WebCore/platform/efl/UserAgentEfl.cpp:61:43: error: returning > reference to temporary [-Werror=return-local-addr] > return MAKE_VERSION(WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION); > ^ > cc1plus: all warnings being treated as errors > > However this works well if we use a local variable. Is this fine for you ? > > #define MAKE_VERSION(major, minor) #major "." #minor > const String& version = MAKE_VERSION(WEBKIT_MAJOR_VERSION, > WEBKIT_MINOR_VERSION); > return version; > #undef MAKE_VERSION I upload a patch to Bug 151250. Please leave your comment there. 265016 2015-11-08 07:06:47 -0800 2015-11-08 21:52:03 -0800 Patch bug-151007-20151109000644.patch text/plain 9031 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTkyMTIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmJmMzk4N2EzZjY0ZmVh NGFkNmQ5YmFlZjJlYTBkMGY3MjUxN2VmZC4uYzYyZjAwY2YyNDliOTNmNGNlY2QyNjgyYzEwNDBj ZmY4ZjU4NTc1OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDE1LTExLTA4ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ad2Via2l0Lm9yZz4KKworICAgICAgICBbRUZMXSBBZGQg VXNlckFnZW50RUZsLmNwcHxoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNTEwMDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBBcyBvdGhlciBwb3J0cyBFRkwgcG9ydCBzdGFydHMgdG8gaGF2ZSBVc2VyQWdl bnRFZmwgY2xhc3MgaW4gb3JkZXIgdG8gc3VwcG9ydCBtb3JlIGRldGFpbGVkCisgICAgICAgIFVB LgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgbm8gYmVoYXZpb3IgY2hhbmdlLgorCisgICAgICAg ICogUGxhdGZvcm1FZmwuY21ha2U6CisgICAgICAgICogcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVm bC5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JVQVN0cmluZyk6Cisg ICAgICAgIChXZWJDb3JlOjpwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6CisgICAgICAgIChX ZWJDb3JlOjp2ZXJzaW9uRm9yVUFTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRV c2VyQWdlbnQpOgorICAgICAgICAqIHBsYXRmb3JtL2VmbC9Vc2VyQWdlbnRFZmwuaDogQWRkZWQu CisKIDIwMTUtMTEtMDYgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAg ICAgIE1vZGVybiBJREI6IE1ha2UgdGhlIHJlc3VsdCBkYXRhIGZvciBhICJnZXQiIHJlcXVlc3Qg YmUgYW4gSURCR2V0UmVzdWx0LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9n IGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDMzYzEzN2Q1Nzc1MjBhMTA4MWZiMGYz NWZiNmMzNmVmOGFjM2E4YTYuLjY1NzRjOWMzYzNlMDgwMWVmZTgyZjczNGU5MTU1MTMzOTcyZjRl MmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxNS0xMS0wOCAgR3l1eW91bmcgS2lt ICA8Z3l1eW91bmcua2ltQHdlYmtpdC5vcmc+CisKKyAgICAgICAgW0VGTF0gQWRkIFVzZXJBZ2Vu dEVGbC5jcHB8aAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTUxMDA3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgQXMgb3RoZXIgcG9ydHMgRUZMIHBvcnQgc3RhcnRzIHRvIGhhdmUgVXNlckFnZW50RWZsIGNs YXNzIGluIG9yZGVyIHRvIHN1cHBvcnQgbW9yZSBkZXRhaWxlZAorICAgICAgICBVQS4KKworICAg ICAgICAqIFVJUHJvY2Vzcy9lZmwvV2ViUGFnZVByb3h5RWZsLmNwcDoKKyAgICAgICAgKFdlYktp dDo6V2ViUGFnZVByb3h5OjpzdGFuZGFyZFVzZXJBZ2VudCk6IENhbGwgV2ViQ29yZTo6c3RhbmRh cmRVc2VyQWdlbnQoKS4KKwogMjAxNS0xMS0wNiAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBs ZS5jb20+CiAKICAgICAgICAgTW9kZXJuIElEQjogTWFrZSB0aGUgcmVzdWx0IGRhdGEgZm9yIGEg ImdldCIgcmVxdWVzdCBiZSBhbiBJREJHZXRSZXN1bHQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtl CmluZGV4IGU1OTdkMDFiYTE1MzQzZDQwYzEzNzVhMWZhM2NjY2Y5OTdiNDQ1MjcuLjVhYzA2NWEx MzZmYzRjZTAxYjljZTFmNjliOGU0MDUyYTg5ZDUwMmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL1BsYXRmb3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNt YWtlCkBAIC0xMjMsNiArMTIzLDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAg cGxhdGZvcm0vZWZsL1Njcm9sbGJhclRoZW1lRWZsLmNwcAogICAgIHBsYXRmb3JtL2VmbC9Tb3Vu ZEVmbC5jcHAKICAgICBwbGF0Zm9ybS9lZmwvVGVtcG9yYXJ5TGlua1N0dWJzLmNwcAorICAgIHBs YXRmb3JtL2VmbC9Vc2VyQWdlbnRFZmwuY3BwCiAgICAgcGxhdGZvcm0vZWZsL1dpZGdldEVmbC5j cHAKIAogICAgIHBsYXRmb3JtL2dlb2NsdWUvR2VvbG9jYXRpb25Qcm92aWRlckdlb2NsdWUxLmNw cApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lZmwvVXNlckFnZW50RWZsLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5jMjFkYWZlZWQ5MGJkYTg0YTMwNWMxNjA0YjU3MmQ1ZTIxYzAzODM3Ci0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5jcHAKQEAg LTAsMCArMSw3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBOYXZlciBDb3JwLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUg bWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIg aW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExF IElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisg KiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVXNlckFnZW50RWZsLmgiCisKKyNp bmNsdWRlICJXZWJLaXRWZXJzaW9uLmgiCisjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+ CisKKyNpZiBPUyhVTklYKQorI2luY2x1ZGUgPHN5cy91dHNuYW1lLmg+CisjZW5kaWYKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitzdGF0aWMgY29uc3QgU3RyaW5nIHBsYXRmb3JtRm9yVUFTdHJp bmcoKQoreworI2lmIFBMQVRGT1JNKFgxMSkKKyAgICByZXR1cm4gU3RyaW5nKCJYMTEiKTsKKyNl bHNlCisgICAgcmV0dXJuIFN0cmluZygiVW5rbm93biIpOworI2VuZGlmCit9CisKK3N0YXRpYyBj b25zdCBTdHJpbmcgcGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcoKQoreworICAgIFN0cmluZyBv c1ZlcnNpb247CisgICAgc3RydWN0IHV0c25hbWUgbmFtZTsKKyAgICBpZiAodW5hbWUoJm5hbWUp ICE9IC0xKQorICAgICAgICBvc1ZlcnNpb24gPSBXVEY6OlN0cmluZyhuYW1lLnN5c25hbWUpICsg IiAiICsgV1RGOjpTdHJpbmcobmFtZS5tYWNoaW5lKTsKKyAgICBlbHNlCisgICAgICAgIG9zVmVy c2lvbiA9ICJVbmtub3duIjsKKyAgICByZXR1cm4gb3NWZXJzaW9uOworfQorCitzdGF0aWMgY29u c3QgU3RyaW5nIHZlcnNpb25Gb3JVQVN0cmluZygpCit7CisgICAgc3RhdGljIE5ldmVyRGVzdHJv eWVkPGNvbnN0IFN0cmluZz4gdmVyc2lvbihTdHJpbmc6OmZvcm1hdCgiJWkuJWkiLCBXRUJLSVRf TUFKT1JfVkVSU0lPTiwgV0VCS0lUX01JTk9SX1ZFUlNJT04pKTsKKyAgICByZXR1cm4gdmVyc2lv bjsKK30KKworU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRp b25OYW1lLCBjb25zdCBTdHJpbmcmKQoreworICAgIFN0cmluZyB2ZXJzaW9uID0gdmVyc2lvbkZv clVBU3RyaW5nKCk7CisgICAgU3RyaW5nIHN0YW5kYXJkVXNlckFnZW50U3RyaW5nID0gIk1vemls bGEvNS4wICgiICsgcGxhdGZvcm1Gb3JVQVN0cmluZygpICsgIjsgIiArIHBsYXRmb3JtVmVyc2lv bkZvclVBU3RyaW5nKCkKKyAgICAgICAgKyAiKSBBcHBsZVdlYktpdC8iICsgdmVyc2lvbiArICIg KEtIVE1MLCBsaWtlIEdlY2tvKSBWZXJzaW9uLzguMCBTYWZhcmkvIiArIHZlcnNpb247CisKKyAg ICByZXR1cm4gYXBwbGljYXRpb25OYW1lLmlzRW1wdHkoKSA/IHN0YW5kYXJkVXNlckFnZW50U3Ry aW5nIDogc3RhbmRhcmRVc2VyQWdlbnRTdHJpbmcgKyAnICcgKyBhcHBsaWNhdGlvbk5hbWU7Cit9 CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZs L1VzZXJBZ2VudEVmbC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhkZGEwYjMxMjIzODQ5MTZhMzhmNGNlYjBiNmU4 MmUwZDVkMTBkNGQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9l ZmwvVXNlckFnZW50RWZsLmgKQEAgLTAsMCArMSwzOCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxNSBOYXZlciBDb3JwLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFVzZXJBZ2VudEVmbF9oCisjZGVmaW5l IFVzZXJBZ2VudEVmbF9oCisKKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitTdHJpbmcgc3RhbmRhcmRVc2VyQWdlbnQoY29uc3QgU3RyaW5n JiBhcHBsaWNhdGlvbk5hbWUgPSBlbXB0eVN0cmluZygpLCBjb25zdCBTdHJpbmcmIGFwcGxpY2F0 aW9uVmVyc2lvbiA9IGVtcHR5U3RyaW5nKCkpOworCit9CisKKyNlbmRpZiAvLyBVc2VyQWdlbnRF ZmxfaAorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZWZsL1dlYlBhZ2VQ cm94eUVmbC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZWZsL1dlYlBhZ2VQcm94eUVm bC5jcHAKaW5kZXggYWRjNjQ3MmJjOWMxZmI2OTNjZmU5ZmI2OWFjYzhkNjc4MzIwMzhiZS4uZjk4 OTcyNGY5M2U3ZjhiOTFiMWJiMGZlZWVkMjA0YmQ0NmRmMWFiZSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL2VmbC9XZWJQYWdlUHJveHlFZmwuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9lZmwvV2ViUGFnZVByb3h5RWZsLmNwcApAQCAtMjksMTQgKzI5LDEy IEBACiAjaW5jbHVkZSAiRXdrVmlldy5oIgogI2luY2x1ZGUgIk5hdGl2ZVdlYktleWJvYXJkRXZl bnQuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgotI2luY2x1ZGUgIldlYktpdFZlcnNp b24uaCIKKyNpbmNsdWRlICJVc2VyQWdlbnRFZmwuaCIKICNpbmNsdWRlICJXZWJQYWdlTWVzc2Fn ZXMuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHkuaCIKICNpbmNsdWRlICJXZWJWaWV3Lmgi CiAjaW5jbHVkZSAiV2Vic2l0ZURhdGFTdG9yZS5oIgogCi0jaW5jbHVkZSA8c3lzL3V0c25hbWUu aD4KLQogbmFtZXNwYWNlIFdlYktpdCB7CiAKIHZvaWQgV2ViUGFnZVByb3h5OjpwbGF0Zm9ybUlu aXRpYWxpemUoKQpAQCAtNDUsMjggKzQzLDcgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnBsYXRmb3Jt SW5pdGlhbGl6ZSgpCiAKIFN0cmluZyBXZWJQYWdlUHJveHk6OnN0YW5kYXJkVXNlckFnZW50KGNv bnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lRm9yVXNlckFnZW50KQogewotICAgIFN0cmluZyBw bGF0Zm9ybTsKLSAgICBTdHJpbmcgdmVyc2lvbjsKLSAgICBTdHJpbmcgb3NWZXJzaW9uOwotICAg IFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudFN0cmluZzsKLQotI2lmIFBMQVRGT1JNKFgxMSkKLSAg ICBwbGF0Zm9ybSA9ICJYMTEiOwotI2Vsc2UKLSAgICBwbGF0Zm9ybSA9ICJVbmtub3duIjsKLSNl bmRpZgotCi0gICAgdmVyc2lvbiA9IFN0cmluZzo6bnVtYmVyKFdFQktJVF9NQUpPUl9WRVJTSU9O KSArICcuJyArIFN0cmluZzo6bnVtYmVyKFdFQktJVF9NSU5PUl9WRVJTSU9OKSArICcrJzsKLSAg ICBzdHJ1Y3QgdXRzbmFtZSBuYW1lOwotICAgIGlmICh1bmFtZSgmbmFtZSkgIT0gLTEpCi0gICAg ICAgIG9zVmVyc2lvbiA9IFdURjo6U3RyaW5nKG5hbWUuc3lzbmFtZSkgKyAiICIgKyBXVEY6OlN0 cmluZyhuYW1lLm1hY2hpbmUpOwotICAgIGVsc2UKLSAgICAgICAgb3NWZXJzaW9uID0gIlVua25v d24iOwotCi0gICAgc3RhbmRhcmRVc2VyQWdlbnRTdHJpbmcgPSAiTW96aWxsYS81LjAgKCIgKyBw bGF0Zm9ybSArICI7ICIgKyBvc1ZlcnNpb24gKyAiKSBBcHBsZVdlYktpdC8iICsgdmVyc2lvbgot ICAgICAgICArICIgKEtIVE1MLCBsaWtlIEdlY2tvKSBWZXJzaW9uLzguMCBTYWZhcmkvIiArIHZl cnNpb247Ci0KLSAgICByZXR1cm4gYXBwbGljYXRpb25OYW1lRm9yVXNlckFnZW50LmlzRW1wdHko KSA/IHN0YW5kYXJkVXNlckFnZW50U3RyaW5nIDogc3RhbmRhcmRVc2VyQWdlbnRTdHJpbmcgKyAn ICcgKyBhcHBsaWNhdGlvbk5hbWVGb3JVc2VyQWdlbnQ7CisgICAgcmV0dXJuIFdlYkNvcmU6OnN0 YW5kYXJkVXNlckFnZW50KGFwcGxpY2F0aW9uTmFtZUZvclVzZXJBZ2VudCk7CiB9CiAKIHZvaWQg V2ViUGFnZVByb3h5OjpnZXRFZGl0b3JDb21tYW5kc0ZvcktleUV2ZW50KFZlY3RvcjxXVEY6OlN0 cmluZz4mIC8qY29tbWFuZHNMaXN0Ki8pCg== 265031 2015-11-08 21:52:09 -0800 2015-11-08 23:03:17 -0800 Patch bug-151007-20151109145205.patch text/plain 8998 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTkyMTIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNmJmMzk4N2EzZjY0ZmVh NGFkNmQ5YmFlZjJlYTBkMGY3MjUxN2VmZC4uODNjMDIzMDMyNTZmMTkxZmZlZGQxZTJiMTMzNzc0 Y2E0YzkzMDdhMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDE1LTExLTA4ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ad2Via2l0Lm9yZz4KKworICAgICAgICBbRUZMXSBBZGQg VXNlckFnZW50RUZsLmNwcHxoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNTEwMDcKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KKwor ICAgICAgICBBcyBvdGhlciBwb3J0cyBFRkwgcG9ydCBzdGFydHMgdG8gaGF2ZSBVc2VyQWdlbnRF ZmwgY2xhc3MgaW4gb3JkZXIgdG8gc3VwcG9ydCBtb3JlIGRldGFpbGVkCisgICAgICAgIFVBLgor CisgICAgICAgIE5vIG5ldyB0ZXN0cywgbm8gYmVoYXZpb3IgY2hhbmdlLgorCisgICAgICAgICog UGxhdGZvcm1FZmwuY21ha2U6CisgICAgICAgICogcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5j cHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6cGxhdGZvcm1Gb3JVQVN0cmluZyk6CisgICAg ICAgIChXZWJDb3JlOjpwbGF0Zm9ybVZlcnNpb25Gb3JVQVN0cmluZyk6CisgICAgICAgIChXZWJD b3JlOjp2ZXJzaW9uRm9yVUFTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6c3RhbmRhcmRVc2Vy QWdlbnQpOgorICAgICAgICAqIHBsYXRmb3JtL2VmbC9Vc2VyQWdlbnRFZmwuaDogQWRkZWQuCisK IDIwMTUtMTEtMDYgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAg IE1vZGVybiBJREI6IE1ha2UgdGhlIHJlc3VsdCBkYXRhIGZvciBhICJnZXQiIHJlcXVlc3QgYmUg YW4gSURCR2V0UmVzdWx0LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDMzYzEzN2Q1Nzc1MjBhMTA4MWZiMGYzNWZi NmMzNmVmOGFjM2E4YTYuLmY1MTVlZmFmMjI1ZmJjNGFmNTk4ZjJjNDZlZjc4YTVmYmFjOTE2OWYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxNS0xMS0wOCAgR3l1eW91bmcgS2ltICA8 Z3l1eW91bmcua2ltQHdlYmtpdC5vcmc+CisKKyAgICAgICAgW0VGTF0gQWRkIFVzZXJBZ2VudEVG bC5jcHB8aAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTUxMDA3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgQXMg b3RoZXIgcG9ydHMgRUZMIHBvcnQgc3RhcnRzIHRvIGhhdmUgVXNlckFnZW50RWZsIGNsYXNzIGlu IG9yZGVyIHRvIHN1cHBvcnQgbW9yZSBkZXRhaWxlZAorICAgICAgICBVQS4KKworICAgICAgICAq IFVJUHJvY2Vzcy9lZmwvV2ViUGFnZVByb3h5RWZsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2Vi UGFnZVByb3h5OjpzdGFuZGFyZFVzZXJBZ2VudCk6IENhbGwgV2ViQ29yZTo6c3RhbmRhcmRVc2Vy QWdlbnQoKS4KKwogMjAxNS0xMS0wNiAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5jb20+ CiAKICAgICAgICAgTW9kZXJuIElEQjogTWFrZSB0aGUgcmVzdWx0IGRhdGEgZm9yIGEgImdldCIg cmVxdWVzdCBiZSBhbiBJREJHZXRSZXN1bHQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Q bGF0Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCmluZGV4 IGU1OTdkMDFiYTE1MzQzZDQwYzEzNzVhMWZhM2NjY2Y5OTdiNDQ1MjcuLjVhYzA2NWExMzZmYzRj ZTAxYjljZTFmNjliOGU0MDUyYTg5ZDUwMmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1Bs YXRmb3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtRWZsLmNtYWtlCkBA IC0xMjMsNiArMTIzLDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAgICAgcGxhdGZv cm0vZWZsL1Njcm9sbGJhclRoZW1lRWZsLmNwcAogICAgIHBsYXRmb3JtL2VmbC9Tb3VuZEVmbC5j cHAKICAgICBwbGF0Zm9ybS9lZmwvVGVtcG9yYXJ5TGlua1N0dWJzLmNwcAorICAgIHBsYXRmb3Jt L2VmbC9Vc2VyQWdlbnRFZmwuY3BwCiAgICAgcGxhdGZvcm0vZWZsL1dpZGdldEVmbC5jcHAKIAog ICAgIHBsYXRmb3JtL2dlb2NsdWUvR2VvbG9jYXRpb25Qcm92aWRlckdlb2NsdWUxLmNwcApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lZmwvVXNlckFnZW50RWZsLmNwcApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4x MWZkMzhmYWE2MzhjOWU4OWI2MGEzOTBkMWFhMzU3YWFjZjA1Y2MyCi0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5jcHAKQEAgLTAsMCAr MSw3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBOYXZlciBDb3JwLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl CisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgor ICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVXNlckFnZW50RWZsLmgiCisKKyNpbmNsdWRl ICJXZWJLaXRWZXJzaW9uLmgiCisjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CisKKyNp ZiBPUyhVTklYKQorI2luY2x1ZGUgPHN5cy91dHNuYW1lLmg+CisjZW5kaWYKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitzdGF0aWMgY29uc3QgY2hhciogcGxhdGZvcm1Gb3JVQVN0cmluZygpCit7 CisjaWYgUExBVEZPUk0oWDExKQorICAgIHJldHVybiAiWDExIjsKKyNlbHNlCisgICAgcmV0dXJu ICJVbmtub3duIjsKKyNlbmRpZgorfQorCitzdGF0aWMgU3RyaW5nIHBsYXRmb3JtVmVyc2lvbkZv clVBU3RyaW5nKCkKK3sKKyAgICBTdHJpbmcgdmVyc2lvbjsKKyAgICBzdHJ1Y3QgdXRzbmFtZSBu YW1lOworICAgIGlmICh1bmFtZSgmbmFtZSkgIT0gLTEpCisgICAgICAgIHZlcnNpb24gPSBtYWtl U3RyaW5nKG5hbWUuc3lzbmFtZSwgJyAnLCBuYW1lLm1hY2hpbmUpOworICAgIGVsc2UKKyAgICAg ICAgdmVyc2lvbiA9ICJVbmtub3duIjsKKyAgICByZXR1cm4gdmVyc2lvbjsKK30KKworc3RhdGlj IGNvbnN0IFN0cmluZyB2ZXJzaW9uRm9yVUFTdHJpbmcoKQoreworICAgIHN0YXRpYyBOZXZlckRl c3Ryb3llZDxTdHJpbmc+IHZlcnNpb24oU3RyaW5nOjpmb3JtYXQoIiVpLiVpIiwgV0VCS0lUX01B Sk9SX1ZFUlNJT04sIFdFQktJVF9NSU5PUl9WRVJTSU9OKSk7CisgICAgcmV0dXJuIHZlcnNpb247 Cit9CisKK1N0cmluZyBzdGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9u TmFtZSwgY29uc3QgU3RyaW5nJikKK3sKKyAgICBTdHJpbmcgdmVyc2lvbiA9IHZlcnNpb25Gb3JV QVN0cmluZygpOworICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxTdHJpbmc+IHN0YW5kYXJkVXNl ckFnZW50U3RyaW5nID0gbWFrZVN0cmluZygiTW96aWxsYS81LjAgKCIsIHBsYXRmb3JtRm9yVUFT dHJpbmcoKSwgIjsgIiwgcGxhdGZvcm1WZXJzaW9uRm9yVUFTdHJpbmcoKSwKKyAgICAgICAgIikg QXBwbGVXZWJLaXQvIiwgdmVyc2lvbiwgIiAoS0hUTUwsIGxpa2UgR2Vja28pIFZlcnNpb24vOC4w IFNhZmFyaS82MDEuMi43Iik7CisKKyAgICByZXR1cm4gYXBwbGljYXRpb25OYW1lLmlzRW1wdHko KSA/IHN0YW5kYXJkVXNlckFnZW50U3RyaW5nIDogc3RhbmRhcmRVc2VyQWdlbnRTdHJpbmcgKyAn ICcgKyBhcHBsaWNhdGlvbk5hbWU7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZWZsL1VzZXJBZ2VudEVmbC5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhkZGEw YjMxMjIzODQ5MTZhMzhmNGNlYjBiNmU4MmUwZDVkMTBkNGQKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9lZmwvVXNlckFnZW50RWZsLmgKQEAgLTAsMCArMSwzOCBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNSBOYXZlciBDb3JwLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4g UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAg ICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUg ZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUg SU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAq IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZ CisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVm IFVzZXJBZ2VudEVmbF9oCisjZGVmaW5lIFVzZXJBZ2VudEVmbF9oCisKKyNpbmNsdWRlIDx3dGYv dGV4dC9XVEZTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitTdHJpbmcgc3RhbmRh cmRVc2VyQWdlbnQoY29uc3QgU3RyaW5nJiBhcHBsaWNhdGlvbk5hbWUgPSBlbXB0eVN0cmluZygp LCBjb25zdCBTdHJpbmcmIGFwcGxpY2F0aW9uVmVyc2lvbiA9IGVtcHR5U3RyaW5nKCkpOworCit9 CisKKyNlbmRpZiAvLyBVc2VyQWdlbnRFZmxfaAorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvZWZsL1dlYlBhZ2VQcm94eUVmbC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvZWZsL1dlYlBhZ2VQcm94eUVmbC5jcHAKaW5kZXggYWRjNjQ3MmJjOWMxZmI2OTNjZmU5 ZmI2OWFjYzhkNjc4MzIwMzhiZS4uZjk4OTcyNGY5M2U3ZjhiOTFiMWJiMGZlZWVkMjA0YmQ0NmRm MWFiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2VmbC9XZWJQYWdlUHJv eHlFZmwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9lZmwvV2ViUGFnZVByb3h5 RWZsLmNwcApAQCAtMjksMTQgKzI5LDEyIEBACiAjaW5jbHVkZSAiRXdrVmlldy5oIgogI2luY2x1 ZGUgIk5hdGl2ZVdlYktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5o IgotI2luY2x1ZGUgIldlYktpdFZlcnNpb24uaCIKKyNpbmNsdWRlICJVc2VyQWdlbnRFZmwuaCIK ICNpbmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHku aCIKICNpbmNsdWRlICJXZWJWaWV3LmgiCiAjaW5jbHVkZSAiV2Vic2l0ZURhdGFTdG9yZS5oIgog Ci0jaW5jbHVkZSA8c3lzL3V0c25hbWUuaD4KLQogbmFtZXNwYWNlIFdlYktpdCB7CiAKIHZvaWQg V2ViUGFnZVByb3h5OjpwbGF0Zm9ybUluaXRpYWxpemUoKQpAQCAtNDUsMjggKzQzLDcgQEAgdm9p ZCBXZWJQYWdlUHJveHk6OnBsYXRmb3JtSW5pdGlhbGl6ZSgpCiAKIFN0cmluZyBXZWJQYWdlUHJv eHk6OnN0YW5kYXJkVXNlckFnZW50KGNvbnN0IFN0cmluZyYgYXBwbGljYXRpb25OYW1lRm9yVXNl ckFnZW50KQogewotICAgIFN0cmluZyBwbGF0Zm9ybTsKLSAgICBTdHJpbmcgdmVyc2lvbjsKLSAg ICBTdHJpbmcgb3NWZXJzaW9uOwotICAgIFN0cmluZyBzdGFuZGFyZFVzZXJBZ2VudFN0cmluZzsK LQotI2lmIFBMQVRGT1JNKFgxMSkKLSAgICBwbGF0Zm9ybSA9ICJYMTEiOwotI2Vsc2UKLSAgICBw bGF0Zm9ybSA9ICJVbmtub3duIjsKLSNlbmRpZgotCi0gICAgdmVyc2lvbiA9IFN0cmluZzo6bnVt YmVyKFdFQktJVF9NQUpPUl9WRVJTSU9OKSArICcuJyArIFN0cmluZzo6bnVtYmVyKFdFQktJVF9N SU5PUl9WRVJTSU9OKSArICcrJzsKLSAgICBzdHJ1Y3QgdXRzbmFtZSBuYW1lOwotICAgIGlmICh1 bmFtZSgmbmFtZSkgIT0gLTEpCi0gICAgICAgIG9zVmVyc2lvbiA9IFdURjo6U3RyaW5nKG5hbWUu c3lzbmFtZSkgKyAiICIgKyBXVEY6OlN0cmluZyhuYW1lLm1hY2hpbmUpOwotICAgIGVsc2UKLSAg ICAgICAgb3NWZXJzaW9uID0gIlVua25vd24iOwotCi0gICAgc3RhbmRhcmRVc2VyQWdlbnRTdHJp bmcgPSAiTW96aWxsYS81LjAgKCIgKyBwbGF0Zm9ybSArICI7ICIgKyBvc1ZlcnNpb24gKyAiKSBB cHBsZVdlYktpdC8iICsgdmVyc2lvbgotICAgICAgICArICIgKEtIVE1MLCBsaWtlIEdlY2tvKSBW ZXJzaW9uLzguMCBTYWZhcmkvIiArIHZlcnNpb247Ci0KLSAgICByZXR1cm4gYXBwbGljYXRpb25O YW1lRm9yVXNlckFnZW50LmlzRW1wdHkoKSA/IHN0YW5kYXJkVXNlckFnZW50U3RyaW5nIDogc3Rh bmRhcmRVc2VyQWdlbnRTdHJpbmcgKyAnICcgKyBhcHBsaWNhdGlvbk5hbWVGb3JVc2VyQWdlbnQ7 CisgICAgcmV0dXJuIFdlYkNvcmU6OnN0YW5kYXJkVXNlckFnZW50KGFwcGxpY2F0aW9uTmFtZUZv clVzZXJBZ2VudCk7CiB9CiAKIHZvaWQgV2ViUGFnZVByb3h5OjpnZXRFZGl0b3JDb21tYW5kc0Zv cktleUV2ZW50KFZlY3RvcjxXVEY6OlN0cmluZz4mIC8qY29tbWFuZHNMaXN0Ki8pCg==