102054 2012-11-13 00:27:30 -0800 [EFL][WK2] Add APIs to get/set whether scripts can open new windows. 2012-11-15 04:14:05 -0800 1 1 1 Unclassified WebKit WebKit EFL 528+ (Nightly build) Other Linux RESOLVED FIXED P2 Normal --- 0 yhnet.jung webkit-unassigned gyuyoung.kim lucas.de.marchi mikhail.pozdnyakov rakuco webkit.review.bot oldest_to_newest 765341 0 yhnet.jung 2012-11-13 00:27:30 -0800 Added setting APIs make it possible to allow or prevent scripts from opening the new windows automatically. 765435 1 173856 yhnet.jung 2012-11-13 02:57:39 -0800 Created attachment 173856 Patch 766861 2 173856 rakuco 2012-11-14 07:07:31 -0800 Comment on attachment 173856 Patch Looks good to me, with an English nitpick: "open the new windows" -> "open new windows". 767659 3 174331 yhnet.jung 2012-11-14 20:17:36 -0800 Created attachment 174331 Patch 767661 4 yhnet.jung 2012-11-14 20:21:21 -0800 I changed: "open the new windows" -> "open new windows". 767671 5 174331 gyuyoung.kim 2012-11-14 20:36:42 -0800 Comment on attachment 174331 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=174331&action=review > Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp:323 > + EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); I think we don't need to set if enable value is same as current value. For example, you may add this condition. bool currentValue = settings->preferences()->javaScriptCanOpenWindowsAutomatically(); if (currentValue == enable) return; 767883 6 174331 yhnet.jung 2012-11-15 03:00:08 -0800 Comment on attachment 174331 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=174331&action=review >> Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp:323 >> + EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); > > I think we don't need to set if enable value is same as current value. > > For example, you may add this condition. > > bool currentValue = settings->preferences()->javaScriptCanOpenWindowsAutomatically(); > if (currentValue == enable) > return; I agree to your idea. But, other APIs to set enable value do not check above condition. Above condition must be added in this function? 767886 7 gyuyoung.kim 2012-11-15 03:03:59 -0800 (In reply to comment #6) > I agree to your idea. > But, other APIs to set enable value do not check above condition. > Above condition must be added in this function? I think so. We don't need to set even though current setting is set as parameter. I think other settings functions need to have this checking condition. 767893 8 174331 cdumez 2012-11-15 03:11:09 -0800 Comment on attachment 174331 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=174331&action=review >>> Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp:323 >>> + EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); >> >> I think we don't need to set if enable value is same as current value. >> >> For example, you may add this condition. >> >> bool currentValue = settings->preferences()->javaScriptCanOpenWindowsAutomatically(); >> if (currentValue == enable) >> return; > > I agree to your idea. > But, other APIs to set enable value do not check above condition. > Above condition must be added in this function? I think such if check would make sense if the operation was expensive. However, these are settings and the behavior is usually to set a boolean flag in memory. In practice, adding the if check may make it slower for no good reason. See for e.g.: void Settings::setJavaScriptCanOpenWindowsAutomatically(bool javaScriptCanOpenWindowsAutomatically) { m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; } Would it really make sense to do if (m_javaScriptCanOpenWindowsAutomatically != javaScriptCanOpenWindowsAutomatically) m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; ? 767919 9 gyuyoung.kim 2012-11-15 03:47:20 -0800 (In reply to comment #8) > (From update of attachment 174331 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=174331&action=review > > >>> Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp:323 > >>> + EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); > >> > >> I think we don't need to set if enable value is same as current value. > >> > >> For example, you may add this condition. > >> > >> bool currentValue = settings->preferences()->javaScriptCanOpenWindowsAutomatically(); > >> if (currentValue == enable) > >> return; > > > > I agree to your idea. > > But, other APIs to set enable value do not check above condition. > > Above condition must be added in this function? > > I think such if check would make sense if the operation was expensive. However, these are settings and the behavior is usually to set a boolean flag in memory. In practice, adding the if check may make it slower for no good reason. > > See for e.g.: > > void Settings::setJavaScriptCanOpenWindowsAutomatically(bool javaScriptCanOpenWindowsAutomatically) > { > m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; > } > > Would it really make sense to do if (m_javaScriptCanOpenWindowsAutomatically != javaScriptCanOpenWindowsAutomatically) m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; ? When we add this check, I also think there is no big performance gain because this is not expensive operation. In addition, to add this condition is not big operation. However, I think it doesn't generally make sense we set same value again. If the settings operation become a expensive stuff, I think this checking will prevent to waste our resource in future. Honestly, now there is no gain by this checking. But, if we add additional operation in ewk_settings_xxx function as below, Eina_Bool ewk_settings_encoding_detector_enabled_set(Ewk_Settings* settings, Eina_Bool enable) { EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); settings->preferences()->setUsesEncodingDetector(enable); // To do something. return true; } In this case, we have to add this checking. But, I think it would be not bad if we add this now in order to prevent to do unnecessary operations in future. 767929 10 174331 cdumez 2012-11-15 04:03:09 -0800 Comment on attachment 174331 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=174331&action=review >>>>> Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp:323 >>>>> + EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); >>>> >>>> I think we don't need to set if enable value is same as current value. >>>> >>>> For example, you may add this condition. >>>> >>>> bool currentValue = settings->preferences()->javaScriptCanOpenWindowsAutomatically(); >>>> if (currentValue == enable) >>>> return; >>> >>> I agree to your idea. >>> But, other APIs to set enable value do not check above condition. >>> Above condition must be added in this function? >> >> I think such if check would make sense if the operation was expensive. However, these are settings and the behavior is usually to set a boolean flag in memory. In practice, adding the if check may make it slower for no good reason. >> >> See for e.g.: >> >> void Settings::setJavaScriptCanOpenWindowsAutomatically(bool javaScriptCanOpenWindowsAutomatically) >> { >> m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; >> } >> >> Would it really make sense to do if (m_javaScriptCanOpenWindowsAutomatically != javaScriptCanOpenWindowsAutomatically) m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; ? > > When we add this check, I also think there is no big performance gain because this is not expensive operation. In addition, to add this condition is not big operation. However, I think it doesn't generally make sense we set same value again. If the settings operation become a expensive stuff, I think this checking will prevent to waste our resource in future. > > Honestly, now there is no gain by this checking. But, if we add additional operation in ewk_settings_xxx function as below, > > Eina_Bool ewk_settings_encoding_detector_enabled_set(Ewk_Settings* settings, Eina_Bool enable) > { > EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); > > settings->preferences()->setUsesEncodingDetector(enable); > > // To do something. > > return true; > } > > In this case, we have to add this checking. But, I think it would be not bad if we add this now in order to prevent to do unnecessary operations in future. Yes, I agree with you that if it does something more that setting a flag, adding a change check is worth it. However, it is not the case at the moment, and I would like to avoid refactoring which adds more code (and potentially decreases performance) unless we really need to. If more logic is added later which may take time, then we can optimize then, by adding the change check as you suggest. I would hold off on it until then though. 767932 11 mikhail.pozdnyakov 2012-11-15 04:09:37 -0800 (In reply to comment #9) > (In reply to comment #8) > > (From update of attachment 174331 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=174331&action=review > > > > >>> Source/WebKit2/UIProcess/API/efl/ewk_settings.cpp:323 > > >>> + EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); > > >> > > >> I think we don't need to set if enable value is same as current value. > > >> > > >> For example, you may add this condition. > > >> > > >> bool currentValue = settings->preferences()->javaScriptCanOpenWindowsAutomatically(); > > >> if (currentValue == enable) > > >> return; > > > > > > I agree to your idea. > > > But, other APIs to set enable value do not check above condition. > > > Above condition must be added in this function? > > > > I think such if check would make sense if the operation was expensive. However, these are settings and the behavior is usually to set a boolean flag in memory. In practice, adding the if check may make it slower for no good reason. > > > > See for e.g.: > > > > void Settings::setJavaScriptCanOpenWindowsAutomatically(bool javaScriptCanOpenWindowsAutomatically) > > { > > m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; > > } > > > > Would it really make sense to do if (m_javaScriptCanOpenWindowsAutomatically != javaScriptCanOpenWindowsAutomatically) m_javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically; ? > > When we add this check, I also think there is no big performance gain because this is not expensive operation. In addition, to add this condition is not big operation. However, I think it doesn't generally make sense we set same value again. If the settings operation become a expensive stuff, I think this checking will prevent to waste our resource in future. > > Honestly, now there is no gain by this checking. But, if we add additional operation in ewk_settings_xxx function as below, > > Eina_Bool ewk_settings_encoding_detector_enabled_set(Ewk_Settings* settings, Eina_Bool enable) > { > EINA_SAFETY_ON_NULL_RETURN_VAL(settings, false); > > settings->preferences()->setUsesEncodingDetector(enable); > > // To do something. > > return true; > } > > In this case, we have to add this checking. But, I think it would be not bad if we add this now in order to prevent to do unnecessary operations in future. I would not put it as a rule to be done dogmatically every time, and introduce the check only in cases when we really have an expensive operation. 767933 12 gyuyoung.kim 2012-11-15 04:10:58 -0800 (In reply to comment #10) > Yes, I agree with you that if it does something more that setting a flag, adding a change check is worth it. > However, it is not the case at the moment, and I would like to avoid refactoring which adds more code (and potentially decreases performance) unless we really need to. If more logic is added later which may take time, then we can optimize then, by adding the change check as you suggest. I would hold off on it until then though. This is timing problem. Ok, let's do that. 767934 13 174331 webkit.review.bot 2012-11-15 04:14:00 -0800 Comment on attachment 174331 Patch Clearing flags on attachment: 174331 Committed r134760: <http://trac.webkit.org/changeset/134760> 767935 14 webkit.review.bot 2012-11-15 04:14:05 -0800 All reviewed patches have been landed. Closing bug. 173856 2012-11-13 02:57:39 -0800 2012-11-14 20:17:27 -0800 Patch bug-102054-20121113195540.patch text/plain 4624 yhnet.jung U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0Mzc2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNmM4NDE0MTA4MjI1NDEx NmNiNDZjMGZhMzc1ODRkYjc3ZjJmMDg3MC4uMGE3N2I5MTlmYTI2NDVmZTAxNzBjZDNmNzE1NzM5 MzI3Mzc2ZjljMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTExLTEzICBZdW5p IEplb25nICA8eWhuZXQuanVuZ0BzYW1zdW5nLmNvbT4KKworICAgICAgICBbRUZMXVtXSzJdIEFk ZCBBUElzIHRvIGdldC9zZXQgd2hldGhlciBzY3JpcHRzIGNhbiBvcGVuIHRoZSBuZXcgd2luZG93 cy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjA1 NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVk IHNldHRpbmcgQVBJcyBtYWtlIGl0IHBvc3NpYmxlIHRvIGFsbG93IG9yIHByZXZlbnQgc2NyaXB0 cyBmcm9tIG9wZW5pbmcgdGhlIG5ldyB3aW5kb3dzIGF1dG9tYXRpY2FsbHkuCisKKyAgICAgICAg KiBVSVByb2Nlc3MvQVBJL2VmbC9ld2tfc2V0dGluZ3MuY3BwOgorICAgICAgICAoZXdrX3NldHRp bmdzX3NjcmlwdHNfY2FuX29wZW5fd2luZG93c19zZXQpOgorICAgICAgICAoZXdrX3NldHRpbmdz X3NjcmlwdHNfY2FuX29wZW5fd2luZG93c19nZXQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkv ZWZsL2V3a19zZXR0aW5ncy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZWZsL3Rlc3RzL3Rl c3RfZXdrMl9zZXR0aW5ncy5jcHA6CisgICAgICAgIChURVNUX0YpOgorCiAyMDEyLTExLTEzICBI dWFuZyBEb25nc3VuZyAgPGx1eHRlbGxhQGNvbXBhbnkxMDAubmV0PgogCiAgICAgICAgIENvb3Jk aW5hdGVkIEdyYXBoaWNzOiBEaXJlY3RseSBjb21wb3NpdGVkIGFuaW1hdGVkIEdJRnMgb25seSBy ZW5kZXIgdGhlIGZpcnN0IGltYWdlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9lZmwvZXdrX3NldHRpbmdzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZWZsL2V3a19zZXR0aW5ncy5jcHAKaW5kZXggNzc5ZWYyYjIwZDk0ODg3ZjliN2FjMjYyNzcy OWRlZTE2MTg0ODM3Ni4uZTY5NWU5YmI3OTVkMTQzNmYwNWI4NDdiMDk4MTVhMDY2MjkxNTViOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX3NldHRpbmdz LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfc2V0dGluZ3Mu Y3BwCkBAIC0zMTcsMyArMzE3LDE4IEBAIEVpbmFfQm9vbCBld2tfc2V0dGluZ3Nfb2ZmbGluZV93 ZWJfYXBwbGljYXRpb25fY2FjaGVfZW5hYmxlZF9nZXQoY29uc3QgRXdrX1NldHRpCiAKICAgICBy ZXR1cm4gc2V0dGluZ3MtPnByZWZlcmVuY2VzKCktPm9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hl RW5hYmxlZCgpOwogfQorCitFaW5hX0Jvb2wgZXdrX3NldHRpbmdzX3NjcmlwdHNfY2FuX29wZW5f d2luZG93c19zZXQoRXdrX1NldHRpbmdzKiBzZXR0aW5ncywgRWluYV9Cb29sIGVuYWJsZSkKK3sK KyAgICBFSU5BX1NBRkVUWV9PTl9OVUxMX1JFVFVSTl9WQUwoc2V0dGluZ3MsIGZhbHNlKTsKKyAg ICBzZXR0aW5ncy0+cHJlZmVyZW5jZXMoKS0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0 b21hdGljYWxseShlbmFibGUpOworCisgICAgcmV0dXJuIHRydWU7Cit9CisKK0VpbmFfQm9vbCBl d2tfc2V0dGluZ3Nfc2NyaXB0c19jYW5fb3Blbl93aW5kb3dzX2dldChjb25zdCBFd2tfU2V0dGlu Z3MqIHNldHRpbmdzKQoreworICAgIEVJTkFfU0FGRVRZX09OX05VTExfUkVUVVJOX1ZBTChzZXR0 aW5ncywgZmFsc2UpOworCisgICAgcmV0dXJuIHNldHRpbmdzLT5wcmVmZXJlbmNlcygpLT5qYXZh U2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5KCk7Cit9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfc2V0dGluZ3MuaCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19zZXR0aW5ncy5oCmluZGV4IDU5NDgyMDFmMGYzYTc5 ZTM0YWQzY2RhZjUzZGRmZTcwN2E4NDM0NzguLjgyNTE2MWFjMDBjODUwZWIyNmE2MjA2YzQ4NDYw ODViOTBiNDc5MjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZs L2V3a19zZXR0aW5ncy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3 a19zZXR0aW5ncy5oCkBAIC0zNjgsNiArMzY4LDI5IEBAIEVBUEkgRWluYV9Cb29sIGV3a19zZXR0 aW5nc19vZmZsaW5lX3dlYl9hcHBsaWNhdGlvbl9jYWNoZV9lbmFibGVkX3NldChFd2tfU2V0dGlu CiAgKi8KIEVBUEkgRWluYV9Cb29sIGV3a19zZXR0aW5nc19vZmZsaW5lX3dlYl9hcHBsaWNhdGlv bl9jYWNoZV9lbmFibGVkX2dldChjb25zdCBFd2tfU2V0dGluZ3MgKnNldHRpbmdzKTsKIAorLyoq CisgKiBFbmFibGVzL2Rpc2FibGVzIGlmIHRoZSBzY3JpcHRzIGNhbiBvcGVuIHRoZSBuZXcgd2lu ZG93cy4KKyAqCisgKiBCeSBkZWZhdWx0LCB0aGUgc2NyaXB0cyBjYW4gb3BlbiB0aGUgbmV3IHdp bmRvd3MuCisgKgorICogQHBhcmFtIHNldHRpbmdzIHNldHRpbmdzIG9iamVjdCB0byBzZXQgaWYg dGhlIHNjcmlwdHMgY2FuIG9wZW4gdGhlIG5ldyB3aW5kb3dzCisgKiBAcGFyYW0gZW5hYmxlIEBj IEVJTkFfVFJVRSBpZiB0aGUgc2NyaXB0cyBjYW4gb3BlbiB0aGUgbmV3IHdpbmRvd3MKKyAqICAg ICAgICBAYyBFSU5BX0ZBTFNFIGlmIG5vdAorICoKKyAqIEByZXR1cm4gQGMgRUlOQV9UUlVFIG9u IHN1Y2Nlc3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWlsdXJlIChzY3JpcHRzIGFyZSBkaXNhYmxl ZCkKKyAqLworRUFQSSBFaW5hX0Jvb2wgZXdrX3NldHRpbmdzX3NjcmlwdHNfY2FuX29wZW5fd2lu ZG93c19zZXQoRXdrX1NldHRpbmdzICpzZXR0aW5ncywgRWluYV9Cb29sIGVuYWJsZSk7CisKKy8q KgorICogUmV0dXJucyB3aGV0aGVyIHRoZSBzY3JpcHRzIGNhbiBvcGVuIHRoZSBuZXcgd2luZG93 cy4KKyAqCisgKiBAcGFyYW0gc2V0dGluZ3Mgc2V0dGluZ3Mgb2JqZWN0IHRvIHF1ZXJ5IHdoZXRo ZXIgdGhlIHNjcmlwdHMgY2FuIG9wZW4gdGhlIG5ldyB3aW5kb3dzCisgKgorICogQHJldHVybiBA YyBFSU5BX1RSVUUgaWYgdGhlIHNjcmlwdHMgY2FuIG9wZW4gdGhlIG5ldyB3aW5kb3dzCisgKiAg ICAgICAgIEBjIEVJTkFfRkFMU0UgaWYgbm90IG9yIG9uIGZhaWx1cmUgKHNjcmlwdHMgYXJlIGRp c2FibGVkKQorICovCitFQVBJIEVpbmFfQm9vbCBld2tfc2V0dGluZ3Nfc2NyaXB0c19jYW5fb3Bl bl93aW5kb3dzX2dldChjb25zdCBFd2tfU2V0dGluZ3MgKnNldHRpbmdzKTsKKwogI2lmZGVmIF9f Y3BsdXNwbHVzCiB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZWZsL3Rlc3RzL3Rlc3RfZXdrMl9zZXR0aW5ncy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2VmbC90ZXN0cy90ZXN0X2V3azJfc2V0dGluZ3MuY3BwCmluZGV4IDBkMzZj OTljNThmOTE2MmNmOTRjOThhYjE2MTA1NGZjNzVhMGE4NDIuLjY2YTJkYTc0MTBhYTViN2I4Mzgw N2VhMzlhMTc3Y2U1YzA2ZTA3YmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZWZsL3Rlc3RzL3Rlc3RfZXdrMl9zZXR0aW5ncy5jcHAKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9lZmwvdGVzdHMvdGVzdF9ld2syX3NldHRpbmdzLmNwcApAQCAtMTk3 LDMgKzE5NywxNiBAQCBURVNUX0YoRVdLMlVuaXRUZXN0QmFzZSwgZXdrX3NldHRpbmdzX29mZmxp bmVfd2ViX2FwcGxpY2F0aW9uX2NhY2hlX2VuYWJsZWQpCiAgICAgQVNTRVJUX0ZBTFNFKGV3a19z ZXR0aW5nc19vZmZsaW5lX3dlYl9hcHBsaWNhdGlvbl9jYWNoZV9lbmFibGVkX2dldChzZXR0aW5n cykpOwogfQogCitURVNUX0YoRVdLMlVuaXRUZXN0QmFzZSwgZXdrX3NldHRpbmdzX3NjcmlwdHNf Y2FuX29wZW5fd2luZG93cykKK3sKKyAgICBFd2tfU2V0dGluZ3MqIHNldHRpbmdzID0gZXdrX3Zp ZXdfc2V0dGluZ3NfZ2V0KHdlYlZpZXcoKSk7CisKKyAgICAvLyBUaGUgc2NyaXB0cyBjYW4gb3Bl biB0aGUgbmV3IHdpbmRvd3MgYnkgZGVmYXVsdC4KKyAgICBBU1NFUlRfVFJVRShld2tfc2V0dGlu Z3Nfc2NyaXB0c19jYW5fb3Blbl93aW5kb3dzX2dldChzZXR0aW5ncykpOworCisgICAgQVNTRVJU X1RSVUUoZXdrX3NldHRpbmdzX3NjcmlwdHNfY2FuX29wZW5fd2luZG93c19zZXQoc2V0dGluZ3Ms IHRydWUpKTsKKyAgICBBU1NFUlRfVFJVRShld2tfc2V0dGluZ3Nfc2NyaXB0c19jYW5fb3Blbl93 aW5kb3dzX2dldChzZXR0aW5ncykpOworCisgICAgQVNTRVJUX1RSVUUoZXdrX3NldHRpbmdzX3Nj cmlwdHNfY2FuX29wZW5fd2luZG93c19zZXQoc2V0dGluZ3MsIGZhbHNlKSk7CisgICAgQVNTRVJU X0ZBTFNFKGV3a19zZXR0aW5nc19zY3JpcHRzX2Nhbl9vcGVuX3dpbmRvd3NfZ2V0KHNldHRpbmdz KSk7Cit9Cg== 174331 2012-11-14 20:17:36 -0800 2012-11-15 04:14:00 -0800 Patch bug-102054-20121115131534.patch text/plain 4537 yhnet.jung U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0NzIwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZDAyNGIxZjdhZjk2MWI4 ZTcxMTJmZmYxNzMxN2ZkODExMjExNWQ1Yi4uNWE5ZTNjZDY2MDViYTg5NmFiYWIzZTI1Zjg3MDMy Y2Q3M2Y5OTNkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTExLTE0ICBZdW5p IEplb25nICA8eWhuZXQuanVuZ0BzYW1zdW5nLmNvbT4KKworICAgICAgICBbRUZMXVtXSzJdIEFk ZCBBUElzIHRvIGdldC9zZXQgd2hldGhlciBzY3JpcHRzIGNhbiBvcGVuIG5ldyB3aW5kb3dzLgor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTAyMDU0CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgc2V0 dGluZyBBUElzIG1ha2UgaXQgcG9zc2libGUgdG8gYWxsb3cgb3IgcHJldmVudCBzY3JpcHRzIGZy b20gb3BlbmluZyBuZXcgd2luZG93cyBhdXRvbWF0aWNhbGx5LgorCisgICAgICAgICogVUlQcm9j ZXNzL0FQSS9lZmwvZXdrX3NldHRpbmdzLmNwcDoKKyAgICAgICAgKGV3a19zZXR0aW5nc19zY3Jp cHRzX2Nhbl9vcGVuX3dpbmRvd3Nfc2V0KToKKyAgICAgICAgKGV3a19zZXR0aW5nc19zY3JpcHRz X2Nhbl9vcGVuX3dpbmRvd3NfZ2V0KToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2VmbC9ld2tf c2V0dGluZ3MuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2VmbC90ZXN0cy90ZXN0X2V3azJf c2V0dGluZ3MuY3BwOgorICAgICAgICAoVEVTVF9GKToKKwogMjAxMi0xMS0xNCAgQnJlbnQgRnVs Z2hhbSAgPGJmdWxnaGFtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgW1dpbkNhaXJvXSBCdWlsZCBj b3JyZWN0aW9uIGFmdGVyIHIxMzQ3MDMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2VmbC9ld2tfc2V0dGluZ3MuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9lZmwvZXdrX3NldHRpbmdzLmNwcAppbmRleCA3NzllZjJiMjBkOTQ4ODdmOWI3YWMyNjI3 NzI5ZGVlMTYxODQ4Mzc2Li5lNjk1ZTliYjc5NWQxNDM2ZjA1Yjg0N2IwOTgxNWEwNjYyOTE1NWI5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC9ld2tfc2V0dGlu Z3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19zZXR0aW5n cy5jcHAKQEAgLTMxNywzICszMTcsMTggQEAgRWluYV9Cb29sIGV3a19zZXR0aW5nc19vZmZsaW5l X3dlYl9hcHBsaWNhdGlvbl9jYWNoZV9lbmFibGVkX2dldChjb25zdCBFd2tfU2V0dGkKIAogICAg IHJldHVybiBzZXR0aW5ncy0+cHJlZmVyZW5jZXMoKS0+b2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2Fj aGVFbmFibGVkKCk7CiB9CisKK0VpbmFfQm9vbCBld2tfc2V0dGluZ3Nfc2NyaXB0c19jYW5fb3Bl bl93aW5kb3dzX3NldChFd2tfU2V0dGluZ3MqIHNldHRpbmdzLCBFaW5hX0Jvb2wgZW5hYmxlKQor eworICAgIEVJTkFfU0FGRVRZX09OX05VTExfUkVUVVJOX1ZBTChzZXR0aW5ncywgZmFsc2UpOwor ICAgIHNldHRpbmdzLT5wcmVmZXJlbmNlcygpLT5zZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NB dXRvbWF0aWNhbGx5KGVuYWJsZSk7CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKworRWluYV9Cb29s IGV3a19zZXR0aW5nc19zY3JpcHRzX2Nhbl9vcGVuX3dpbmRvd3NfZ2V0KGNvbnN0IEV3a19TZXR0 aW5ncyogc2V0dGluZ3MpCit7CisgICAgRUlOQV9TQUZFVFlfT05fTlVMTF9SRVRVUk5fVkFMKHNl dHRpbmdzLCBmYWxzZSk7CisKKyAgICByZXR1cm4gc2V0dGluZ3MtPnByZWZlcmVuY2VzKCktPmph dmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHkoKTsKK30KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL2V3a19zZXR0aW5ncy5oIGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvZXdrX3NldHRpbmdzLmgKaW5kZXggNTk0ODIwMWYwZjNh NzllMzRhZDNjZGFmNTNkZGZlNzA3YTg0MzQ3OC4uZmU2MmI4Yjg3NjdiNTMzZTUzMDI3OGVlNzlm ZjQ5ZTM3YjNmNjc4YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9l ZmwvZXdrX3NldHRpbmdzLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwv ZXdrX3NldHRpbmdzLmgKQEAgLTM2OCw2ICszNjgsMjkgQEAgRUFQSSBFaW5hX0Jvb2wgZXdrX3Nl dHRpbmdzX29mZmxpbmVfd2ViX2FwcGxpY2F0aW9uX2NhY2hlX2VuYWJsZWRfc2V0KEV3a19TZXR0 aW4KICAqLwogRUFQSSBFaW5hX0Jvb2wgZXdrX3NldHRpbmdzX29mZmxpbmVfd2ViX2FwcGxpY2F0 aW9uX2NhY2hlX2VuYWJsZWRfZ2V0KGNvbnN0IEV3a19TZXR0aW5ncyAqc2V0dGluZ3MpOwogCisv KioKKyAqIEVuYWJsZXMvZGlzYWJsZXMgaWYgdGhlIHNjcmlwdHMgY2FuIG9wZW4gbmV3IHdpbmRv d3MuCisgKgorICogQnkgZGVmYXVsdCwgdGhlIHNjcmlwdHMgY2FuIG9wZW4gbmV3IHdpbmRvd3Mu CisgKgorICogQHBhcmFtIHNldHRpbmdzIHNldHRpbmdzIG9iamVjdCB0byBzZXQgaWYgdGhlIHNj cmlwdHMgY2FuIG9wZW4gbmV3IHdpbmRvd3MKKyAqIEBwYXJhbSBlbmFibGUgQGMgRUlOQV9UUlVF IGlmIHRoZSBzY3JpcHRzIGNhbiBvcGVuIG5ldyB3aW5kb3dzCisgKiAgICAgICAgQGMgRUlOQV9G QUxTRSBpZiBub3QKKyAqCisgKiBAcmV0dXJuIEBjIEVJTkFfVFJVRSBvbiBzdWNjZXNzIG9yIEBj IEVJTkFfRkFMU0Ugb24gZmFpbHVyZSAoc2NyaXB0cyBhcmUgZGlzYWJsZWQpCisgKi8KK0VBUEkg RWluYV9Cb29sIGV3a19zZXR0aW5nc19zY3JpcHRzX2Nhbl9vcGVuX3dpbmRvd3Nfc2V0KEV3a19T ZXR0aW5ncyAqc2V0dGluZ3MsIEVpbmFfQm9vbCBlbmFibGUpOworCisvKioKKyAqIFJldHVybnMg d2hldGhlciB0aGUgc2NyaXB0cyBjYW4gb3BlbiBuZXcgd2luZG93cy4KKyAqCisgKiBAcGFyYW0g c2V0dGluZ3Mgc2V0dGluZ3Mgb2JqZWN0IHRvIHF1ZXJ5IHdoZXRoZXIgdGhlIHNjcmlwdHMgY2Fu IG9wZW4gbmV3IHdpbmRvd3MKKyAqCisgKiBAcmV0dXJuIEBjIEVJTkFfVFJVRSBpZiB0aGUgc2Ny aXB0cyBjYW4gb3BlbiBuZXcgd2luZG93cworICogICAgICAgICBAYyBFSU5BX0ZBTFNFIGlmIG5v dCBvciBvbiBmYWlsdXJlIChzY3JpcHRzIGFyZSBkaXNhYmxlZCkKKyAqLworRUFQSSBFaW5hX0Jv b2wgZXdrX3NldHRpbmdzX3NjcmlwdHNfY2FuX29wZW5fd2luZG93c19nZXQoY29uc3QgRXdrX1Nl dHRpbmdzICpzZXR0aW5ncyk7CisKICNpZmRlZiBfX2NwbHVzcGx1cwogfQogI2VuZGlmCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC90ZXN0cy90ZXN0X2V3azJf c2V0dGluZ3MuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9lZmwvdGVzdHMvdGVz dF9ld2syX3NldHRpbmdzLmNwcAppbmRleCAwZDM2Yzk5YzU4ZjkxNjJjZjk0Yzk4YWIxNjEwNTRm Yzc1YTBhODQyLi5kOWYwZmRiZDQ2NWIxYjdhZjBjZTMwNjE0NWFiYjQ2NjM4NzIwOTI3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2VmbC90ZXN0cy90ZXN0X2V3azJf c2V0dGluZ3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZWZsL3Rlc3Rz L3Rlc3RfZXdrMl9zZXR0aW5ncy5jcHAKQEAgLTE5NywzICsxOTcsMTYgQEAgVEVTVF9GKEVXSzJV bml0VGVzdEJhc2UsIGV3a19zZXR0aW5nc19vZmZsaW5lX3dlYl9hcHBsaWNhdGlvbl9jYWNoZV9l bmFibGVkKQogICAgIEFTU0VSVF9GQUxTRShld2tfc2V0dGluZ3Nfb2ZmbGluZV93ZWJfYXBwbGlj YXRpb25fY2FjaGVfZW5hYmxlZF9nZXQoc2V0dGluZ3MpKTsKIH0KIAorVEVTVF9GKEVXSzJVbml0 VGVzdEJhc2UsIGV3a19zZXR0aW5nc19zY3JpcHRzX2Nhbl9vcGVuX3dpbmRvd3MpCit7CisgICAg RXdrX1NldHRpbmdzKiBzZXR0aW5ncyA9IGV3a192aWV3X3NldHRpbmdzX2dldCh3ZWJWaWV3KCkp OworCisgICAgLy8gVGhlIHNjcmlwdHMgY2FuIG9wZW4gbmV3IHdpbmRvd3MgYnkgZGVmYXVsdC4K KyAgICBBU1NFUlRfVFJVRShld2tfc2V0dGluZ3Nfc2NyaXB0c19jYW5fb3Blbl93aW5kb3dzX2dl dChzZXR0aW5ncykpOworCisgICAgQVNTRVJUX1RSVUUoZXdrX3NldHRpbmdzX3NjcmlwdHNfY2Fu X29wZW5fd2luZG93c19zZXQoc2V0dGluZ3MsIHRydWUpKTsKKyAgICBBU1NFUlRfVFJVRShld2tf c2V0dGluZ3Nfc2NyaXB0c19jYW5fb3Blbl93aW5kb3dzX2dldChzZXR0aW5ncykpOworCisgICAg QVNTRVJUX1RSVUUoZXdrX3NldHRpbmdzX3NjcmlwdHNfY2FuX29wZW5fd2luZG93c19zZXQoc2V0 dGluZ3MsIGZhbHNlKSk7CisgICAgQVNTRVJUX0ZBTFNFKGV3a19zZXR0aW5nc19zY3JpcHRzX2Nh bl9vcGVuX3dpbmRvd3NfZ2V0KHNldHRpbmdzKSk7Cit9Cg==