90603 2012-07-05 05:09:18 -0700 [EFL] Support the permission function of the Web Notification. 2017-03-11 10:34:43 -0800 1 1 1 Unclassified WebKit WebKit EFL 528+ (Nightly build) Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 88919 90936 73544 95925 0 kihong.kwon webkit-unassigned cdumez donggwan.kim gyuyoung.kim gyuyoung.kim haraken jinwoo7.song kenneth lucas.de.marchi mcatanzaro rakuco tmpsantos vimff0 webkit.review.bot oldest_to_newest 663498 0 kihong.kwon 2012-07-05 05:09:18 -0700 Implement checkPermission and requestPermission of Web Notification. 663928 1 151029 kihong.kwon 2012-07-06 01:04:50 -0700 Created attachment 151029 Patch 664636 2 151029 gyuyoung.kim 2012-07-08 22:07:31 -0700 Comment on attachment 151029 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151029&action=review > Source/WebKit/efl/ewk/ewk_view.cpp:4526 > + delete requestedDomain; Isn't free() better ? Because, strdup uses malloc. > Source/WebKit/efl/ewk/ewk_view.cpp:4533 > + delete requestedDomain; ditto. 664647 3 kihong.kwon 2012-07-08 22:31:45 -0700 (In reply to comment #2) > (From update of attachment 151029 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=151029&action=review > > > Source/WebKit/efl/ewk/ewk_view.cpp:4526 > > + delete requestedDomain; > > Isn't free() better ? Because, strdup uses malloc. > > > Source/WebKit/efl/ewk/ewk_view.cpp:4533 > > + delete requestedDomain; > > ditto. OK, I will fix them in next patch. Thanks. 664652 4 151029 cdumez 2012-07-08 22:41:11 -0700 Comment on attachment 151029 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151029&action=review > Source/WebKit/efl/ChangeLog:9 > + Stored permissions in the outside application(like a browser) can be cached by ewk_view_notification_permissions_set. "can be cached using ewk_..." > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:93 > + String domain = context->url().host(); #if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS) ? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:99 > + m_pendingLegacyPermissionRequests.remove(domain); Since you already have the iterator you could call HashMap::remove(iterator) which is likely faster than HashMap::remove(key). > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:107 > + m_pendingPermissionRequests.remove(domain); Ditto. > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:115 > + LegacyPermissionRequestMap::iterator legacyIter = m_pendingLegacyPermissionRequests.find(String(domain)); String::fromUTF8() ? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:131 > + m_cachedPermissions.add(String(domain), isAllowed); Ditto. > Source/WebKit/efl/ewk/ewk_view.cpp:4517 > + static_cast<WebCore::NotificationPresenterClientEfl*>(WebCore::NotificationController::clientFrom(priv->page.get()))->addPermission(domain, allow); !!allow ? > Source/WebKit/efl/ewk/ewk_view.cpp:4522 > +void ewk_view_notification_permission_request(Evas_Object* ewkView, WTF::String& domain) Looks like domain reference should be const. > Source/WebKit/efl/ewk/ewk_view.cpp:4524 > + char* requestedDomain = strdup(domain.utf8().data()); Instead of using strdup and manage memory yourself I would prefer if you use CString. E.g. CString requestedDomain = domain.utf8(); >> Source/WebKit/efl/ewk/ewk_view.cpp:4526 >> + delete requestedDomain; > > Isn't free() better ? Because, strdup uses malloc. Gyuyoung is right but this becomes useless if you use CString. > Source/WebKit/efl/ewk/ewk_view.cpp:4529 > +void ewk_view_notification_permission_cancel(Evas_Object* ewkView, WTF::String& domain) Looks like domain reference should be const. > Source/WebKit/efl/ewk/ewk_view.cpp:4531 > + char* requestedDomain = strdup(domain.utf8().data()); Instead of using strdup and manage memory yourself I would prefer if you use CString. E.g. CString requestedDomain = domain.utf8(); > Source/WebKit/efl/ewk/ewk_view.h:78 > + * - "notification,permission,request", const char*: request to confirm permission for domain from uesr. "user" > Source/WebKit/efl/ewk/ewk_view.h:2699 > + * Set cache by stored permission list for notification. This sentence is very difficult to understand. > Source/WebKit/efl/ewk/ewk_view.h:2702 > + * @param domain string for determine permission. "domain string used to determine the permission" ? > Source/WebKit/efl/ewk/ewk_view.h:2705 > +EAPI void ewk_view_notification_permissions_set(Evas_Object *o, const char *domain, Eina_Bool allow); Shouldn't this return a boolean like the other Ewk setters? > Source/WebKit/efl/ewk/ewk_view_private.h:160 > +void ewk_view_notification_permission_request(Evas_Object* ewkView, WTF::String& domain); const reference. > Source/WebKit/efl/ewk/ewk_view_private.h:161 > +void ewk_view_notification_permission_cancel(Evas_Object* ewkView, WTF::String& domain); Ditto. 664677 5 151029 kihong.kwon 2012-07-08 23:44:12 -0700 Comment on attachment 151029 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151029&action=review >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:93 >> + String domain = context->url().host(); > > #if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS) ? I don't think so. This file is already wrapped with "#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)". >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:99 >> + m_pendingLegacyPermissionRequests.remove(domain); > > Since you already have the iterator you could call HashMap::remove(iterator) which is likely faster than HashMap::remove(key). You are right. >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:115 >> + LegacyPermissionRequestMap::iterator legacyIter = m_pendingLegacyPermissionRequests.find(String(domain)); > > String::fromUTF8() ? I'm not sure about changing this? Do you have a reason for that? >> Source/WebKit/efl/ewk/ewk_view.cpp:4517 >> + static_cast<WebCore::NotificationPresenterClientEfl*>(WebCore::NotificationController::clientFrom(priv->page.get()))->addPermission(domain, allow); > > !!allow ? It will be changed to allowed. >> Source/WebKit/efl/ewk/ewk_view.cpp:4522 >> +void ewk_view_notification_permission_request(Evas_Object* ewkView, WTF::String& domain) > > Looks like domain reference should be const. OK. >> Source/WebKit/efl/ewk/ewk_view.cpp:4524 >> + char* requestedDomain = strdup(domain.utf8().data()); > > Instead of using strdup and manage memory yourself I would prefer if you use CString. E.g. CString requestedDomain = domain.utf8(); OK, It's better than mine. :) >> Source/WebKit/efl/ewk/ewk_view.cpp:4529 >> +void ewk_view_notification_permission_cancel(Evas_Object* ewkView, WTF::String& domain) > > Looks like domain reference should be const. OK. >> Source/WebKit/efl/ewk/ewk_view.cpp:4531 >> + char* requestedDomain = strdup(domain.utf8().data()); > > Instead of using strdup and manage memory yourself I would prefer if you use CString. E.g. CString requestedDomain = domain.utf8(); ditto. >> Source/WebKit/efl/ewk/ewk_view.h:2699 >> + * Set cache by stored permission list for notification. > > This sentence is very difficult to understand. I will change description. >> Source/WebKit/efl/ewk/ewk_view.h:2702 >> + * @param domain string for determine permission. > > "domain string used to determine the permission" ? Fixed. >> Source/WebKit/efl/ewk/ewk_view.h:2705 >> +EAPI void ewk_view_notification_permissions_set(Evas_Object *o, const char *domain, Eina_Bool allow); > > Shouldn't this return a boolean like the other Ewk setters? Fixed. >> Source/WebKit/efl/ewk/ewk_view_private.h:160 >> +void ewk_view_notification_permission_request(Evas_Object* ewkView, WTF::String& domain); > > const reference. Fixed. >> Source/WebKit/efl/ewk/ewk_view_private.h:161 >> +void ewk_view_notification_permission_cancel(Evas_Object* ewkView, WTF::String& domain); > > Ditto. Fixed. 664698 6 151199 kihong.kwon 2012-07-09 00:33:44 -0700 Created attachment 151199 Patch 665482 7 151199 morrita 2012-07-09 22:20:18 -0700 Comment on attachment 151199 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > + PermissionsMap::iterator iter = m_cachedPermissions.find(context->url().host()); Is it intentional to use host()? For example, is it OK to ignore the port number? It looks WebKit2/mac uses SecurityOrigin for that same purpose. 665621 8 kihong.kwon 2012-07-10 03:25:36 -0700 (In reply to comment #7) > (From update of attachment 151199 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > > + PermissionsMap::iterator iter = m_cachedPermissions.find(context->url().host()); > > Is it intentional to use host()? For example, is it OK to ignore the port number? > It looks WebKit2/mac uses SecurityOrigin for that same purpose. You are right. I think I need to change about that. Thank you. :) 668560 9 151199 kenneth 2012-07-12 20:25:35 -0700 Comment on attachment 151199 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review >>> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 >>> + PermissionsMap::iterator iter = m_cachedPermissions.find(context->url().host()); >> >> Is it intentional to use host()? For example, is it OK to ignore the port number? >> It looks WebKit2/mac uses SecurityOrigin for that same purpose. > > You are right. > I think I need to change about that. > Thank you. :) You could take a look at how we are doing this for Qt (I am not sure the patch was ever landed but one exists in bugzilla). > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:115 > +#if ENABLE(LEGACY_NOTIFICATIONS) > + LegacyPermissionRequestMap::iterator legacyIter = m_pendingLegacyPermissionRequests.find(String(domain)); Why support legacy notifications at all? They should go away no? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:41 > +#if ENABLE(LEGACY_NOTIFICATIONS) I would really let EFL just not support legacy notifications. You are adding much code and it makes it even harder removing the feature later. 669810 10 151199 gyuyoung.kim 2012-07-14 04:51:37 -0700 Comment on attachment 151199 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:34 > + NotificationPresenterClientEfl(Evas_Object* view); Use *explicit* keyword for constructor which has a parameter. >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:41 >> +#if ENABLE(LEGACY_NOTIFICATIONS) > > I would really let EFL just not support legacy notifications. You are adding much code and it makes it even harder removing the feature later. According to my quick search, it looks other ports are supporting LEGACY_NOTIFICATIONS. But, there is no reason to use LEGACY_NOTIFICATIONS on EFL port, I also think we don't need to support it. > Source/WebKit/efl/ewk/ewk_view.cpp:4515 > + EWK_VIEW_SD_GET(ewkView, smartData); Use EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, false) instead of this. > Source/WebKit/efl/ewk/ewk_view.cpp:4516 > + EWK_VIEW_PRIV_GET(smartData, priv); Use EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, false) 670130 11 kihong.kwon 2012-07-15 23:58:04 -0700 (In reply to comment #9) > (From update of attachment 151199 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review > > >>> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > >>> + PermissionsMap::iterator iter = m_cachedPermissions.find(context->url().host()); > >> > >> Is it intentional to use host()? For example, is it OK to ignore the port number? > >> It looks WebKit2/mac uses SecurityOrigin for that same purpose. > > > > You are right. > > I think I need to change about that. > > Thank you. :) > > You could take a look at how we are doing this for Qt (I am not sure the patch was ever landed but one exists in bugzilla). OK. I'll do that, thanks~ :) > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:115 > > +#if ENABLE(LEGACY_NOTIFICATIONS) > > + LegacyPermissionRequestMap::iterator legacyIter = m_pendingLegacyPermissionRequests.find(String(domain)); > > Why support legacy notifications at all? They should go away no? > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:41 > > +#if ENABLE(LEGACY_NOTIFICATIONS) > > I would really let EFL just not support legacy notifications. You are adding much code and it makes it even harder removing the feature later. I agree with you on one hand but almost sites support legacy notification until now on the other. (html5test.com, html5rocks.com...) Actually I haven't seen yet a site support W3C "Web Notifications". In addition, even firefox supports legacy notifications with this link (http://www.chromium.org/developers/design-documents/desktop-notifications/api-specification) That's why I would like to add LEGACY_NOTIFICATIONS. I would like to get your opinion about this. Thank you. :) 670132 12 kihong.kwon 2012-07-16 00:00:38 -0700 (In reply to comment #10) > (From update of attachment 151199 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:34 > > + NotificationPresenterClientEfl(Evas_Object* view); > > Use *explicit* keyword for constructor which has a parameter. OK. > > >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:41 > >> +#if ENABLE(LEGACY_NOTIFICATIONS) > > > > I would really let EFL just not support legacy notifications. You are adding much code and it makes it even harder removing the feature later. > > According to my quick search, it looks other ports are supporting LEGACY_NOTIFICATIONS. But, there is no reason to use LEGACY_NOTIFICATIONS on EFL port, I also think we don't need to support it. I add my answer for this to reply of Kenneth's comments. Please read it and leave comments. > > > Source/WebKit/efl/ewk/ewk_view.cpp:4515 > > + EWK_VIEW_SD_GET(ewkView, smartData); > > Use EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData, false) instead of this. > > > Source/WebKit/efl/ewk/ewk_view.cpp:4516 > > + EWK_VIEW_PRIV_GET(smartData, priv); > > Use EWK_VIEW_PRIV_GET_OR_RETURN(smartData, priv, false) OK, Thanks. 670946 13 151199 kenneth 2012-07-16 20:43:22 -0700 Comment on attachment 151199 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review >>> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:115 >>> + LegacyPermissionRequestMap::iterator legacyIter = m_pendingLegacyPermissionRequests.find(String(domain)); >> >> Why support legacy notifications at all? They should go away no? > > I agree with you on one hand but almost sites support legacy notification until now on the other. (html5test.com, html5rocks.com...) > Actually I haven't seen yet a site support W3C "Web Notifications". > > In addition, even firefox supports legacy notifications with this link (http://www.chromium.org/developers/design-documents/desktop-notifications/api-specification) > > That's why I would like to add LEGACY_NOTIFICATIONS. > > I would like to get your opinion about this. > Thank you. :) I am pretty sure that Safari on Desktop and iOS doesnt support legacy notifications, also I don't think Internet Explorer nor Opera does so. It is a dead fish in the water. They became legacy notifications as other vendors had issues with the old spec. 671852 14 kihong.kwon 2012-07-17 18:26:20 -0700 (In reply to comment #13) > (From update of attachment 151199 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=151199&action=review > > I am pretty sure that Safari on Desktop and iOS doesnt support legacy notifications, also I don't think Internet Explorer nor Opera does so. It is a dead fish in the water. They became legacy notifications as other vendors had issues with the old spec. I accept your opinion. I will update this patch without LEGACY_NOTIFICATIONS. Thank you for your comments~:) 671884 15 152903 kihong.kwon 2012-07-17 19:19:21 -0700 Created attachment 152903 Patch 671916 16 152903 kenneth 2012-07-17 20:03:48 -0700 Comment on attachment 152903 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=152903&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > + PermissionsMap::iterator iter = m_cachedPermissions.find(context->securityOrigin()->toString()); > + > + if (iter == m_cachedPermissions.end()) > + return PermissionNotAllowed; > + > + if (iter->second) > + return PermissionAllowed; > + > return PermissionDenied; > } So this will never reach the last return? What is the difference between Denied and NotAllowed? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 > +void NotificationPresenterClientEfl::addPermissionCache(const char* domain, const bool isAllowed) addTo ? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:89 > + PermissionsMap::iterator iter = m_cachedPermissions.find(String(domain)); > + > + if (iter == m_cachedPermissions.end()) > + return; > + > + m_cachedPermissions.add(String(domain), isAllowed); So you check whehter is is already cached. If it is not you return, thus never cache :-( 671960 17 kihong.kwon 2012-07-17 21:51:58 -0700 (In reply to comment #16) > (From update of attachment 152903 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=152903&action=review > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > > + PermissionsMap::iterator iter = m_cachedPermissions.find(context->securityOrigin()->toString()); > > + > > + if (iter == m_cachedPermissions.end()) > > + return PermissionNotAllowed; > > + > > + if (iter->second) > > + return PermissionAllowed; > > + > > return PermissionDenied; > > } > > So this will never reach the last return? What is the difference between Denied and NotAllowed? Denied means user already select deny when requestPermission has been called. But, NotAllowed means there haven't been requested to the user yet, in this case requestPermission need to be called. Last return statement can be called when iter->second(Permission allowed) is false. > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 > > +void NotificationPresenterClientEfl::addPermissionCache(const char* domain, const bool isAllowed) > > addTo ? OK. I'will change it. > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:89 > > + PermissionsMap::iterator iter = m_cachedPermissions.find(String(domain)); > > + > > + if (iter == m_cachedPermissions.end()) > > + return; > > + > > + m_cachedPermissions.add(String(domain), isAllowed); > > So you check whehter is is already cached. If it is not you return, thus never cache :-( I don't think so, permission cache is added in the requestPermission. If we want to use notification, we need to call requestPermission to get a permission. 675410 18 153724 kihong.kwon 2012-07-22 20:19:42 -0700 Created attachment 153724 Patch 676433 19 153724 gyuyoung.kim 2012-07-23 23:37:12 -0700 Comment on attachment 153724 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=153724&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:89 > + m_cachedPermissions.add(String(domain), isAllowed); Use String::fromUTF8() instead of String(). > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:101 > + m_cachedPermissions.add(String(ewk_security_origin_string_get(origin)), isAllowed); ditto. > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:34 > + NotificationPresenterClientEfl(Evas_Object* view); Missing *explicit* keyword. > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.h:48 > + void addToPermissionCache(const char* domain, bool isAllowed); Use String class in WebCoreSupport layer. > Source/WebKit/efl/ewk/ewk_view.cpp:110 > +#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS) Don't you remove LEGACY_NOTIFICATIONS macro in this patch ? > Source/WebKit/efl/ewk/ewk_view.cpp:773 > +#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS) ditto. > Source/WebKit/efl/ewk/ewk_view.cpp:4520 > + EWK_VIEW_SD_GET(ewkView, smartData); Use EWK_VIEW_SD_GET_OR_RETURN. > Source/WebKit/efl/ewk/ewk_view.cpp:4521 > + EWK_VIEW_PRIV_GET(smartData, priv); ditto. > Source/WebKit/efl/ewk/ewk_view.cpp:4532 > + EWK_VIEW_SD_GET(ewkView, smartData); ditto. > Source/WebKit/efl/ewk/ewk_view.cpp:4533 > + EWK_VIEW_PRIV_GET(smartData, priv); ditto. 676479 20 haraken 2012-07-24 00:52:32 -0700 Just FYI, Notification.permissionLevel() is going to be changed to Notification.permission() (bug 88919) 704919 21 160621 kihong.kwon 2012-08-26 19:42:57 -0700 Created attachment 160621 Patch 705027 22 160621 kenneth 2012-08-27 01:08:17 -0700 Comment on attachment 160621 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=160621&action=review > Source/WebKit/efl/ewk/ewk_view.h:2699 > + * Add permitted or denied list to the permission cache for Web Notificaitons. spelling mistakes > Source/WebKit/efl/ewk/ewk_view.h:2710 > +Eina_Bool ewk_view_notification_permission_cache_add(Evas_Object *o, const char *domain, Eina_Bool permitted); I think cache is a pretty overloaded name... What about "store". Will there be different permission stores? like for geolocation, notifications etc? 705032 23 160621 mikhail.pozdnyakov 2012-08-27 01:22:55 -0700 Comment on attachment 160621 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=160621&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:33 > + : m_view(view) Check for null? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:64 > + Ewk_Security_Origin* origin = ewk_security_origin_new(context->securityOrigin()); shouldn't we check args for null here before usage? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > +void NotificationPresenterClientEfl::addToPermissionCache(const String domain, const bool isAllowed) const String& domain > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:84 > + return; if (iter != m_cachedPermissions.end()) m_cachedPermissions.add(domain, isAllowed); > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:90 > + PermissionRequestMap::iterator iter = m_pendingPermissionRequests.find(const_cast<Ewk_Security_Origin*>(origin)); maybe typedef HashMap<const Ewk_Security_Origin*, RefPtr<WebCore::NotificationPermissionCallback> > PermissionRequestMap; so that you do not need const_cast? 705033 24 160621 gyuyoung.kim 2012-08-27 01:23:58 -0700 Comment on attachment 160621 Patch We started to add unit test for public API as well. Please add unit test. 705974 25 160621 gyuyoung.kim 2012-08-27 18:40:06 -0700 Comment on attachment 160621 Patch Set r- because of many comments. 711743 26 cdumez 2012-09-04 23:00:57 -0700 Any update on this? 711751 27 kihong.kwon 2012-09-04 23:25:44 -0700 (In reply to comment #26) > Any update on this? I will update this soon. :) 711952 28 kihong.kwon 2012-09-05 04:49:21 -0700 (In reply to comment #22) > (From update of attachment 160621 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=160621&action=review > > > Source/WebKit/efl/ewk/ewk_view.h:2699 > > + * Add permitted or denied list to the permission cache for Web Notificaitons. > > spelling mistakes > > > Source/WebKit/efl/ewk/ewk_view.h:2710 > > +Eina_Bool ewk_view_notification_permission_cache_add(Evas_Object *o, const char *domain, Eina_Bool permitted); > > I think cache is a pretty overloaded name... What about "store". Will there be different permission stores? like for geolocation, notifications etc? I'll change it like your recommendation. Thanks. :) 712784 29 kihong.kwon 2012-09-05 19:14:55 -0700 (In reply to comment #23) > (From update of attachment 160621 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=160621&action=review > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:33 > > + : m_view(view) > > Check for null? OK. > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:64 > > + Ewk_Security_Origin* origin = ewk_security_origin_new(context->securityOrigin()); > > shouldn't we check args for null here before usage? Not exactly. context is already checked in the Notification::requestPermission. Therefore we don't need check it here. > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:80 > > +void NotificationPresenterClientEfl::addToPermissionCache(const String domain, const bool isAllowed) > > const String& domain You are right. > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:84 > > + return; > > if (iter != m_cachedPermissions.end()) > m_cachedPermissions.add(domain, isAllowed); > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:90 > > + PermissionRequestMap::iterator iter = m_pendingPermissionRequests.find(const_cast<Ewk_Security_Origin*>(origin)); > > maybe typedef HashMap<const Ewk_Security_Origin*, RefPtr<WebCore::NotificationPermissionCallback> > PermissionRequestMap; so that you do not need const_cast? OK. It's better. 712785 30 kihong.kwon 2012-09-05 19:17:05 -0700 (In reply to comment #24) > (From update of attachment 160621 [details]) > We started to add unit test for public API as well. Please add unit test. I knew that. We need many test cases for the Web notification. Therefore I'll add test cases after adding all APIs about Web Notification. 712788 31 gyuyoung.kim 2012-09-05 19:20:06 -0700 (In reply to comment #30) > (In reply to comment #24) > > (From update of attachment 160621 [details] [details]) > > We started to add unit test for public API as well. Please add unit test. > I knew that. We need many test cases for the Web notification. > Therefore I'll add test cases after adding all APIs about Web Notification. If possible, I would like to recommend to add unit test together. But, if you don't want to add unit test together with this patch. Please file a bug and link this bug. 712814 32 162401 kihong.kwon 2012-09-05 20:18:58 -0700 Created attachment 162401 Patch 712819 33 162401 gyuyoung.kim 2012-09-05 20:26:49 -0700 Comment on attachment 162401 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162401&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 > +void NotificationPresenterClientEfl::addToPermissionCache(const String& domain, const bool isAllowed) As parameter name, *allowed* is more used. 712825 34 kihong.kwon 2012-09-05 20:34:47 -0700 (In reply to comment #33) > (From update of attachment 162401 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=162401&action=review > > > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 > > +void NotificationPresenterClientEfl::addToPermissionCache(const String& domain, const bool isAllowed) > > As parameter name, *allowed* is more used. OK. 712858 35 162411 kihong.kwon 2012-09-05 21:47:09 -0700 Created attachment 162411 Patch 713044 36 162411 gyuyoung.kim 2012-09-06 02:03:32 -0700 Comment on attachment 162411 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162411&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:87 > + m_cachedPermissions.add(domain, isAllowed); isAllowed -> allowed ? > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:96 > + iter->second->handleEvent(Notification::permissionString(isAllowed ? NotificationClient::PermissionAllowed : NotificationClient::PermissionDenied)); ditto. > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:98 > + m_cachedPermissions.add(String::fromUTF8(ewk_security_origin_string_get(origin)), isAllowed); ditto. 713045 37 162411 gyuyoung.kim 2012-09-06 02:04:17 -0700 Comment on attachment 162411 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162411&action=review > Source/WebKit/efl/ewk/ewk_view.h:2771 > + * @param allow @c EINA_TRUE to permit, @c EINA_FALSE to deny. allow -> permitted ? 713147 38 162471 kihong.kwon 2012-09-06 03:59:14 -0700 Created attachment 162471 Patch 713242 39 162471 kenneth 2012-09-06 06:33:27 -0700 Comment on attachment 162471 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162471&action=review > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:73 > + PermissionsMap::iterator iter = m_cachedPermissions.find(context->securityOrigin()->toString()); We normally use 'it' > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 > +void NotificationPresenterClientEfl::addToPermissionCache(const String& domain, const bool permitted) isPermitted > Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:87 > + PermissionsMap::iterator iter = m_cachedPermissions.find(domain); > + if (iter == m_cachedPermissions.end()) > + return; > + m_cachedPermissions.add(domain, permitted); That cannot be right, it never gets added 713276 40 162471 kihong.kwon 2012-09-06 07:37:53 -0700 Comment on attachment 162471 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162471&action=review >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:73 >> + PermissionsMap::iterator iter = m_cachedPermissions.find(context->securityOrigin()->toString()); > > We normally use 'it' OK. I will change all iter to it. >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 >> +void NotificationPresenterClientEfl::addToPermissionCache(const String& domain, const bool permitted) > > isPermitted gyuyoung how do you think about this? I accepted gyuyoung's opinion about this. isPermitted? or permitted? :-) >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:87 >> + m_cachedPermissions.add(domain, permitted); > > That cannot be right, it never gets added You are right. I need to change this to (iter != m_cachedPermissions.end()). 713945 41 gyuyoung.kim 2012-09-06 18:06:25 -0700 (In reply to comment #40) > >> Source/WebKit/efl/WebCoreSupport/NotificationPresenterClientEfl.cpp:82 > >> +void NotificationPresenterClientEfl::addToPermissionCache(const String& domain, const bool permitted) > > > > isPermitted I think that *isPermitted* is better than *permitted* for internal function according to WebKit coding style. 714041 42 162660 kihong.kwon 2012-09-06 20:07:16 -0700 Created attachment 162660 Patch 714241 43 162660 webkit.review.bot 2012-09-07 00:55:44 -0700 Comment on attachment 162660 Patch Clearing flags on attachment: 162660 Committed r127839: <http://trac.webkit.org/changeset/127839> 714243 44 webkit.review.bot 2012-09-07 00:55:51 -0700 All reviewed patches have been landed. Closing bug. 714245 45 162660 kenneth 2012-09-07 00:57:55 -0700 Comment on attachment 162660 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162660&action=review removing cq- for now > Source/WebKit/efl/ewk/ewk_view.h:2762 > +Eina_Bool ewk_view_notification_permission_store(Evas_Object *o, const char *domain, Eina_Bool permitted); Shouldn't this be permission_store_add? Like the add is missing? > Source/WebKit/efl/ewk/ewk_view.h:2775 > +EAPI Eina_Bool ewk_view_notification_permissions_set(Evas_Object *o, const Ewk_Security_Origin *origin, Eina_Bool permitted); I dont get the different between this one and the above API function. 714307 46 162660 kenneth 2012-09-07 02:10:58 -0700 Comment on attachment 162660 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=162660&action=review > Source/WebKit/efl/ewk/ewk_view.h:2765 > + * Set permitted or denied lists to the permission cache for the Web Notifications. This comment seems wrong Accept or deny a permission request. ewk_viewport_notification_permission_request_set ? 714333 47 gyuyoung.kim 2012-09-07 02:59:42 -0700 Reverted r127839 for reason: r127839 Committed r127848: <http://trac.webkit.org/changeset/127848> 1286252 48 mcatanzaro 2017-03-11 10:34:43 -0800 Closing this bug because the EFL port has been removed from trunk. If you feel this bug applies to a different upstream WebKit port and was closed in error, please either update the title and reopen the bug, or leave a comment to request this. 151029 2012-07-06 01:04:50 -0700 2012-07-09 00:33:33 -0700 Patch bug-90603-20120706170448.patch text/plain 12446 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxOTQ3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggYjgwMzIzYmQ2 OTY3MTFjZDY3OGZlZWE4ZTc5YWFiMmNlOTEwM2ZkMi4uZWY0MmFiZGRkYjJjNTg0YjAwNDBjNjBj ZmNmM2Q3NGNiYjk5OTJjMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEy LTA3LTA2ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z KGJvdGggTk9USUZJQ0FUSU9OIGFuZCBMRUdBQ1lfTk9USUZJQ0FUSU9OKS4KKyAgICAgICAgU3Rv cmVkIHBlcm1pc3Npb25zIGluIHRoZSBvdXRzaWRlIGFwcGxpY2F0aW9uKGxpa2UgYSBicm93c2Vy KSBjYW4gYmUgY2FjaGVkIGJ5IGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQu CisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRF ZmwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZs OjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQ ZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbDo6Y2hlY2tQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKToKKyAgICAgICAg KFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6YWRkUGVybWlzc2lvbik6 CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZs Lmg6CisgICAgICAgIChOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwpOgorICAgICAgICAq IGV3ay9ld2tfdmlldy5jcHA6CisgICAgICAgIChfZXdrX3ZpZXdfcHJpdl9uZXcpOgorICAgICAg ICAoZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zX3NldCk6CisgICAgICAgIChld2tf dmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KToKKyAgICAgICAgKGV3a192aWV3 X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX2NhbmNlbCk6CisgICAgICAgICogZXdrL2V3a192aWV3 Lmg6CisgICAgICAgICogZXdrL2V3a192aWV3X3ByaXZhdGUuaDoKKwogMjAxMi0wNy0wNiAgU2Vv a2p1IEt3b24gIDxzZW9ranUua3dvbkBzYW1zdW5nLmNvbT4KIAogICAgICAgICBbRUZMXSBBZGQg V2ViIEluc3BlY3RvciB0byBXZWJLaXQtRUZMCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwIGIvU291 cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsLmNwcAppbmRleCBjNGU1Y2E4ZGE0OGE3MWFjYTI0N2U4ODMzMTY0YzBjYmI5N2M0ZDVkLi4y YzhjMWJhZjFlN2VhZTJjOTk1NjkzMGRhYTU2ZDk1NTJiZjBhYjU2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRF ZmwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbC5jcHAKQEAgLTIyLDEwICsyMiwxMyBAQAogCiAjaWYgRU5BQkxF KE5PVElGSUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKICNpbmNsdWRl ICJOb3RJbXBsZW1lbnRlZC5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIK KyNpbmNsdWRlICJld2tfdmlld19wcml2YXRlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAot Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwoKQorTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpOb3RpZmljYXRpb25QcmVz ZW50ZXJDbGllbnRFZmwoRXZhc19PYmplY3QqIHZpZXcpCisgICAgOiBtX3ZpZXcodmlldykKIHsK IH0KIApAQCAtNTQsMjAgKzU3LDc4IEBAIHZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsOjpub3RpZmljYXRpb25Db250cm9sbGVyRGVzdHJveWVkKCkKICAgICBub3RJbXBsZW1lbnRl ZCgpOwogfQogCisjaWYgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQogdm9pZCBOb3RpZmlj YXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8Vm9pZENhbGxiYWNrPiBjYWxsYmFjaykKIHsK LSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFN0cmluZyBkb21haW4gPSBjb250ZXh0LT51cmwo KS5ob3N0KCk7CisgICAgbV9wZW5kaW5nTGVnYWN5UGVybWlzc2lvblJlcXVlc3RzLmFkZChkb21h aW4sIGNhbGxiYWNrKTsKKyAgICBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1 ZXN0KG1fdmlldywgZG9tYWluKTsKK30KKyNlbmRpZgorCisjaWYgRU5BQkxFKE5PVElGSUNBVElP TlMpCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Np b24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxOb3RpZmljYXRp b25QZXJtaXNzaW9uQ2FsbGJhY2s+IGNhbGxiYWNrKQoreworICAgIFN0cmluZyBkb21haW4gPSBj b250ZXh0LT51cmwoKS5ob3N0KCk7CisgICAgbV9wZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLmFk ZChkb21haW4sIGNhbGxiYWNrKTsKKyAgICBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lv bl9yZXF1ZXN0KG1fdmlldywgZG9tYWluKTsKIH0KKyNlbmRpZgogCiBOb3RpZmljYXRpb25DbGll bnQ6OlBlcm1pc3Npb24gTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpjaGVja1Blcm1p c3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKIHsKLSAgICBub3RJbXBsZW1l bnRlZCgpOworICAgIFBlcm1pc3Npb25zTWFwOjppdGVyYXRvciBpdGVyID0gbV9jYWNoZWRQZXJt aXNzaW9ucy5maW5kKGNvbnRleHQtPnVybCgpLmhvc3QoKSk7CisKKyAgICBpZiAoaXRlciA9PSBt X2NhY2hlZFBlcm1pc3Npb25zLmVuZCgpKQorICAgICAgICByZXR1cm4gUGVybWlzc2lvbk5vdEFs bG93ZWQ7CisKKyAgICBpZiAoaXRlci0+c2Vjb25kKQorICAgICAgICByZXR1cm4gUGVybWlzc2lv bkFsbG93ZWQ7CisKICAgICByZXR1cm4gUGVybWlzc2lvbkRlbmllZDsKIH0KIAogdm9pZCBOb3Rp ZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNhbmNlbFJlcXVlc3RzRm9yUGVybWlzc2lvbihT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG5vdEltcGxlbWVudGVkKCk7 CisgICAgU3RyaW5nIGRvbWFpbiA9IGNvbnRleHQtPnVybCgpLmhvc3QoKTsKKworI2lmIEVOQUJM RShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyAgICBMZWdhY3lQZXJtaXNzaW9uUmVxdWVzdE1hcDo6 aXRlcmF0b3IgbGVnYWN5SXRlciA9IG1fcGVuZGluZ0xlZ2FjeVBlcm1pc3Npb25SZXF1ZXN0cy5m aW5kKGRvbWFpbik7CisgICAgaWYgKGxlZ2FjeUl0ZXIgIT0gbV9wZW5kaW5nTGVnYWN5UGVybWlz c2lvblJlcXVlc3RzLmVuZCgpKSB7CisgICAgICAgIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJt aXNzaW9uX2NhbmNlbChtX3ZpZXcsIGRvbWFpbik7CisgICAgICAgIG1fcGVuZGluZ0xlZ2FjeVBl cm1pc3Npb25SZXF1ZXN0cy5yZW1vdmUoZG9tYWluKTsKKyAgICB9CisjZW5kaWYKKworI2lmIEVO QUJMRShOT1RJRklDQVRJT05TKQorICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwOjppdGVyYXRvciBp dGVyID0gbV9wZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLmZpbmQoZG9tYWluKTsKKyAgICBpZiAo aXRlciAhPSBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpIHsKKyAgICAgICAgZXdr X3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FuY2VsKG1fdmlldywgZG9tYWluKTsKKyAg ICAgICAgbV9wZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLnJlbW92ZShkb21haW4pOworICAgIH0K KyNlbmRpZgorfQorCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6YWRkUGVy bWlzc2lvbihjb25zdCBjaGFyKiBkb21haW4sIGNvbnN0IGJvb2wgaXNBbGxvd2VkKQoreworI2lm IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyAgICBMZWdhY3lQZXJtaXNzaW9uUmVxdWVz dE1hcDo6aXRlcmF0b3IgbGVnYWN5SXRlciA9IG1fcGVuZGluZ0xlZ2FjeVBlcm1pc3Npb25SZXF1 ZXN0cy5maW5kKFN0cmluZyhkb21haW4pKTsKKyAgICBpZiAobGVnYWN5SXRlciAhPSBtX3BlbmRp bmdMZWdhY3lQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpIHsKKyAgICAgICAgaWYgKGlzQWxsb3dl ZCkKKyAgICAgICAgICAgIGxlZ2FjeUl0ZXItPnNlY29uZC0+aGFuZGxlRXZlbnQoKTsKKyAgICAg ICAgbV9wZW5kaW5nTGVnYWN5UGVybWlzc2lvblJlcXVlc3RzLnJlbW92ZShsZWdhY3lJdGVyKTsK KyAgICB9CisjZW5kaWYKKworI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQorICAgIFBlcm1pc3Np b25SZXF1ZXN0TWFwOjppdGVyYXRvciBpdGVyID0gbV9wZW5kaW5nUGVybWlzc2lvblJlcXVlc3Rz LmZpbmQoU3RyaW5nKGRvbWFpbikpOworICAgIGlmIChpdGVyICE9IG1fcGVuZGluZ1Blcm1pc3Np b25SZXF1ZXN0cy5lbmQoKSkgeworICAgICAgICBpdGVyLT5zZWNvbmQtPmhhbmRsZUV2ZW50KE5v dGlmaWNhdGlvbjo6cGVybWlzc2lvblN0cmluZyhpc0FsbG93ZWQgPyBOb3RpZmljYXRpb25DbGll bnQ6OlBlcm1pc3Npb25BbGxvd2VkIDogTm90aWZpY2F0aW9uQ2xpZW50OjpQZXJtaXNzaW9uRGVu aWVkKSk7CisgICAgICAgIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0cy5yZW1vdmUoaXRlcik7 CisgICAgfQorI2VuZGlmCisKKyAgICBtX2NhY2hlZFBlcm1pc3Npb25zLmFkZChTdHJpbmcoZG9t YWluKSwgaXNBbGxvd2VkKTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwv V2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmggYi9Tb3VyY2Uv V2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwu aAppbmRleCBlY2U1Y2NmZTRiNjVkMTM1YTgxOGJkOTlmMTI0NTk1ZTAwYTJiZmUxLi41NDkyNzE3 NTljYjI4NjI3YmEyOTQ4OTc4OTQxOWFhY2RjNzRmY2FkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaAor KysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50 ZXJDbGllbnRFZmwuaApAQCAtMjMsMjIgKzIzLDQ1IEBACiAjaWYgRU5BQkxFKE5PVElGSUNBVElP TlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKICNpbmNsdWRlICJOb3RpZmljYXRp b24uaCIKICNpbmNsdWRlICJOb3RpZmljYXRpb25DbGllbnQuaCIKKyNpbmNsdWRlIDxFdmFzLmg+ CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFz cyBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwgOiBwdWJsaWMgTm90aWZpY2F0aW9uQ2xp ZW50IHsKIAogcHVibGljOgotICAgIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCgpOwor ICAgIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbChFdmFzX09iamVjdCogdmlldyk7CiAg ICAgfk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCgpOwogCiAgICAgdmlydHVhbCBib29s IHNob3coTm90aWZpY2F0aW9uKik7CiAgICAgdmlydHVhbCB2b2lkIGNhbmNlbChOb3RpZmljYXRp b24qKTsKICAgICB2aXJ0dWFsIHZvaWQgbm90aWZpY2F0aW9uT2JqZWN0RGVzdHJveWVkKE5vdGlm aWNhdGlvbiopOwogICAgIHZpcnR1YWwgdm9pZCBub3RpZmljYXRpb25Db250cm9sbGVyRGVzdHJv eWVkKCk7CisjaWYgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQogICAgIHZpcnR1YWwgdm9p ZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxW b2lkQ2FsbGJhY2s+KTsKKyNlbmRpZgorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQorICAgIHZp cnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c1JlZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+KTsKKyNlbmRpZgogICAgIHZp cnR1YWwgTm90aWZpY2F0aW9uQ2xpZW50OjpQZXJtaXNzaW9uIGNoZWNrUGVybWlzc2lvbihTY3Jp cHRFeGVjdXRpb25Db250ZXh0Kik7CiAgICAgdmlydHVhbCB2b2lkIGNhbmNlbFJlcXVlc3RzRm9y UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0Kik7CisKKyAgICB2b2lkIGFkZFBlcm1p c3Npb24oY29uc3QgY2hhciogZG9tYWluLCBib29sIGlzQWxsb3dlZCk7CisKK3ByaXZhdGU6Cisg ICAgRXZhc19PYmplY3QqIG1fdmlldzsKKworI2lmIEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9O UykKKyAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8V2ViQ29yZTo6Vm9pZENhbGxi YWNrPiA+IExlZ2FjeVBlcm1pc3Npb25SZXF1ZXN0TWFwOworICAgIExlZ2FjeVBlcm1pc3Npb25S ZXF1ZXN0TWFwIG1fcGVuZGluZ0xlZ2FjeVBlcm1pc3Npb25SZXF1ZXN0czsKKyNlbmRpZgorI2lm IEVOQUJMRShOT1RJRklDQVRJT05TKQorICAgIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIFJlZlB0 cjxXZWJDb3JlOjpOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+ID4gUGVybWlzc2lvblJl cXVlc3RNYXA7CisgICAgUGVybWlzc2lvblJlcXVlc3RNYXAgbV9wZW5kaW5nUGVybWlzc2lvblJl cXVlc3RzOworI2VuZGlmCisgICAgdHlwZWRlZiBIYXNoTWFwPFN0cmluZywgYm9vbD4gUGVybWlz c2lvbnNNYXA7CisgICAgUGVybWlzc2lvbnNNYXAgbV9jYWNoZWRQZXJtaXNzaW9uczsKIH07CiAK IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwCmluZGV4IGE5ODc2OWEzZjhlMTgyMjVhN2Q5 NzVkOTJlOTFlYmZkZTc5M2FiMTguLjAyMzYzNWE2OTFmZmYzYTJmYTE5MGMyOGE3NzFlNDdkYTZi Njk5ODIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKKysr IGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcApAQCAtMTAzLDYgKzEwMywxMSBA QAogI2luY2x1ZGUgIkNvbG9yQ2hvb3NlckNsaWVudC5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUo Tk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQorI2luY2x1ZGUg Ik5vdGlmaWNhdGlvbkNvbnRyb2xsZXIuaCIKKyNpbmNsdWRlICJOb3RpZmljYXRpb25QcmVzZW50 ZXJDbGllbnRFZmwuaCIKKyNlbmRpZgorCiBzdGF0aWMgY29uc3QgZmxvYXQgem9vbU1pbmltdW0g PSAwLjA1Owogc3RhdGljIGNvbnN0IGZsb2F0IHpvb21NYXhpbXVtID0gNC4wOwogCkBAIC03NTcs NiArNzYyLDEwIEBAIHN0YXRpYyBFd2tfVmlld19Qcml2YXRlX0RhdGEqIF9ld2tfdmlld19wcml2 X25ldyhFd2tfVmlld19TbWFydF9EYXRhKiBzbWFydERhdGEpCiAgICAgV2ViQ29yZTo6cHJvdmlk ZUJhdHRlcnlUbyhwcml2LT5wYWdlLmdldCgpLCBuZXcgV2ViQ29yZTo6QmF0dGVyeUNsaWVudEVm bCk7CiAjZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKSB8fCBFTkFCTEUoTEVHQUNZ X05PVElGSUNBVElPTlMpCisgICAgV2ViQ29yZTo6cHJvdmlkZU5vdGlmaWNhdGlvbihwcml2LT5w YWdlLmdldCgpLCBuZXcgV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKHNt YXJ0RGF0YS0+c2VsZikpOworI2VuZGlmCisKICAgICBwcml2LT5wYWdlU2V0dGluZ3MgPSBwcml2 LT5wYWdlLT5zZXR0aW5ncygpOwogCiAgICAgcHJpdi0+dmlld3BvcnRBcmd1bWVudHMud2lkdGgg PSBXZWJDb3JlOjpWaWV3cG9ydEFyZ3VtZW50czo6VmFsdWVBdXRvOwpAQCAtNDUwMCw2ICs0NTA5 LDMxIEBAIHZvaWQgZXdrX3ZpZXdfY3Vyc29yX3NldChFdmFzX09iamVjdCogZXdrVmlldywgY29u c3QgV2ViQ29yZTo6Q3Vyc29yJiBjdXJzb3IpCiAgICAgfQogfQogCit2b2lkIGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IGNo YXIqIGRvbWFpbiwgRWluYV9Cb29sIGFsbG93KQoreworI2lmIEVOQUJMRShOT1RJRklDQVRJT05T KSB8fCBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdfU0RfR0VUKGV3 a1ZpZXcsIHNtYXJ0RGF0YSk7CisgICAgRVdLX1ZJRVdfUFJJVl9HRVQoc21hcnREYXRhLCBwcml2 KTsKKyAgICBzdGF0aWNfY2FzdDxXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRF ZmwqPihXZWJDb3JlOjpOb3RpZmljYXRpb25Db250cm9sbGVyOjpjbGllbnRGcm9tKHByaXYtPnBh Z2UuZ2V0KCkpKS0+YWRkUGVybWlzc2lvbihkb21haW4sIGFsbG93KTsKKyNlbmRpZgorfQorCisj aWYgRU5BQkxFKE5PVElGSUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykK K3ZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fcmVxdWVzdChFdmFzX09iamVj dCogZXdrVmlldywgV1RGOjpTdHJpbmcmIGRvbWFpbikKK3sKKyAgICBjaGFyKiByZXF1ZXN0ZWRE b21haW4gPSBzdHJkdXAoZG9tYWluLnV0ZjgoKS5kYXRhKCkpOworICAgIGV2YXNfb2JqZWN0X3Nt YXJ0X2NhbGxiYWNrX2NhbGwoZXdrVmlldywgIm5vdGlmaWNhdGlvbixwZXJtaXNzaW9uLHJlcXVl c3QiLCByZXF1ZXN0ZWREb21haW4pOworICAgIGRlbGV0ZSByZXF1ZXN0ZWREb21haW47Cit9CisK K3ZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FuY2VsKEV2YXNfT2JqZWN0 KiBld2tWaWV3LCBXVEY6OlN0cmluZyYgZG9tYWluKQoreworICAgIGNoYXIqIHJlcXVlc3RlZERv bWFpbiA9IHN0cmR1cChkb21haW4udXRmOCgpLmRhdGEoKSk7CisgICAgZXZhc19vYmplY3Rfc21h cnRfY2FsbGJhY2tfY2FsbChld2tWaWV3LCAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24sY2FuY2Vs IiwgcmVxdWVzdGVkRG9tYWluKTsKKyAgICBkZWxldGUgcmVxdWVzdGVkRG9tYWluOworfQorI2Vu ZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRlIHsKIAogV2ViQ29yZTo6UGFnZSogY29yZVBhZ2Uo Y29uc3QgRXZhc19PYmplY3QqIGV3a1ZpZXcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9ld2svZXdrX3ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCmluZGV4 IGQ1ZmViMzZiMzM5OWM3ZTRjYWFmYTUwNmNmNmUzMjdiZDdkNGRhYjkuLjVjNTBhN2ZlOTI0YmQ2 MTM5ZmYzZWYxOGY0OGYzZDk0NGYwM2FiMzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZs L2V3ay9ld2tfdmlldy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCkBA IC03NCw2ICs3NCw4IEBACiAgKiAgLSAibWl4ZWRjb250ZW50LGRpc3BsYXllZCIsIHZvaWQ6IGFu eSBvZiB0aGUgY29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgZGlzcGxheWVkIG1peGVk IGNvbnRlbnQuCiAgKiAgLSAibWl4ZWRjb250ZW50LHJ1biIsIHZvaWQ6IGFueSBvZiB0aGUgY29u dGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgcnVuIG1peGVkIGNvbnRlbnQuCiAgKiAgLSAi bmF2aWdhdGUsd2l0aCxkYXRhIiwgRXdrX1ZpZXdfTmF2aWdhdGlvbl9EYXRhKjogcmVwb3J0cyB0 aGF0IHZpZXcgZGlkIG5hdmlnYXRpb24gYW5kIGdpdmVzIHRoZSBuYXZpZ2F0aW9uIGRldGFpbHMu CisgKiAgLSAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24sY2FuY2VsIiwgY29uc3QgY2hhcio6IHJl cXVlc3QgdG8gY2FuY2VsIHBlcm1pc3Npb24gcmVxdWVzdGluZyBmb3IgZG9tYWluLgorICogIC0g Im5vdGlmaWNhdGlvbixwZXJtaXNzaW9uLHJlcXVlc3QiLCBjb25zdCBjaGFyKjogcmVxdWVzdCB0 byBjb25maXJtIHBlcm1pc3Npb24gZm9yIGRvbWFpbiBmcm9tIHVlc3IuCiAgKiAgLSAicGVyZm9y bSxjbGllbnQscmVkaXJlY3QiLCBFd2tfVmlld19SZWRpcmVjdGlvbl9EYXRhKjogcmVwb3J0cyB0 aGF0IHZpZXcgcGVyZm9ybWVkIGEgY2xpZW50IHJlZGlyZWN0IGFuZCBnaXZlcyB0aGUgcmVkaXJl Y3Rpb24gZGV0YWlscy4KICAqICAtICJwZXJmb3JtLHNlcnZlcixyZWRpcmVjdCIsIEV3a19WaWV3 X1JlZGlyZWN0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBwZXJmb3JtZWQgYSBzZXJ2ZXIg cmVkaXJlY3QgYW5kIGdpdmVzIHRoZSByZWRpcmVjdGlvbiBkZXRhaWxzLgogICogIC0gInByb3Rv Y29saGFuZGxlcixyZWdpc3RyYXRpb24scmVxdWVzdGVkIiwgRXdrX0N1c3RvbV9IYW5kbGVyX0Rh dGE6IGFkZCBhIGhhbmRsZXIgdXJsIGZvciB0aGUgZ2l2ZW4gcHJvdG9jb2wuCkBAIC0yNjkzLDYg KzI2OTUsMTUgQEAgRUFQSSBFdmFzX09iamVjdCogZXdrX3ZpZXdfd2ViX2luc3BlY3Rvcl92aWV3 X2dldChjb25zdCBFdmFzX09iamVjdCAqbyk7CiAgKi8KIEVBUEkgdm9pZCBld2tfdmlld193ZWJf aW5zcGVjdG9yX3ZpZXdfc2V0KEV2YXNfT2JqZWN0ICpvLCBFdmFzX09iamVjdCAqaW5zcGVjdG9y X3ZpZXcpOwogCisvKioKKyAqIFNldCBjYWNoZSBieSBzdG9yZWQgcGVybWlzc2lvbiBsaXN0IGZv ciBub3RpZmljYXRpb24uCisgKgorICogQHBhcmFtIG8gdmlldyBvYmplY3QgdG8gc2V0IHRoZSBw ZXJtaXNzaW9uIGNhY2hlIGxpc3QuCisgKiBAcGFyYW0gZG9tYWluIHN0cmluZyBmb3IgZGV0ZXJt aW5lIHBlcm1pc3Npb24uCisgKiBAcGFyYW0gYWxsb3cgQGMgRUlOQV9UUlVFIHRvIHBlcm1pdCwg QGMgRUlOQV9GQUxTRSB0byBkZW55LgorICovCitFQVBJIHZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25zX3NldChFdmFzX09iamVjdCAqbywgY29uc3QgY2hhciAqZG9tYWluLCBF aW5hX0Jvb2wgYWxsb3cpOworCiAjaWZkZWYgX19jcGx1c3BsdXMKIH0KICNlbmRpZgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaCBiL1NvdXJjZS9X ZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgKaW5kZXggYjcwZTc1NWIxNjA5M2E1M2Nl NmNkMzc4ZTM2M2RjNjkyM2RmMWQ4OS4uNzQ0NzkwMzJiMGMxNWEwYWU3ZmExZDA5NTM3ZDNlNjYy NzA2YmVhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZh dGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5oCkBAIC0x NTYsNiArMTU2LDExIEBAIGJvb2wgZXdrX3ZpZXdfYWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfb2Jq ZWN0X2NyZWF0ZShFdmFzX09iamVjdCogZXdrVmlldywgRXZhc19OCiBXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHQzRCogZXdrX3ZpZXdfYWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfY29udGV4dF9nZXQo RXZhc19PYmplY3QqIGV3a1ZpZXcpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9O UykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQordm9pZCBld2tfdmlld19ub3RpZmlj YXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNfT2JqZWN0KiBld2tWaWV3LCBXVEY6OlN0cmlu ZyYgZG9tYWluKTsKK3ZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FuY2Vs KEV2YXNfT2JqZWN0KiBld2tWaWV3LCBXVEY6OlN0cmluZyYgZG9tYWluKTsKKyNlbmRpZgorCiBu YW1lc3BhY2UgRVdLUHJpdmF0ZSB7CiBXZWJDb3JlOjpQYWdlICpjb3JlUGFnZShjb25zdCBFdmFz X09iamVjdCAqZXdrVmlldyk7CiBQbGF0Zm9ybVBhZ2VDbGllbnQgY29yZVBhZ2VDbGllbnQoRXZh c19PYmplY3QqIGV3a1ZpZXcpOwo= 151199 2012-07-09 00:33:44 -0700 2012-07-17 19:19:09 -0700 Patch bug-90603-20120709163342.patch text/plain 12656 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTIyMDg4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggNzU1Zjc5Yjdl YTZmNTA5NTM2MzRiZjU5MTkzMDlkN2Q1NWFjYTVlNS4uNTQ2YjI3MzA3ZTIwZjQ4NDQyMGU4YzIx NjBiNGZlMzNiZjQyODVhNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEy LTA3LTA4ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z KGJvdGggTk9USUZJQ0FUSU9OIGFuZCBMRUdBQ1lfTk9USUZJQ0FUSU9OKS4KKyAgICAgICAgU3Rv cmVkIHBlcm1pc3Npb25zIGluIHRoZSBvdXRzaWRlIGFwcGxpY2F0aW9uKGxpa2UgYSBicm93c2Vy KSBjYW4gYmUgY2FjaGVkIHVzaW5nIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19z ZXQuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwpOgorICAgICAgICAoV2ViQ29yZSk6 CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVl c3RQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbDo6Y2hlY2tQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKToKKyAgICAg ICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6YWRkUGVybWlzc2lv bik6CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsLmg6CisgICAgICAgIChOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwpOgorICAgICAg ICAqIGV3ay9ld2tfdmlldy5jcHA6CisgICAgICAgIChfZXdrX3ZpZXdfcHJpdl9uZXcpOgorICAg ICAgICAoZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zX3NldCk6CisgICAgICAgIChl d2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KToKKyAgICAgICAgKGV3a192 aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX2NhbmNlbCk6CisgICAgICAgICogZXdrL2V3a192 aWV3Lmg6CisgICAgICAgICogZXdrL2V3a192aWV3X3ByaXZhdGUuaDoKKwogMjAxMi0wNy0wOCAg Q2hyaXN0b3BoZSBEdW1leiAgPGNocmlzdG9waGUuZHVtZXpAaW50ZWwuY29tPgogCiAgICAgICAg IFtFRkxdIFJFR1JFU1NJT04gKHIxMjIwMzUpOiBmdWxsc2NyZWVuL2V4aXQtZnVsbC1zY3JlZW4t aWZyYW1lLmh0bWwgaXMgY3Jhc2hpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dl YkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHAgYi9Tb3VyY2Uv V2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwu Y3BwCmluZGV4IGM0ZTVjYThkYTQ4YTcxYWNhMjQ3ZTg4MzMxNjRjMGNiYjk3YzRkNWQuLjRhZjFi ZGZiMWRhMzc4NzI3MzNmMTI2OWE3ZTM1ZDMzNjQ2OTUyZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5j cHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJl c2VudGVyQ2xpZW50RWZsLmNwcApAQCAtMjIsMTAgKzIyLDEzIEBACiAKICNpZiBFTkFCTEUoTk9U SUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQogI2luY2x1ZGUgIk5v dEltcGxlbWVudGVkLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorI2lu Y2x1ZGUgImV3a192aWV3X3ByaXZhdGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1Ob3Rp ZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVm bCgpCitOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbChFdmFzX09iamVjdCogdmlldykKKyAgICA6IG1fdmlldyh2aWV3KQogewogfQog CkBAIC01NCwyMCArNTcsNzggQEAgdm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6 Om5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0cm95ZWQoKQogICAgIG5vdEltcGxlbWVudGVkKCk7 CiB9CiAKKyNpZiBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCiB2b2lkIE5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+IGNhbGxiYWNrKQogewotICAg IG5vdEltcGxlbWVudGVkKCk7CisgICAgU3RyaW5nIGRvbWFpbiA9IGNvbnRleHQtPnVybCgpLmhv c3QoKTsKKyAgICBtX3BlbmRpbmdMZWdhY3lQZXJtaXNzaW9uUmVxdWVzdHMuYWRkKGRvbWFpbiwg Y2FsbGJhY2spOworICAgIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3JlcXVlc3Qo bV92aWV3LCBkb21haW4pOworfQorI2VuZGlmCisKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykK K3ZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpyZXF1ZXN0UGVybWlzc2lvbihT Y3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPE5vdGlmaWNhdGlvblBl cm1pc3Npb25DYWxsYmFjaz4gY2FsbGJhY2spCit7CisgICAgU3RyaW5nIGRvbWFpbiA9IGNvbnRl eHQtPnVybCgpLmhvc3QoKTsKKyAgICBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuYWRkKGRv bWFpbiwgY2FsbGJhY2spOworICAgIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3Jl cXVlc3QobV92aWV3LCBkb21haW4pOwogfQorI2VuZGlmCiAKIE5vdGlmaWNhdGlvbkNsaWVudDo6 UGVybWlzc2lvbiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNoZWNrUGVybWlzc2lv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Np b25zLmZpbmQoY29udGV4dC0+dXJsKCkuaG9zdCgpKTsKKworICAgIGlmIChpdGVyID09IG1fY2Fj aGVkUGVybWlzc2lvbnMuZW5kKCkpCisgICAgICAgIHJldHVybiBQZXJtaXNzaW9uTm90QWxsb3dl ZDsKKworICAgIGlmIChpdGVyLT5zZWNvbmQpCisgICAgICAgIHJldHVybiBQZXJtaXNzaW9uQWxs b3dlZDsKKwogICAgIHJldHVybiBQZXJtaXNzaW9uRGVuaWVkOwogfQogCiB2b2lkIE5vdGlmaWNh dGlvblByZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAg ICBTdHJpbmcgZG9tYWluID0gY29udGV4dC0+dXJsKCkuaG9zdCgpOworCisjaWYgRU5BQkxFKExF R0FDWV9OT1RJRklDQVRJT05TKQorICAgIExlZ2FjeVBlcm1pc3Npb25SZXF1ZXN0TWFwOjppdGVy YXRvciBsZWdhY3lJdGVyID0gbV9wZW5kaW5nTGVnYWN5UGVybWlzc2lvblJlcXVlc3RzLmZpbmQo ZG9tYWluKTsKKyAgICBpZiAobGVnYWN5SXRlciAhPSBtX3BlbmRpbmdMZWdhY3lQZXJtaXNzaW9u UmVxdWVzdHMuZW5kKCkpIHsKKyAgICAgICAgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Np b25fY2FuY2VsKG1fdmlldywgZG9tYWluKTsKKyAgICAgICAgbV9wZW5kaW5nTGVnYWN5UGVybWlz c2lvblJlcXVlc3RzLnJlbW92ZShsZWdhY3lJdGVyKTsKKyAgICB9CisjZW5kaWYKKworI2lmIEVO QUJMRShOT1RJRklDQVRJT05TKQorICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwOjppdGVyYXRvciBp dGVyID0gbV9wZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLmZpbmQoZG9tYWluKTsKKyAgICBpZiAo aXRlciAhPSBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpIHsKKyAgICAgICAgZXdr X3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FuY2VsKG1fdmlldywgZG9tYWluKTsKKyAg ICAgICAgbV9wZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLnJlbW92ZShpdGVyKTsKKyAgICB9Cisj ZW5kaWYKK30KKwordm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmFkZFBlcm1p c3Npb24oY29uc3QgY2hhciogZG9tYWluLCBjb25zdCBib29sIGlzQWxsb3dlZCkKK3sKKyNpZiBF TkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCisgICAgTGVnYWN5UGVybWlzc2lvblJlcXVlc3RN YXA6Oml0ZXJhdG9yIGxlZ2FjeUl0ZXIgPSBtX3BlbmRpbmdMZWdhY3lQZXJtaXNzaW9uUmVxdWVz dHMuZmluZChTdHJpbmcoZG9tYWluKSk7CisgICAgaWYgKGxlZ2FjeUl0ZXIgIT0gbV9wZW5kaW5n TGVnYWN5UGVybWlzc2lvblJlcXVlc3RzLmVuZCgpKSB7CisgICAgICAgIGlmIChpc0FsbG93ZWQp CisgICAgICAgICAgICBsZWdhY3lJdGVyLT5zZWNvbmQtPmhhbmRsZUV2ZW50KCk7CisgICAgICAg IG1fcGVuZGluZ0xlZ2FjeVBlcm1pc3Npb25SZXF1ZXN0cy5yZW1vdmUobGVnYWN5SXRlcik7Cisg ICAgfQorI2VuZGlmCisKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICBQZXJtaXNzaW9u UmVxdWVzdE1hcDo6aXRlcmF0b3IgaXRlciA9IG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0cy5m aW5kKFN0cmluZyhkb21haW4pKTsKKyAgICBpZiAoaXRlciAhPSBtX3BlbmRpbmdQZXJtaXNzaW9u UmVxdWVzdHMuZW5kKCkpIHsKKyAgICAgICAgaXRlci0+c2Vjb25kLT5oYW5kbGVFdmVudChOb3Rp ZmljYXRpb246OnBlcm1pc3Npb25TdHJpbmcoaXNBbGxvd2VkID8gTm90aWZpY2F0aW9uQ2xpZW50 OjpQZXJtaXNzaW9uQWxsb3dlZCA6IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbkRlbmll ZCkpOworICAgICAgICBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMucmVtb3ZlKGl0ZXIpOwor ICAgIH0KKyNlbmRpZgorCisgICAgbV9jYWNoZWRQZXJtaXNzaW9ucy5hZGQoU3RyaW5nKGRvbWFp biksIGlzQWxsb3dlZCk7CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dl YkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oIGIvU291cmNlL1dl YktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmgK aW5kZXggZWNlNWNjZmU0YjY1ZDEzNWE4MThiZDk5ZjEyNDU5NWUwMGEyYmZlMS4uNTQ5MjcxNzU5 Y2IyODYyN2JhMjk0ODk3ODk0MTlhYWNkYzc0ZmNhZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmgKKysr IGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsLmgKQEAgLTIzLDIyICsyMyw0NSBAQAogI2lmIEVOQUJMRShOT1RJRklDQVRJT05T KSB8fCBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9u LmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uQ2xpZW50LmgiCisjaW5jbHVkZSA8RXZhcy5oPgor I2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3Mg Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsIDogcHVibGljIE5vdGlmaWNhdGlvbkNsaWVu dCB7CiAKIHB1YmxpYzoKLSAgICBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKTsKKyAg ICBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoRXZhc19PYmplY3QqIHZpZXcpOwogICAg IH5Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKTsKIAogICAgIHZpcnR1YWwgYm9vbCBz aG93KE5vdGlmaWNhdGlvbiopOwogICAgIHZpcnR1YWwgdm9pZCBjYW5jZWwoTm90aWZpY2F0aW9u Kik7CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbk9iamVjdERlc3Ryb3llZChOb3RpZmlj YXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgbm90aWZpY2F0aW9uQ29udHJvbGxlckRlc3Ryb3ll ZCgpOworI2lmIEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKICAgICB2aXJ0dWFsIHZvaWQg cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8Vm9p ZENhbGxiYWNrPik7CisjZW5kaWYKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICB2aXJ0 dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NS ZWZQdHI8Tm90aWZpY2F0aW9uUGVybWlzc2lvbkNhbGxiYWNrPik7CisjZW5kaWYKICAgICB2aXJ0 dWFsIE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbiBjaGVja1Blcm1pc3Npb24oU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCopOwogICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0c0ZvclBl cm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOworCisgICAgdm9pZCBhZGRQZXJtaXNz aW9uKGNvbnN0IGNoYXIqIGRvbWFpbiwgYm9vbCBpc0FsbG93ZWQpOworCitwcml2YXRlOgorICAg IEV2YXNfT2JqZWN0KiBtX3ZpZXc7CisKKyNpZiBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMp CisgICAgdHlwZWRlZiBIYXNoTWFwPFN0cmluZywgUmVmUHRyPFdlYkNvcmU6OlZvaWRDYWxsYmFj az4gPiBMZWdhY3lQZXJtaXNzaW9uUmVxdWVzdE1hcDsKKyAgICBMZWdhY3lQZXJtaXNzaW9uUmVx dWVzdE1hcCBtX3BlbmRpbmdMZWdhY3lQZXJtaXNzaW9uUmVxdWVzdHM7CisjZW5kaWYKKyNpZiBF TkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8 V2ViQ29yZTo6Tm90aWZpY2F0aW9uUGVybWlzc2lvbkNhbGxiYWNrPiA+IFBlcm1pc3Npb25SZXF1 ZXN0TWFwOworICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1 ZXN0czsKKyNlbmRpZgorICAgIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIGJvb2w+IFBlcm1pc3Np b25zTWFwOworICAgIFBlcm1pc3Npb25zTWFwIG1fY2FjaGVkUGVybWlzc2lvbnM7CiB9OwogCiB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwIGIvU291cmNl L1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcAppbmRleCBhOTg3NjlhM2Y4ZTE4MjI1YTdkOTc1 ZDkyZTkxZWJmZGU3OTNhYjE4Li5hMzRkZTQwNjNjMzBmMTRhYmYwNzgyN2MwZmM2YjZiOWM2NmRl YTkwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKQEAgLTEwMyw2ICsxMDMsMTEgQEAK ICNpbmNsdWRlICJDb2xvckNob29zZXJDbGllbnQuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKE5P VElGSUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyNpbmNsdWRlICJO b3RpZmljYXRpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsLmgiCisjZW5kaWYKKwogc3RhdGljIGNvbnN0IGZsb2F0IHpvb21NaW5pbXVtID0g MC4wNTsKIHN0YXRpYyBjb25zdCBmbG9hdCB6b29tTWF4aW11bSA9IDQuMDsKIApAQCAtNzU3LDYg Kzc2MiwxMCBAQCBzdGF0aWMgRXdrX1ZpZXdfUHJpdmF0ZV9EYXRhKiBfZXdrX3ZpZXdfcHJpdl9u ZXcoRXdrX1ZpZXdfU21hcnRfRGF0YSogc21hcnREYXRhKQogICAgIFdlYkNvcmU6OnByb3ZpZGVC YXR0ZXJ5VG8ocHJpdi0+cGFnZS5nZXQoKSwgbmV3IFdlYkNvcmU6OkJhdHRlcnlDbGllbnRFZmwp OwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9O T1RJRklDQVRJT05TKQorICAgIFdlYkNvcmU6OnByb3ZpZGVOb3RpZmljYXRpb24ocHJpdi0+cGFn ZS5nZXQoKSwgbmV3IFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbChzbWFy dERhdGEtPnNlbGYpKTsKKyNlbmRpZgorCiAgICAgcHJpdi0+cGFnZVNldHRpbmdzID0gcHJpdi0+ cGFnZS0+c2V0dGluZ3MoKTsKIAogICAgIHByaXYtPnZpZXdwb3J0QXJndW1lbnRzLndpZHRoID0g V2ViQ29yZTo6Vmlld3BvcnRBcmd1bWVudHM6OlZhbHVlQXV0bzsKQEAgLTQ1MDAsNiArNDUwOSwz MiBAQCB2b2lkIGV3a192aWV3X2N1cnNvcl9zZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0 IFdlYkNvcmU6OkN1cnNvciYgY3Vyc29yKQogICAgIH0KIH0KIAorRWluYV9Cb29sIGV3a192aWV3 X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0 IGNoYXIqIGRvbWFpbiwgRWluYV9Cb29sIHBlcm1pdHRlZCkKK3sKKyNpZiBFTkFCTEUoTk9USUZJ Q0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQorICAgIEVXS19WSUVXX1NE X0dFVChld2tWaWV3LCBzbWFydERhdGEpOworICAgIEVXS19WSUVXX1BSSVZfR0VUKHNtYXJ0RGF0 YSwgcHJpdik7CisgICAgc3RhdGljX2Nhc3Q8V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsKj4oV2ViQ29yZTo6Tm90aWZpY2F0aW9uQ29udHJvbGxlcjo6Y2xpZW50RnJvbShw cml2LT5wYWdlLmdldCgpKSktPmFkZFBlcm1pc3Npb24oZG9tYWluLCBwZXJtaXR0ZWQpOworICAg IHJldHVybiB0cnVlOworI2Vsc2UKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKworI2lm IEVOQUJMRShOT1RJRklDQVRJT05TKSB8fCBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCit2 b2lkIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3JlcXVlc3QoRXZhc19PYmplY3Qq IGV3a1ZpZXcsIGNvbnN0IFdURjo6U3RyaW5nJiBkb21haW4pCit7CisgICAgQ1N0cmluZyByZXF1 ZXN0ZWREb21haW4gPSBkb21haW4udXRmOCgpOworICAgIGV2YXNfb2JqZWN0X3NtYXJ0X2NhbGxi YWNrX2NhbGwoZXdrVmlldywgIm5vdGlmaWNhdGlvbixwZXJtaXNzaW9uLHJlcXVlc3QiLCBjb25z dF9jYXN0PGNoYXIqPihyZXF1ZXN0ZWREb21haW4uZGF0YSgpKSk7Cit9CisKK3ZvaWQgZXdrX3Zp ZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FuY2VsKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBj b25zdCBXVEY6OlN0cmluZyYgZG9tYWluKQoreworICAgIENTdHJpbmcgcmVxdWVzdGVkRG9tYWlu ID0gZG9tYWluLnV0ZjgoKTsKKyAgICBldmFzX29iamVjdF9zbWFydF9jYWxsYmFja19jYWxsKGV3 a1ZpZXcsICJub3RpZmljYXRpb24scGVybWlzc2lvbixjYW5jZWwiLCBjb25zdF9jYXN0PGNoYXIq PihyZXF1ZXN0ZWREb21haW4uZGF0YSgpKSk7Cit9CisjZW5kaWYKKwogbmFtZXNwYWNlIEVXS1By aXZhdGUgewogCiBXZWJDb3JlOjpQYWdlKiBjb3JlUGFnZShjb25zdCBFdmFzX09iamVjdCogZXdr VmlldykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oIGIvU291 cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKaW5kZXggZDVmZWIzNmIzMzk5YzdlNGNhYWZh NTA2Y2Y2ZTMyN2JkN2Q0ZGFiOS4uODYzZmFmMWY0YWZmMzA5YTEzOTE2MTlkZDIyYjVlOGYzZmU4 YThjMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKKysrIGIv U291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKQEAgLTc0LDYgKzc0LDggQEAKICAqICAt ICJtaXhlZGNvbnRlbnQsZGlzcGxheWVkIiwgdm9pZDogYW55IG9mIHRoZSBjb250YWluaW5nIGZy YW1lcyBoYXMgbG9hZGVkIGFuZCBkaXNwbGF5ZWQgbWl4ZWQgY29udGVudC4KICAqICAtICJtaXhl ZGNvbnRlbnQscnVuIiwgdm9pZDogYW55IG9mIHRoZSBjb250YWluaW5nIGZyYW1lcyBoYXMgbG9h ZGVkIGFuZCBydW4gbWl4ZWQgY29udGVudC4KICAqICAtICJuYXZpZ2F0ZSx3aXRoLGRhdGEiLCBF d2tfVmlld19OYXZpZ2F0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBkaWQgbmF2aWdhdGlv biBhbmQgZ2l2ZXMgdGhlIG5hdmlnYXRpb24gZGV0YWlscy4KKyAqICAtICJub3RpZmljYXRpb24s cGVybWlzc2lvbixjYW5jZWwiLCBjb25zdCBjaGFyKjogcmVxdWVzdCB0byBjYW5jZWwgcGVybWlz c2lvbiByZXF1ZXN0aW5nIGZvciBkb21haW4uCisgKiAgLSAibm90aWZpY2F0aW9uLHBlcm1pc3Np b24scmVxdWVzdCIsIGNvbnN0IGNoYXIqOiByZXF1ZXN0IHRvIGNvbmZpcm0gcGVybWlzc2lvbiBm b3IgZG9tYWluIGZyb20gdXNlci4KICAqICAtICJwZXJmb3JtLGNsaWVudCxyZWRpcmVjdCIsIEV3 a19WaWV3X1JlZGlyZWN0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBwZXJmb3JtZWQgYSBj bGllbnQgcmVkaXJlY3QgYW5kIGdpdmVzIHRoZSByZWRpcmVjdGlvbiBkZXRhaWxzLgogICogIC0g InBlcmZvcm0sc2VydmVyLHJlZGlyZWN0IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0YSo6IHJl cG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIHNlcnZlciByZWRpcmVjdCBhbmQgZ2l2ZXMgdGhl IHJlZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAicHJvdG9jb2xoYW5kbGVyLHJlZ2lzdHJhdGlv bixyZXF1ZXN0ZWQiLCBFd2tfQ3VzdG9tX0hhbmRsZXJfRGF0YTogYWRkIGEgaGFuZGxlciB1cmwg Zm9yIHRoZSBnaXZlbiBwcm90b2NvbC4KQEAgLTI2OTMsNiArMjY5NSwxNyBAQCBFQVBJIEV2YXNf T2JqZWN0KiBld2tfdmlld193ZWJfaW5zcGVjdG9yX3ZpZXdfZ2V0KGNvbnN0IEV2YXNfT2JqZWN0 ICpvKTsKICAqLwogRUFQSSB2b2lkIGV3a192aWV3X3dlYl9pbnNwZWN0b3Jfdmlld19zZXQoRXZh c19PYmplY3QgKm8sIEV2YXNfT2JqZWN0ICppbnNwZWN0b3Jfdmlldyk7CiAKKy8qKgorICogU2V0 IHBlcm1pdHRlZCBvciBkZW5pZWQgbGlzdHMgdG8gdGhlIHBlcm1pc3Npb24gY2FjaGUgZm9yIHRo ZSBXZWIgTm90aWZpY2FpdG9ucy4KKyAqCisgKiBAcGFyYW0gbyB2aWV3IG9iamVjdCB0byBzZXQg dGhlIHBlcm1pc3Npb24gY2FjaGUgbGlzdC4KKyAqIEBwYXJhbSBkb21haW4gc3RyaW5nIGZvciBk ZXRlcm1pbmUgdGhlIHBlcm1pc3Npb24uCisgKiBAcGFyYW0gYWxsb3cgQGMgRUlOQV9UUlVFIHRv IHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0byBkZW55LgorCisgKiBAcmV0dXJuIEBjIEVJTkFfVFJV RSBvbiBzdWNjZXNzIG9yIEBjIEVJTkFfRkFMU0Ugb24gZmFpbHVyZQorICovCitFQVBJIEVpbmFf Qm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc2V0KEV2YXNfT2JqZWN0ICpv LCBjb25zdCBjaGFyICpkb21haW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQpOworCiAjaWZkZWYgX19j cGx1c3BsdXMKIH0KICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3 a192aWV3X3ByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRl LmgKaW5kZXggYjcwZTc1NWIxNjA5M2E1M2NlNmNkMzc4ZTM2M2RjNjkyM2RmMWQ4OS4uY2U5ZmI4 NWM2YmViMzIzOGY0NmU1YTRhYTI1MzE3N2ZjMDU1ZTM3YSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9l d2svZXdrX3ZpZXdfcHJpdmF0ZS5oCkBAIC0xNTYsNiArMTU2LDExIEBAIGJvb2wgZXdrX3ZpZXdf YWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfb2JqZWN0X2NyZWF0ZShFdmFzX09iamVjdCogZXdrVmll dywgRXZhc19OCiBXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRCogZXdrX3ZpZXdfYWNjZWxlcmF0 ZWRfY29tcG9zaXRpbmdfY29udGV4dF9nZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcpOwogI2VuZGlm CiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJ T05TKQordm9pZCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNf T2JqZWN0KiBld2tWaWV3LCBjb25zdCBXVEY6OlN0cmluZyYgZG9tYWluKTsKK3ZvaWQgZXdrX3Zp ZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FuY2VsKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBj b25zdCBXVEY6OlN0cmluZyYgZG9tYWluKTsKKyNlbmRpZgorCiBuYW1lc3BhY2UgRVdLUHJpdmF0 ZSB7CiBXZWJDb3JlOjpQYWdlICpjb3JlUGFnZShjb25zdCBFdmFzX09iamVjdCAqZXdrVmlldyk7 CiBQbGF0Zm9ybVBhZ2VDbGllbnQgY29yZVBhZ2VDbGllbnQoRXZhc19PYmplY3QqIGV3a1ZpZXcp Owo= 152903 2012-07-17 19:19:21 -0700 2012-07-22 20:19:29 -0700 Patch bug-90603-20120718111919.patch text/plain 12883 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTIyNjk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggZmE0N2U5Yjc2 MjFjN2ExZWIzNDNhMWQxZjc3MGNlNzViMGUzMzAwMS4uZmE4YWVlMDFhNjY5MWU3ZTZkOTg1Njdi MTM4ZTY4ZjUwNTllZmE0ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEy LTA3LTE3ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z LgorICAgICAgICBjaGVja1Blcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uTGV2 ZWwoKS4KKyAgICAgICAgcmVxdWVzdFBlcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5yZXF1ZXN0 UGVybWlzc2lvbigpLgorICAgICAgICBJbiBhZGRpdGlvbiwgaWYgdGhlcmUgYXJlIHN0b3JlZCBw ZXJtaXNzaW9ucyBpbiB0aGUgb3V0c2lkZSBhcHBsaWNhdGlvbihsaWtlIGEgYnJvd3NlcikKKyAg ICAgICAgbmVlZCB0byBiZSBjYWNoZWQgYnkgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Np b25zX2NhY2hlX2FkZC4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVz ZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCk6CisgICAgICAg IChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNz aW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 Y2hlY2tQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbDo6YWRkUGVybWlzc2lvbkNhY2hlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAg ICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpzZXRQZXJtaXNz aW9uKToKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuaDoKKyAgICAgICAgKE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCk6CisgICAg ICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJt aXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVm bDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKToKKyAgICAgICAgKiBld2svZXdrX3ZpZXcu Y3BwOgorICAgICAgICAoX2V3a192aWV3X3ByaXZfbmV3KToKKyAgICAgICAgKGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uX2NhY2hlX2FkZCk6CisgICAgICAgIChld2tfdmlld19ub3Rp ZmljYXRpb25fcGVybWlzc2lvbnNfc2V0KToKKyAgICAgICAgKGV3a192aWV3X25vdGlmaWNhdGlv bl9wZXJtaXNzaW9uX3JlcXVlc3QpOgorICAgICAgICAqIGV3ay9ld2tfdmlldy5oOgorICAgICAg ICAqIGV3ay9ld2tfdmlld19wcml2YXRlLmg6CisKIDIwMTItMDctMTUgIEtpaG9uZyBLd29uICA8 a2lob25nLmt3b25Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gQWRkIGEgQVBJIGZvciBn ZXR0aW5nIHNlY3VyaXR5IG9yaWdpbiBzdHJpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv ZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHAgYi9T b3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuY3BwCmluZGV4IGM0ZTVjYThkYTQ4YTcxYWNhMjQ3ZTg4MzMxNjRjMGNiYjk3YzRkNWQu Ljg1MmRiMDQzYThlMzQ4ZTVjNTA3NjEzM2Y2OTc0YjFkM2FhMmFhODUgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0 aW9uUHJlc2VudGVyQ2xpZW50RWZsLmNwcApAQCAtMjAsMTIgKzIwLDE3IEBACiAjaW5jbHVkZSAi Y29uZmlnLmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmgiCiAK LSNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05T KQorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgi CisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorI2luY2x1ZGUgIlNlY3VyaXR5 T3JpZ2luLmgiCisjaW5jbHVkZSAiZXdrX3NlY3VyaXR5X29yaWdpbl9wcml2YXRlLmgiCisjaW5j bHVkZSAiZXdrX3ZpZXdfcHJpdmF0ZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLU5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZs KCkKK05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Tm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KQorICAgIDogbV92aWV3KHZpZXcpCiB7CiB9CiAK QEAgLTU0LDIwICs1OSw0NyBAQCB2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 bm90aWZpY2F0aW9uQ29udHJvbGxlckRlc3Ryb3llZCgpCiAgICAgbm90SW1wbGVtZW50ZWQoKTsK IH0KIAotdm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNz aW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8Vm9pZENhbGxi YWNrPiBjYWxsYmFjaykKK3ZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpyZXF1 ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRy PE5vdGlmaWNhdGlvblBlcm1pc3Npb25DYWxsYmFjaz4gY2FsbGJhY2spCiB7Ci0gICAgbm90SW1w bGVtZW50ZWQoKTsKKyAgICBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4gPSBld2tfc2VjdXJp dHlfb3JpZ2luX25ldyhjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpKTsKKyAgICBtX3BlbmRpbmdQ ZXJtaXNzaW9uUmVxdWVzdHMuYWRkKG9yaWdpbiwgY2FsbGJhY2spOworICAgIGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uX3JlcXVlc3QobV92aWV3LCBvcmlnaW4pOwogfQogCiBOb3Rp ZmljYXRpb25DbGllbnQ6OlBlcm1pc3Npb24gTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZs OjpjaGVja1Blcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKIHsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOworICAgIFBlcm1pc3Npb25zTWFwOjppdGVyYXRvciBpdGVyID0g bV9jYWNoZWRQZXJtaXNzaW9ucy5maW5kKGNvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPnRvU3Ry aW5nKCkpOworCisgICAgaWYgKGl0ZXIgPT0gbV9jYWNoZWRQZXJtaXNzaW9ucy5lbmQoKSkKKyAg ICAgICAgcmV0dXJuIFBlcm1pc3Npb25Ob3RBbGxvd2VkOworCisgICAgaWYgKGl0ZXItPnNlY29u ZCkKKyAgICAgICAgcmV0dXJuIFBlcm1pc3Npb25BbGxvd2VkOworCiAgICAgcmV0dXJuIFBlcm1p c3Npb25EZW5pZWQ7CiB9CiAKLXZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpj YW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4 dCkKK3ZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjphZGRQZXJtaXNzaW9uQ2Fj aGUoY29uc3QgY2hhciogZG9tYWluLCBjb25zdCBib29sIGlzQWxsb3dlZCkKIHsKLSAgICBub3RJ bXBsZW1lbnRlZCgpOworICAgIFBlcm1pc3Npb25zTWFwOjppdGVyYXRvciBpdGVyID0gbV9jYWNo ZWRQZXJtaXNzaW9ucy5maW5kKFN0cmluZyhkb21haW4pKTsKKworICAgIGlmIChpdGVyID09IG1f Y2FjaGVkUGVybWlzc2lvbnMuZW5kKCkpCisgICAgICAgIHJldHVybjsKKworICAgIG1fY2FjaGVk UGVybWlzc2lvbnMuYWRkKFN0cmluZyhkb21haW4pLCBpc0FsbG93ZWQpOworfQorCit2b2lkIE5v dGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVybWlzc2lvbihjb25zdCBFd2tfU2Vj dXJpdHlfT3JpZ2luKiBvcmlnaW4sIGNvbnN0IGJvb2wgaXNBbGxvd2VkKQoreworICAgIFBlcm1p c3Npb25SZXF1ZXN0TWFwOjppdGVyYXRvciBpdGVyID0gbV9wZW5kaW5nUGVybWlzc2lvblJlcXVl c3RzLmZpbmQoY29uc3RfY2FzdDxFd2tfU2VjdXJpdHlfT3JpZ2luKj4ob3JpZ2luKSk7CisKKyAg ICBpZiAoaXRlciA9PSBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpCisgICAgICAg IHJldHVybjsKKworICAgIGl0ZXItPnNlY29uZC0+aGFuZGxlRXZlbnQoTm90aWZpY2F0aW9uOjpw ZXJtaXNzaW9uU3RyaW5nKGlzQWxsb3dlZCA/IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lv bkFsbG93ZWQgOiBOb3RpZmljYXRpb25DbGllbnQ6OlBlcm1pc3Npb25EZW5pZWQpKTsKKyAgICBt X3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMucmVtb3ZlKGl0ZXIpOworICAgIG1fY2FjaGVkUGVy bWlzc2lvbnMuYWRkKFN0cmluZyhld2tfc2VjdXJpdHlfb3JpZ2luX3N0cmluZ19nZXQob3JpZ2lu KSksIGlzQWxsb3dlZCk7CisgICAgZXdrX3NlY3VyaXR5X29yaWdpbl9mcmVlKGNvbnN0X2Nhc3Q8 RXdrX1NlY3VyaXR5X09yaWdpbio+KG9yaWdpbikpOwogfQogCiB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRF ZmwuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNl bnRlckNsaWVudEVmbC5oCmluZGV4IGVjZTVjY2ZlNGI2NWQxMzVhODE4YmQ5OWYxMjQ1OTVlMDBh MmJmZTEuLmIzZGNkNDlkMzA3YzU1YzNjZjQ2NmZkN2I5M2VkM2U4ODJiMTFlYjYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oCkBAIC0yMCwyNSArMjAsNDEgQEAKICNpZm5kZWYg Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsX2gKICNkZWZpbmUgTm90aWZpY2F0aW9uUHJl c2VudGVyQ2xpZW50RWZsX2gKIAotI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKSB8fCBFTkFCTEUo TEVHQUNZX05PVElGSUNBVElPTlMpCisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCiAjaW5jbHVk ZSAiTm90aWZpY2F0aW9uLmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uQ2xpZW50LmgiCisjaW5j bHVkZSAiZXdrX3NlY3VyaXR5X29yaWdpbi5oIgorI2luY2x1ZGUgPEV2YXMuaD4KKyNpbmNsdWRl IDx3dGYvSGFzaE1hcC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIE5vdGlmaWNh dGlvblByZXNlbnRlckNsaWVudEVmbCA6IHB1YmxpYyBOb3RpZmljYXRpb25DbGllbnQgewotCiBw dWJsaWM6Ci0gICAgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CisgICAgTm90aWZp Y2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KTsKICAgICB+Tm90aWZp Y2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CiAKICAgICB2aXJ0dWFsIGJvb2wgc2hvdyhOb3Rp ZmljYXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsKE5vdGlmaWNhdGlvbiopOwogICAg IHZpcnR1YWwgdm9pZCBub3RpZmljYXRpb25PYmplY3REZXN0cm95ZWQoTm90aWZpY2F0aW9uKik7 CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0cm95ZWQoKTsKLSAg ICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCos IFBhc3NSZWZQdHI8Vm9pZENhbGxiYWNrPik7CisjaWYgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJ T05TKQorICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+KSB7IH0KKyNlbmRpZgorICAgIHZpcnR1 YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1Jl ZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+KTsKICAgICB2aXJ0dWFsIE5vdGlm aWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbiBjaGVja1Blcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9u Q29udGV4dCopOwotICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24o U2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOworICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0 c0ZvclBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopIHsgfQorCisgICAgdm9pZCBh ZGRQZXJtaXNzaW9uQ2FjaGUoY29uc3QgY2hhciogZG9tYWluLCBib29sIGlzQWxsb3dlZCk7Cisg ICAgdm9pZCBzZXRQZXJtaXNzaW9uKGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qLCBib29sIGlz QWxsb3dlZCk7CisKK3ByaXZhdGU6CisgICAgRXZhc19PYmplY3QqIG1fdmlldzsKKworICAgIHR5 cGVkZWYgSGFzaE1hcDxFd2tfU2VjdXJpdHlfT3JpZ2luKiwgUmVmUHRyPFdlYkNvcmU6Ok5vdGlm aWNhdGlvblBlcm1pc3Npb25DYWxsYmFjaz4gPiBQZXJtaXNzaW9uUmVxdWVzdE1hcDsKKyAgICBQ ZXJtaXNzaW9uUmVxdWVzdE1hcCBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHM7CisgICAgdHlw ZWRlZiBIYXNoTWFwPFN0cmluZywgYm9vbD4gUGVybWlzc2lvbnNNYXA7CisgICAgUGVybWlzc2lv bnNNYXAgbV9jYWNoZWRQZXJtaXNzaW9uczsKIH07CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3Zp ZXcuY3BwCmluZGV4IDFhZTgzZmM5ZDhiMzViOTk4NGExOWEwZTU2ZGY4MzI1MTRkNTNlNjkuLjkx OGJlZmYyOWFjOTVhZjkwMzJlNzM5OTFmZjJiYzVhOGY4M2ViZTEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvZXdr L2V3a192aWV3LmNwcApAQCAtMTAzLDYgKzEwMywxMSBAQAogI2luY2x1ZGUgIkNvbG9yQ2hvb3Nl ckNsaWVudC5oIgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxF KExFR0FDWV9OT1RJRklDQVRJT05TKQorI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNvbnRyb2xsZXIu aCIKKyNpbmNsdWRlICJOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaCIKKyNlbmRpZgor CiBzdGF0aWMgY29uc3QgZmxvYXQgem9vbU1pbmltdW0gPSAwLjA1Owogc3RhdGljIGNvbnN0IGZs b2F0IHpvb21NYXhpbXVtID0gNC4wOwogCkBAIC03NTcsNiArNzYyLDEwIEBAIHN0YXRpYyBFd2tf Vmlld19Qcml2YXRlX0RhdGEqIF9ld2tfdmlld19wcml2X25ldyhFd2tfVmlld19TbWFydF9EYXRh KiBzbWFydERhdGEpCiAgICAgV2ViQ29yZTo6cHJvdmlkZUJhdHRlcnlUbyhwcml2LT5wYWdlLmdl dCgpLCBuZXcgQmF0dGVyeUNsaWVudEVmbCk7CiAjZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklD QVRJT05TKSB8fCBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCisgICAgV2ViQ29yZTo6cHJv dmlkZU5vdGlmaWNhdGlvbihwcml2LT5wYWdlLmdldCgpLCBuZXcgV2ViQ29yZTo6Tm90aWZpY2F0 aW9uUHJlc2VudGVyQ2xpZW50RWZsKHNtYXJ0RGF0YS0+c2VsZikpOworI2VuZGlmCisKICAgICBw cml2LT5wYWdlU2V0dGluZ3MgPSBwcml2LT5wYWdlLT5zZXR0aW5ncygpOwogCiAgICAgcHJpdi0+ dmlld3BvcnRBcmd1bWVudHMud2lkdGggPSBXZWJDb3JlOjpWaWV3cG9ydEFyZ3VtZW50czo6VmFs dWVBdXRvOwpAQCAtNDUwMCw2ICs0NTA5LDM3IEBAIHZvaWQgZXdrX3ZpZXdfY3Vyc29yX3NldChF dmFzX09iamVjdCogZXdrVmlldywgY29uc3QgV2ViQ29yZTo6Q3Vyc29yJiBjdXJzb3IpCiAgICAg fQogfQogCitFaW5hX0Jvb2wgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FjaGVf YWRkKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBjaGFyKiBkb21haW4sIEVpbmFfQm9vbCBw ZXJtaXR0ZWQpCit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdfU0Rf R0VUKGV3a1ZpZXcsIHNtYXJ0RGF0YSk7CisgICAgRVdLX1ZJRVdfUFJJVl9HRVQoc21hcnREYXRh LCBwcml2KTsKKyAgICBzdGF0aWNfY2FzdDxXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJD bGllbnRFZmwqPihXZWJDb3JlOjpOb3RpZmljYXRpb25Db250cm9sbGVyOjpjbGllbnRGcm9tKHBy aXYtPnBhZ2UuZ2V0KCkpKS0+YWRkUGVybWlzc2lvbkNhY2hlKGRvbWFpbiwgcGVybWl0dGVkKTsK KyAgICByZXR1cm4gdHJ1ZTsKKyNlbHNlCisgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCit9CisK K0VpbmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc2V0KEV2YXNfT2Jq ZWN0KiBld2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4sIEVpbmFfQm9v bCBwZXJtaXR0ZWQpCit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdf U0RfR0VUKGV3a1ZpZXcsIHNtYXJ0RGF0YSk7CisgICAgRVdLX1ZJRVdfUFJJVl9HRVQoc21hcnRE YXRhLCBwcml2KTsKKyAgICBzdGF0aWNfY2FzdDxXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50 ZXJDbGllbnRFZmwqPihXZWJDb3JlOjpOb3RpZmljYXRpb25Db250cm9sbGVyOjpjbGllbnRGcm9t KHByaXYtPnBhZ2UuZ2V0KCkpKS0+c2V0UGVybWlzc2lvbihvcmlnaW4sIHBlcm1pdHRlZCk7Cisg ICAgcmV0dXJuIHRydWU7CisjZWxzZQorICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorfQorCisj aWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCit2b2lkIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJt aXNzaW9uX3JlcXVlc3QoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IEV3a19TZWN1cml0eV9P cmlnaW4qIG9yaWdpbikKK3sKKyAgICBldmFzX29iamVjdF9zbWFydF9jYWxsYmFja19jYWxsKGV3 a1ZpZXcsICJub3RpZmljYXRpb24scGVybWlzc2lvbixyZXF1ZXN0IiwgY29uc3RfY2FzdDxFd2tf U2VjdXJpdHlfT3JpZ2luKj4ob3JpZ2luKSk7Cit9CisjZW5kaWYKKwogbmFtZXNwYWNlIEVXS1By aXZhdGUgewogCiBXZWJDb3JlOjpQYWdlKiBjb3JlUGFnZShjb25zdCBFdmFzX09iamVjdCogZXdr VmlldykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oIGIvU291 cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKaW5kZXggZDVmZWIzNmIzMzk5YzdlNGNhYWZh NTA2Y2Y2ZTMyN2JkN2Q0ZGFiOS4uMzg4YWQ0MTY0ZWYzNTg1ODUzMTgyMjdmZDU5OWFmY2Q1MTFl Y2ZmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKKysrIGIv U291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKQEAgLTc0LDYgKzc0LDcgQEAKICAqICAt ICJtaXhlZGNvbnRlbnQsZGlzcGxheWVkIiwgdm9pZDogYW55IG9mIHRoZSBjb250YWluaW5nIGZy YW1lcyBoYXMgbG9hZGVkIGFuZCBkaXNwbGF5ZWQgbWl4ZWQgY29udGVudC4KICAqICAtICJtaXhl ZGNvbnRlbnQscnVuIiwgdm9pZDogYW55IG9mIHRoZSBjb250YWluaW5nIGZyYW1lcyBoYXMgbG9h ZGVkIGFuZCBydW4gbWl4ZWQgY29udGVudC4KICAqICAtICJuYXZpZ2F0ZSx3aXRoLGRhdGEiLCBF d2tfVmlld19OYXZpZ2F0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBkaWQgbmF2aWdhdGlv biBhbmQgZ2l2ZXMgdGhlIG5hdmlnYXRpb24gZGV0YWlscy4KKyAqICAtICJub3RpZmljYXRpb24s cGVybWlzc2lvbixyZXF1ZXN0IiwgY29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbio6IHJlcXVlc3Qg dG8gY29uZmlybSBwZXJtaXNzaW9uIGZvciBzZWN1cml0eSBvcmlnaW4gZnJvbSB1c2VyLgogICog IC0gInBlcmZvcm0sY2xpZW50LHJlZGlyZWN0IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0YSo6 IHJlcG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIGNsaWVudCByZWRpcmVjdCBhbmQgZ2l2ZXMg dGhlIHJlZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAicGVyZm9ybSxzZXJ2ZXIscmVkaXJlY3Qi LCBFd2tfVmlld19SZWRpcmVjdGlvbl9EYXRhKjogcmVwb3J0cyB0aGF0IHZpZXcgcGVyZm9ybWVk IGEgc2VydmVyIHJlZGlyZWN0IGFuZCBnaXZlcyB0aGUgcmVkaXJlY3Rpb24gZGV0YWlscy4KICAq ICAtICJwcm90b2NvbGhhbmRsZXIscmVnaXN0cmF0aW9uLHJlcXVlc3RlZCIsIEV3a19DdXN0b21f SGFuZGxlcl9EYXRhOiBhZGQgYSBoYW5kbGVyIHVybCBmb3IgdGhlIGdpdmVuIHByb3RvY29sLgpA QCAtMjY5Myw2ICsyNjk0LDMzIEBAIEVBUEkgRXZhc19PYmplY3QqIGV3a192aWV3X3dlYl9pbnNw ZWN0b3Jfdmlld19nZXQoY29uc3QgRXZhc19PYmplY3QgKm8pOwogICovCiBFQVBJIHZvaWQgZXdr X3ZpZXdfd2ViX2luc3BlY3Rvcl92aWV3X3NldChFdmFzX09iamVjdCAqbywgRXZhc19PYmplY3Qg Kmluc3BlY3Rvcl92aWV3KTsKIAorLyoqCisgKiBBZGQgcGVybWl0dGVkIG9yIGRlbmllZCBsaXN0 IHRvIHRoZSBwZXJtaXNzaW9uIGNhY2hlIGZvciBXZWIgTm90aWZpY2FpdG9ucy4KKyAqCisgKiBJ ZiB0aGVyZSBhcmUgc3RvcmVkIHBlcm1pc3Npb24gbGlzdHMgZm9yIFdlYiBOb3RpZmljYXRpb25z LAorICogdGhpcyBmdW5jdGlvbiBuZWVkIHRvIGJlIGNhbGxlZCB3aXRoIHBlcm1pc3Npb24uCisg KgorICogQHBhcmFtIG8gdmlldyBvYmplY3QgdG8gc2V0IHRoZSBwZXJtaXNzaW9uIGNhY2hlIGxp c3QuCisgKiBAcGFyYW0gZG9tYWluIHN0cmluZyBmb3IgZGV0ZXJtaW5lIHRoZSBwZXJtaXNzaW9u LgorICogQHBhcmFtIHBlcm1pdHRlZCBAYyBFSU5BX1RSVUUgdG8gcGVybWl0LCBAYyBFSU5BX0ZB TFNFIHRvIGRlbnkuCisgKgorICogQHJldHVybiBAYyBFSU5BX1RSVUUgb24gc3VjY2VzcyBvciBA YyBFSU5BX0ZBTFNFIG9uIGZhaWx1cmUKKyAqLworRWluYV9Cb29sIGV3a192aWV3X25vdGlmaWNh dGlvbl9wZXJtaXNzaW9uX2NhY2hlX2FkZChFdmFzX09iamVjdCAqbywgY29uc3QgY2hhciAqZG9t YWluLCBFaW5hX0Jvb2wgcGVybWl0dGVkKTsKKworLyoqCisgKiBTZXQgcGVybWl0dGVkIG9yIGRl bmllZCBsaXN0cyB0byB0aGUgcGVybWlzc2lvbiBjYWNoZSBmb3IgdGhlIFdlYiBOb3RpZmljYWl0 b25zLgorICoKKyAqIEFmdGVyIGNoZWNraW5nIHBlcm1pc3Npb24sIHRoaXMgZnVuY3Rpb24gaGF2 ZSB0byBiZSBjYWxsZWQgdG8gc2V0IHBlcm1pc3Npb24uCisgKgorICogQHBhcmFtIG8gdmlldyBv YmplY3QgdG8gc2V0IHRoZSBwZXJtaXNzaW9uLgorICogQHBhcmFtIG9yaWdpbiBzZWN1cml0eSBv cmlnaW4gb2JqZWN0CisgKiBAcGFyYW0gYWxsb3cgQGMgRUlOQV9UUlVFIHRvIHBlcm1pdCwgQGMg RUlOQV9GQUxTRSB0byBkZW55LgorICoKKyAqIEByZXR1cm4gQGMgRUlOQV9UUlVFIG9uIHN1Y2Nl c3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWlsdXJlCisgKi8KK0VBUEkgRWluYV9Cb29sIGV3a192 aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQoRXZhc19PYmplY3QgKm8sIGNvbnN0IEV3 a19TZWN1cml0eV9PcmlnaW4gKm9yaWdpbiwgRWluYV9Cb29sIHBlcm1pdHRlZCk7CisKICNpZmRl ZiBfX2NwbHVzcGx1cwogfQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9l d2svZXdrX3ZpZXdfcHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3By aXZhdGUuaAppbmRleCBiNzBlNzU1YjE2MDkzYTUzY2U2Y2QzNzhlMzYzZGM2OTIzZGYxZDg5Li5m NDkyNmRiYjNlZWM1ZTUwNjIzMzEzZmYzMjRmZDIwYjRjMGZmNTQ1IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQv ZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgKQEAgLTE1Niw2ICsxNTYsMTAgQEAgYm9vbCBld2tf dmlld19hY2NlbGVyYXRlZF9jb21wb3NpdGluZ19vYmplY3RfY3JlYXRlKEV2YXNfT2JqZWN0KiBl d2tWaWV3LCBFdmFzX04KIFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEKiBld2tfdmlld19hY2Nl bGVyYXRlZF9jb21wb3NpdGluZ19jb250ZXh0X2dldChFdmFzX09iamVjdCogZXdrVmlldyk7CiAj ZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQordm9pZCBld2tfdmlld19ub3RpZmlj YXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBFd2tf U2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4pOworI2VuZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRl IHsKIFdlYkNvcmU6OlBhZ2UgKmNvcmVQYWdlKGNvbnN0IEV2YXNfT2JqZWN0ICpld2tWaWV3KTsK IFBsYXRmb3JtUGFnZUNsaWVudCBjb3JlUGFnZUNsaWVudChFdmFzX09iamVjdCogZXdrVmlldyk7 Cg== 153724 2012-07-22 20:19:42 -0700 2012-08-26 19:42:51 -0700 Patch bug-90603-20120723121933.patch text/plain 13022 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTIzMjg3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggYjA2ZWZhMTNl MmVmMjc2MzIyZGQ4OWEzZjBlM2ZhNzQ4YWZjNTk1MS4uODlkMDFiZDg4NmU4NTAzMmM0NTliMDE5 NmI1OGJjM2ZhOTU4MGY4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDM3IEBACiAyMDEy LTA3LTIwICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgogCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z LgorICAgICAgICBjaGVja1Blcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uTGV2 ZWwoKS4KKyAgICAgICAgcmVxdWVzdFBlcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5yZXF1ZXN0 UGVybWlzc2lvbigpLgorICAgICAgICBJbiBhZGRpdGlvbiwgaWYgdGhlcmUgYXJlIHN0b3JlZCBw ZXJtaXNzaW9ucyBpbiB0aGUgb3V0c2lkZSBhcHBsaWNhdGlvbihsaWtlIGEgYnJvd3NlcikKKyAg ICAgICAgbmVlZCB0byBiZSBjYWNoZWQgYnkgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Np b25zX2NhY2hlX2FkZC4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVz ZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCk6CisgICAgICAg IChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNz aW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 Y2hlY2tQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbDo6YWRkVG9QZXJtaXNzaW9uQ2FjaGUpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnNldFBlcm1p c3Npb24pOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbC5oOgorICAgICAgICAoTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKToKKyAg ICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBl cm1pc3Npb24pOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsOjpjYW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24pOgorICAgICAgICAqIGV3ay9ld2tfdmll dy5jcHA6CisgICAgICAgIChfZXdrX3ZpZXdfcHJpdl9uZXcpOgorICAgICAgICAoZXdrX3ZpZXdf bm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FjaGVfYWRkKToKKyAgICAgICAgKGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQpOgorICAgICAgICAoZXdrX3ZpZXdfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25fcmVxdWVzdCk6CisgICAgICAgICogZXdrL2V3a192aWV3Lmg6CisgICAg ICAgICogZXdrL2V3a192aWV3X3ByaXZhdGUuaDoKKworMjAxMi0wNy0yMCAgS2lob25nIEt3b24g IDxraWhvbmcua3dvbkBzYW1zdW5nLmNvbT4KKwogICAgICAgICBbRUZMXSBSZW1vdmUgdW51c2Vk IGhlYWRlcnMgZnJvbSBld2tfc2VjdXJpdHlfb3JpZ2luCiAgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05MTkxNAogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3Bw IGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsLmNwcAppbmRleCBjNGU1Y2E4ZGE0OGE3MWFjYTI0N2U4ODMzMTY0YzBjYmI5N2M0 ZDVkLi5mMmM0ZjMyN2VmYzE1NjI4OTc0ZTNjNTE2YjNkZmI5ZDcyNzdlNDdiIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJD bGllbnRFZmwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHAKQEAgLTIwLDEyICsyMCwxNyBAQAogI2luY2x1 ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5o IgogCi0jaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FU SU9OUykKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRl ZC5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRlICJTZWN1 cml0eU9yaWdpbi5oIgorI2luY2x1ZGUgImV3a19zZWN1cml0eV9vcmlnaW5fcHJpdmF0ZS5oIgor I2luY2x1ZGUgImV3a192aWV3X3ByaXZhdGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1O b3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbCgpCitOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNl bnRlckNsaWVudEVmbChFdmFzX09iamVjdCogdmlldykKKyAgICA6IG1fdmlldyh2aWV3KQogewog fQogCkBAIC01NCwyMCArNTksNDcgQEAgdm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRF Zmw6Om5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0cm95ZWQoKQogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKLXZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpyZXF1ZXN0UGVy bWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPFZvaWRD YWxsYmFjaz4gY2FsbGJhY2spCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1Jl ZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+IGNhbGxiYWNrKQogewotICAgIG5v dEltcGxlbWVudGVkKCk7CisgICAgRXdrX1NlY3VyaXR5X09yaWdpbiogb3JpZ2luID0gZXdrX3Nl Y3VyaXR5X29yaWdpbl9uZXcoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKSk7CisgICAgbV9wZW5k aW5nUGVybWlzc2lvblJlcXVlc3RzLmFkZChvcmlnaW4sIGNhbGxiYWNrKTsKKyAgICBld2tfdmll d19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KG1fdmlldywgb3JpZ2luKTsKIH0KIAog Tm90aWZpY2F0aW9uQ2xpZW50OjpQZXJtaXNzaW9uIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbDo6Y2hlY2tQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiB7 Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBQZXJtaXNzaW9uc01hcDo6aXRlcmF0b3IgaXRl ciA9IG1fY2FjaGVkUGVybWlzc2lvbnMuZmluZChjb250ZXh0LT5zZWN1cml0eU9yaWdpbigpLT50 b1N0cmluZygpKTsKKworICAgIGlmIChpdGVyID09IG1fY2FjaGVkUGVybWlzc2lvbnMuZW5kKCkp CisgICAgICAgIHJldHVybiBQZXJtaXNzaW9uTm90QWxsb3dlZDsKKworICAgIGlmIChpdGVyLT5z ZWNvbmQpCisgICAgICAgIHJldHVybiBQZXJtaXNzaW9uQWxsb3dlZDsKKwogICAgIHJldHVybiBQ ZXJtaXNzaW9uRGVuaWVkOwogfQogCi12b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVm bDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNv bnRleHQpCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6YWRkVG9QZXJtaXNz aW9uQ2FjaGUoY29uc3QgY2hhciogZG9tYWluLCBjb25zdCBib29sIGlzQWxsb3dlZCkKIHsKLSAg ICBub3RJbXBsZW1lbnRlZCgpOworICAgIFBlcm1pc3Npb25zTWFwOjppdGVyYXRvciBpdGVyID0g bV9jYWNoZWRQZXJtaXNzaW9ucy5maW5kKFN0cmluZyhkb21haW4pKTsKKworICAgIGlmIChpdGVy ID09IG1fY2FjaGVkUGVybWlzc2lvbnMuZW5kKCkpCisgICAgICAgIHJldHVybjsKKworICAgIG1f Y2FjaGVkUGVybWlzc2lvbnMuYWRkKFN0cmluZyhkb21haW4pLCBpc0FsbG93ZWQpOworfQorCit2 b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVybWlzc2lvbihjb25zdCBF d2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4sIGNvbnN0IGJvb2wgaXNBbGxvd2VkKQoreworICAg IFBlcm1pc3Npb25SZXF1ZXN0TWFwOjppdGVyYXRvciBpdGVyID0gbV9wZW5kaW5nUGVybWlzc2lv blJlcXVlc3RzLmZpbmQoY29uc3RfY2FzdDxFd2tfU2VjdXJpdHlfT3JpZ2luKj4ob3JpZ2luKSk7 CisKKyAgICBpZiAoaXRlciA9PSBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpCisg ICAgICAgIHJldHVybjsKKworICAgIGl0ZXItPnNlY29uZC0+aGFuZGxlRXZlbnQoTm90aWZpY2F0 aW9uOjpwZXJtaXNzaW9uU3RyaW5nKGlzQWxsb3dlZCA/IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVy bWlzc2lvbkFsbG93ZWQgOiBOb3RpZmljYXRpb25DbGllbnQ6OlBlcm1pc3Npb25EZW5pZWQpKTsK KyAgICBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMucmVtb3ZlKGl0ZXIpOworICAgIG1fY2Fj aGVkUGVybWlzc2lvbnMuYWRkKFN0cmluZyhld2tfc2VjdXJpdHlfb3JpZ2luX3N0cmluZ19nZXQo b3JpZ2luKSksIGlzQWxsb3dlZCk7CisgICAgZXdrX3NlY3VyaXR5X29yaWdpbl9mcmVlKGNvbnN0 X2Nhc3Q8RXdrX1NlY3VyaXR5X09yaWdpbio+KG9yaWdpbikpOwogfQogCiB9CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJD bGllbnRFZmwuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbC5oCmluZGV4IGVjZTVjY2ZlNGI2NWQxMzVhODE4YmQ5OWYxMjQ1 OTVlMDBhMmJmZTEuLjNmMTI5NzMzZjNlNTU5N2E5Mzc3ZjRiNzNkMDI4NmI3MzE1OGZkZjUgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0 L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oCkBAIC0yMCwyNSArMjAsNDEgQEAKICNp Zm5kZWYgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsX2gKICNkZWZpbmUgTm90aWZpY2F0 aW9uUHJlc2VudGVyQ2xpZW50RWZsX2gKIAotI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKSB8fCBF TkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCiAj aW5jbHVkZSAiTm90aWZpY2F0aW9uLmgiCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uQ2xpZW50Lmgi CisjaW5jbHVkZSAiZXdrX3NlY3VyaXR5X29yaWdpbi5oIgorI2luY2x1ZGUgPEV2YXMuaD4KKyNp bmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIE5v dGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCA6IHB1YmxpYyBOb3RpZmljYXRpb25DbGllbnQg ewotCiBwdWJsaWM6Ci0gICAgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CisgICAg Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KTsKICAgICB+ Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CiAKICAgICB2aXJ0dWFsIGJvb2wgc2hv dyhOb3RpZmljYXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsKE5vdGlmaWNhdGlvbiop OwogICAgIHZpcnR1YWwgdm9pZCBub3RpZmljYXRpb25PYmplY3REZXN0cm95ZWQoTm90aWZpY2F0 aW9uKik7CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0cm95ZWQo KTsKLSAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIFBhc3NSZWZQdHI8Vm9pZENhbGxiYWNrPik7CisjaWYgRU5BQkxFKExFR0FDWV9OT1RJ RklDQVRJT05TKQorICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVj dXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+KSB7IH0KKyNlbmRpZgorICAg IHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg UGFzc1JlZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+KTsKICAgICB2aXJ0dWFs IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbiBjaGVja1Blcm1pc3Npb24oU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCopOwotICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0c0ZvclBlcm1p c3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOworICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxS ZXF1ZXN0c0ZvclBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopIHsgfQorCisgICAg dm9pZCBhZGRUb1Blcm1pc3Npb25DYWNoZShjb25zdCBjaGFyKiBkb21haW4sIGJvb2wgaXNBbGxv d2VkKTsKKyAgICB2b2lkIHNldFBlcm1pc3Npb24oY29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbios IGJvb2wgaXNBbGxvd2VkKTsKKworcHJpdmF0ZToKKyAgICBFdmFzX09iamVjdCogbV92aWV3Owor CisgICAgdHlwZWRlZiBIYXNoTWFwPEV3a19TZWN1cml0eV9PcmlnaW4qLCBSZWZQdHI8V2ViQ29y ZTo6Tm90aWZpY2F0aW9uUGVybWlzc2lvbkNhbGxiYWNrPiA+IFBlcm1pc3Npb25SZXF1ZXN0TWFw OworICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0czsK KyAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBib29sPiBQZXJtaXNzaW9uc01hcDsKKyAgICBQ ZXJtaXNzaW9uc01hcCBtX2NhY2hlZFBlcm1pc3Npb25zOwogfTsKIAogfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3 ay9ld2tfdmlldy5jcHAKaW5kZXggZGM4YWM4OGJhZTQ4MTRkMjViZjFjNTViM2NhZTk1MWI0ZGNi YWE3Ny4uZWE4NDAyNmJmMGFlNDdmNWNhYWEwMTllN2I3MjIyNTUzMzUzOWVjNyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 L2VmbC9ld2svZXdrX3ZpZXcuY3BwCkBAIC0xMDcsNiArMTA3LDExIEBACiAjaW5jbHVkZSAiUmVn aXN0ZXJQcm90b2NvbEhhbmRsZXJDbGllbnRFZmwuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKE5P VElGSUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyNpbmNsdWRlICJO b3RpZmljYXRpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsLmgiCisjZW5kaWYKKwogc3RhdGljIGNvbnN0IGZsb2F0IHpvb21NaW5pbXVtID0g MC4wNTsKIHN0YXRpYyBjb25zdCBmbG9hdCB6b29tTWF4aW11bSA9IDQuMDsKIApAQCAtNzY1LDYg Kzc3MCwxMCBAQCBzdGF0aWMgRXdrX1ZpZXdfUHJpdmF0ZV9EYXRhKiBfZXdrX3ZpZXdfcHJpdl9u ZXcoRXdrX1ZpZXdfU21hcnRfRGF0YSogc21hcnREYXRhKQogICAgIFdlYkNvcmU6OnByb3ZpZGVS ZWdpc3RlclByb3RvY29sSGFuZGxlclRvKHByaXYtPnBhZ2UuZ2V0KCksIG5ldyBXZWJDb3JlOjpS ZWdpc3RlclByb3RvY29sSGFuZGxlckNsaWVudEVmbChzbWFydERhdGEtPnNlbGYpKTsKICNlbmRp ZgogCisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FU SU9OUykKKyAgICBXZWJDb3JlOjpwcm92aWRlTm90aWZpY2F0aW9uKHByaXYtPnBhZ2UuZ2V0KCks IG5ldyBXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoc21hcnREYXRhLT5z ZWxmKSk7CisjZW5kaWYKKwogICAgIHByaXYtPnBhZ2VTZXR0aW5ncyA9IHByaXYtPnBhZ2UtPnNl dHRpbmdzKCk7CiAKICAgICBwcml2LT52aWV3cG9ydEFyZ3VtZW50cy53aWR0aCA9IFdlYkNvcmU6 OlZpZXdwb3J0QXJndW1lbnRzOjpWYWx1ZUF1dG87CkBAIC00NTA1LDYgKzQ1MTQsMzcgQEAgdm9p ZCBld2tfdmlld19jdXJzb3Jfc2V0KEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBXZWJDb3Jl OjpDdXJzb3ImIGN1cnNvcikKICAgICB9CiB9CiAKK0VpbmFfQm9vbCBld2tfdmlld19ub3RpZmlj YXRpb25fcGVybWlzc2lvbl9jYWNoZV9hZGQoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IGNo YXIqIGRvbWFpbiwgRWluYV9Cb29sIHBlcm1pdHRlZCkKK3sKKyNpZiBFTkFCTEUoTk9USUZJQ0FU SU9OUykKKyAgICBFV0tfVklFV19TRF9HRVQoZXdrVmlldywgc21hcnREYXRhKTsKKyAgICBFV0tf VklFV19QUklWX0dFVChzbWFydERhdGEsIHByaXYpOworICAgIHN0YXRpY19jYXN0PFdlYkNvcmU6 Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCo+KFdlYkNvcmU6Ok5vdGlmaWNhdGlvbkNv bnRyb2xsZXI6OmNsaWVudEZyb20ocHJpdi0+cGFnZS5nZXQoKSkpLT5hZGRUb1Blcm1pc3Npb25D YWNoZShkb21haW4sIHBlcm1pdHRlZCk7CisgICAgcmV0dXJuIHRydWU7CisjZWxzZQorICAgIHJl dHVybiBmYWxzZTsKKyNlbmRpZgorfQorCitFaW5hX0Jvb2wgZXdrX3ZpZXdfbm90aWZpY2F0aW9u X3Blcm1pc3Npb25zX3NldChFdmFzX09iamVjdCogZXdrVmlldywgY29uc3QgRXdrX1NlY3VyaXR5 X09yaWdpbiogb3JpZ2luLCBFaW5hX0Jvb2wgcGVybWl0dGVkKQoreworI2lmIEVOQUJMRShOT1RJ RklDQVRJT05TKQorICAgIEVXS19WSUVXX1NEX0dFVChld2tWaWV3LCBzbWFydERhdGEpOworICAg IEVXS19WSUVXX1BSSVZfR0VUKHNtYXJ0RGF0YSwgcHJpdik7CisgICAgc3RhdGljX2Nhc3Q8V2Vi Q29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKj4oV2ViQ29yZTo6Tm90aWZpY2F0 aW9uQ29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2LT5wYWdlLmdldCgpKSktPnNldFBlcm1pc3Np b24ob3JpZ2luLCBwZXJtaXR0ZWQpOworICAgIHJldHVybiB0cnVlOworI2Vsc2UKKyAgICByZXR1 cm4gZmFsc2U7CisjZW5kaWYKK30KKworI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQordm9pZCBl d2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNfT2JqZWN0KiBld2tW aWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4pCit7CisgICAgZXZhc19vYmpl Y3Rfc21hcnRfY2FsbGJhY2tfY2FsbChld2tWaWV3LCAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24s cmVxdWVzdCIsIGNvbnN0X2Nhc3Q8RXdrX1NlY3VyaXR5X09yaWdpbio+KG9yaWdpbikpOworfQor I2VuZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRlIHsKIAogV2ViQ29yZTo6UGFnZSogY29yZVBh Z2UoY29uc3QgRXZhc19PYmplY3QqIGV3a1ZpZXcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2VmbC9ld2svZXdrX3ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCmlu ZGV4IDU1ZWQzZWU4NjgxZWYwYzExNWQ4ZjA4M2UyNDhlODU0YjJjMDBmZTYuLjg0ODI4NTYyNzBh YmNkOTVhMDM0MWVlNGIxYzkyNTc5ZTI0ZTdiMDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv ZWZsL2V3ay9ld2tfdmlldy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5o CkBAIC03NCw2ICs3NCw3IEBACiAgKiAgLSAibWl4ZWRjb250ZW50LGRpc3BsYXllZCIsIHZvaWQ6 IGFueSBvZiB0aGUgY29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgZGlzcGxheWVkIG1p eGVkIGNvbnRlbnQuCiAgKiAgLSAibWl4ZWRjb250ZW50LHJ1biIsIHZvaWQ6IGFueSBvZiB0aGUg Y29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgcnVuIG1peGVkIGNvbnRlbnQuCiAgKiAg LSAibmF2aWdhdGUsd2l0aCxkYXRhIiwgRXdrX1ZpZXdfTmF2aWdhdGlvbl9EYXRhKjogcmVwb3J0 cyB0aGF0IHZpZXcgZGlkIG5hdmlnYXRpb24gYW5kIGdpdmVzIHRoZSBuYXZpZ2F0aW9uIGRldGFp bHMuCisgKiAgLSAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24scmVxdWVzdCIsIGNvbnN0IEV3a19T ZWN1cml0eV9PcmlnaW4qOiByZXF1ZXN0IHRvIGNvbmZpcm0gcGVybWlzc2lvbiBmb3Igc2VjdXJp dHkgb3JpZ2luIGZyb20gdXNlci4KICAqICAtICJwZXJmb3JtLGNsaWVudCxyZWRpcmVjdCIsIEV3 a19WaWV3X1JlZGlyZWN0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBwZXJmb3JtZWQgYSBj bGllbnQgcmVkaXJlY3QgYW5kIGdpdmVzIHRoZSByZWRpcmVjdGlvbiBkZXRhaWxzLgogICogIC0g InBlcmZvcm0sc2VydmVyLHJlZGlyZWN0IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0YSo6IHJl cG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIHNlcnZlciByZWRpcmVjdCBhbmQgZ2l2ZXMgdGhl IHJlZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAicHJvdG9jb2xoYW5kbGVyLHJlZ2lzdHJhdGlv bixyZXF1ZXN0ZWQiLCBFd2tfQ3VzdG9tX0hhbmRsZXJfRGF0YTogYWRkIGEgaGFuZGxlciB1cmwg Zm9yIHRoZSBnaXZlbiBwcm90b2NvbC4KQEAgLTI2OTMsNiArMjY5NCwzMyBAQCBFQVBJIEV2YXNf T2JqZWN0KiBld2tfdmlld193ZWJfaW5zcGVjdG9yX3ZpZXdfZ2V0KGNvbnN0IEV2YXNfT2JqZWN0 ICpvKTsKICAqLwogRUFQSSB2b2lkIGV3a192aWV3X3dlYl9pbnNwZWN0b3Jfdmlld19zZXQoRXZh c19PYmplY3QgKm8sIEV2YXNfT2JqZWN0ICppbnNwZWN0b3Jfdmlldyk7CiAKKy8qKgorICogQWRk IHBlcm1pdHRlZCBvciBkZW5pZWQgbGlzdCB0byB0aGUgcGVybWlzc2lvbiBjYWNoZSBmb3IgV2Vi IE5vdGlmaWNhaXRvbnMuCisgKgorICogSWYgdGhlcmUgYXJlIHN0b3JlZCBwZXJtaXNzaW9uIGxp c3RzIGZvciBXZWIgTm90aWZpY2F0aW9ucywKKyAqIHRoaXMgZnVuY3Rpb24gbmVlZCB0byBiZSBj YWxsZWQgd2l0aCBwZXJtaXNzaW9uLgorICoKKyAqIEBwYXJhbSBvIHZpZXcgb2JqZWN0IHRvIHNl dCB0aGUgcGVybWlzc2lvbiBjYWNoZSBsaXN0LgorICogQHBhcmFtIGRvbWFpbiBzdHJpbmcgZm9y IGRldGVybWluZSB0aGUgcGVybWlzc2lvbi4KKyAqIEBwYXJhbSBwZXJtaXR0ZWQgQGMgRUlOQV9U UlVFIHRvIHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0byBkZW55LgorICoKKyAqIEByZXR1cm4gQGMg RUlOQV9UUlVFIG9uIHN1Y2Nlc3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWlsdXJlCisgKi8KK0Vp bmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9jYWNoZV9hZGQoRXZhc19P YmplY3QgKm8sIGNvbnN0IGNoYXIgKmRvbWFpbiwgRWluYV9Cb29sIHBlcm1pdHRlZCk7CisKKy8q KgorICogU2V0IHBlcm1pdHRlZCBvciBkZW5pZWQgbGlzdHMgdG8gdGhlIHBlcm1pc3Npb24gY2Fj aGUgZm9yIHRoZSBXZWIgTm90aWZpY2FpdG9ucy4KKyAqCisgKiBBZnRlciBjaGVja2luZyBwZXJt aXNzaW9uLCB0aGlzIGZ1bmN0aW9uIGhhdmUgdG8gYmUgY2FsbGVkIHRvIHNldCBwZXJtaXNzaW9u LgorICoKKyAqIEBwYXJhbSBvIHZpZXcgb2JqZWN0IHRvIHNldCB0aGUgcGVybWlzc2lvbi4KKyAq IEBwYXJhbSBvcmlnaW4gc2VjdXJpdHkgb3JpZ2luIG9iamVjdAorICogQHBhcmFtIGFsbG93IEBj IEVJTkFfVFJVRSB0byBwZXJtaXQsIEBjIEVJTkFfRkFMU0UgdG8gZGVueS4KKyAqCisgKiBAcmV0 dXJuIEBjIEVJTkFfVFJVRSBvbiBzdWNjZXNzIG9yIEBjIEVJTkFfRkFMU0Ugb24gZmFpbHVyZQor ICovCitFQVBJIEVpbmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc2V0 KEV2YXNfT2JqZWN0ICpvLCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luICpvcmlnaW4sIEVpbmFf Qm9vbCBwZXJtaXR0ZWQpOworCiAjaWZkZWYgX19jcGx1c3BsdXMKIH0KICNlbmRpZgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaCBiL1NvdXJjZS9X ZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgKaW5kZXggYjcwZTc1NWIxNjA5M2E1M2Nl NmNkMzc4ZTM2M2RjNjkyM2RmMWQ4OS4uZjQ5MjZkYmIzZWVjNWU1MDYyMzMxM2ZmMzI0ZmQyMGI0 YzBmZjU0NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZh dGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5oCkBAIC0x NTYsNiArMTU2LDEwIEBAIGJvb2wgZXdrX3ZpZXdfYWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfb2Jq ZWN0X2NyZWF0ZShFdmFzX09iamVjdCogZXdrVmlldywgRXZhc19OCiBXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHQzRCogZXdrX3ZpZXdfYWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfY29udGV4dF9nZXQo RXZhc19PYmplY3QqIGV3a1ZpZXcpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9O UykKK3ZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fcmVxdWVzdChFdmFzX09i amVjdCogZXdrVmlldywgY29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbiogb3JpZ2luKTsKKyNlbmRp ZgorCiBuYW1lc3BhY2UgRVdLUHJpdmF0ZSB7CiBXZWJDb3JlOjpQYWdlICpjb3JlUGFnZShjb25z dCBFdmFzX09iamVjdCAqZXdrVmlldyk7CiBQbGF0Zm9ybVBhZ2VDbGllbnQgY29yZVBhZ2VDbGll bnQoRXZhc19PYmplY3QqIGV3a1ZpZXcpOwo= 160621 2012-08-26 19:42:57 -0700 2012-09-05 20:18:58 -0700 Patch bug-90603-20120827114250.patch text/plain 12935 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTI2Njc1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggY2M2NTU3MzVi MmJmMTJiNzE3ODZjODY1MGQ1YzYxOWE2YWNlNDZjYy4uYWUzNWQ0ZmFmNDhiNjU4ZmQyY2ExMmNm ZDc4MWMxYTg4YjI0OWFmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEy LTA4LTI2ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z LgorICAgICAgICBjaGVja1Blcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uTGV2 ZWwoKS4KKyAgICAgICAgcmVxdWVzdFBlcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5yZXF1ZXN0 UGVybWlzc2lvbigpLgorICAgICAgICBJbiBhZGRpdGlvbiwgaWYgdGhlIGFwcGxpY2F0aW9uKGxp a2UgYSBicm93c2VyKSBoYXMgcGVybWl0dGVkIGRvbWFpbnMgYWxyZWFkeSwKKyAgICAgICAgaXQg Y2FuIGJlIGNhY2hlZCB1c2luZyBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfY2Fj aGVfYWRkLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbDo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKToKKyAgICAgICAgKFdlYkNv cmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24pOgor ICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpjaGVja1Bl cm1pc3Npb24pOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsOjphZGRUb1Blcm1pc3Npb25DYWNoZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAg KFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVybWlzc2lvbik6 CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZs Lmg6CisgICAgICAgIChOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwpOgorICAgICAgICAo V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpyZXF1ZXN0UGVybWlzc2lv bik6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNh bmNlbFJlcXVlc3RzRm9yUGVybWlzc2lvbik6CisgICAgICAgICogZXdrL2V3a192aWV3LmNwcDoK KyAgICAgICAgKF9ld2tfdmlld19wcml2X25ldyk6CisgICAgICAgIChld2tfdmlld19ub3RpZmlj YXRpb25fcGVybWlzc2lvbl9jYWNoZV9hZGQpOgorICAgICAgICAoZXdrX3ZpZXdfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25zX3NldCk6CisgICAgICAgIChld2tfdmlld19ub3RpZmljYXRpb25fcGVy bWlzc2lvbl9yZXF1ZXN0KToKKyAgICAgICAgKiBld2svZXdrX3ZpZXcuaDoKKyAgICAgICAgKiBl d2svZXdrX3ZpZXdfcHJpdmF0ZS5oOgorCiAyMDEyLTA4LTIzICBSeXVhbiBDaG9pICA8cnl1YW4u Y2hvaUBzYW1zdW5nLmNvbT4KIAogICAgICAgICBbRUZMXSBSZW1vdmUgZXdrX3RpbGVfbWF0cml4 X3RpbGVfdXBkYXRlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBv cnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmNwcCBiL1NvdXJjZS9XZWJLaXQvZWZs L1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHAKaW5kZXgg YzRlNWNhOGRhNDhhNzFhY2EyNDdlODgzMzE2NGMwY2JiOTdjNGQ1ZC4uY2MxY2FjZjRkYjExNjc3 YzhkNTg2M2QzMDgzMmRlYjlhNzhiYzk0YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwv V2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmNwcAorKysgYi9T b3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuY3BwCkBAIC0yMCwxMiArMjAsMTcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNs dWRlICJOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaCIKIAotI2lmIEVOQUJMRShOT1RJ RklDQVRJT05TKSB8fCBFTkFCTEUoTEVHQUNZX05PVElGSUNBVElPTlMpCisjaWYgRU5BQkxFKE5P VElGSUNBVElPTlMpCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKKyNpbmNsdWRlICJTY3Jp cHRFeGVjdXRpb25Db250ZXh0LmgiCisjaW5jbHVkZSAiU2VjdXJpdHlPcmlnaW4uaCIKKyNpbmNs dWRlICJld2tfc2VjdXJpdHlfb3JpZ2luX3ByaXZhdGUuaCIKKyNpbmNsdWRlICJld2tfdmlld19w cml2YXRlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKQorTm90aWZpY2F0aW9u UHJlc2VudGVyQ2xpZW50RWZsOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoRXZhc19P YmplY3QqIHZpZXcpCisgICAgOiBtX3ZpZXcodmlldykKIHsKIH0KIApAQCAtNTQsMjAgKzU5LDQy IEBAIHZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpub3RpZmljYXRpb25Db250 cm9sbGVyRGVzdHJveWVkKCkKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIE5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+IGNhbGxiYWNrKQor dm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNzaW9uKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8Tm90aWZpY2F0aW9uUGVy bWlzc2lvbkNhbGxiYWNrPiBjYWxsYmFjaykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAg IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiA9IGV3a19zZWN1cml0eV9vcmlnaW5fbmV3KGNv bnRleHQtPnNlY3VyaXR5T3JpZ2luKCkpOworICAgIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0 cy5hZGQob3JpZ2luLCBjYWxsYmFjayk7CisgICAgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1p c3Npb25fcmVxdWVzdChtX3ZpZXcsIG9yaWdpbik7CiB9CiAKIE5vdGlmaWNhdGlvbkNsaWVudDo6 UGVybWlzc2lvbiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNoZWNrUGVybWlzc2lv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Np b25zLmZpbmQoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSk7CisgICAgaWYg KGl0ZXIgPT0gbV9jYWNoZWRQZXJtaXNzaW9ucy5lbmQoKSkKKyAgICAgICAgcmV0dXJuIFBlcm1p c3Npb25Ob3RBbGxvd2VkOworICAgIGlmIChpdGVyLT5zZWNvbmQpCisgICAgICAgIHJldHVybiBQ ZXJtaXNzaW9uQWxsb3dlZDsKKwogICAgIHJldHVybiBQZXJtaXNzaW9uRGVuaWVkOwogfQogCi12 b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJt aXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCit2b2lkIE5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6YWRkVG9QZXJtaXNzaW9uQ2FjaGUoY29uc3QgU3RyaW5nIGRv bWFpbiwgY29uc3QgYm9vbCBpc0FsbG93ZWQpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAg ICBQZXJtaXNzaW9uc01hcDo6aXRlcmF0b3IgaXRlciA9IG1fY2FjaGVkUGVybWlzc2lvbnMuZmlu ZChkb21haW4pOworICAgIGlmIChpdGVyID09IG1fY2FjaGVkUGVybWlzc2lvbnMuZW5kKCkpCisg ICAgICAgIHJldHVybjsKKyAgICBtX2NhY2hlZFBlcm1pc3Npb25zLmFkZChkb21haW4sIGlzQWxs b3dlZCk7Cit9CisKK3ZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpzZXRQZXJt aXNzaW9uKGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiwgY29uc3QgYm9vbCBpc0Fs bG93ZWQpCit7CisgICAgUGVybWlzc2lvblJlcXVlc3RNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX3Bl bmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZmluZChjb25zdF9jYXN0PEV3a19TZWN1cml0eV9Pcmln aW4qPihvcmlnaW4pKTsKKyAgICBpZiAoaXRlciA9PSBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVz dHMuZW5kKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGl0ZXItPnNlY29uZC0+aGFuZGxlRXZl bnQoTm90aWZpY2F0aW9uOjpwZXJtaXNzaW9uU3RyaW5nKGlzQWxsb3dlZCA/IE5vdGlmaWNhdGlv bkNsaWVudDo6UGVybWlzc2lvbkFsbG93ZWQgOiBOb3RpZmljYXRpb25DbGllbnQ6OlBlcm1pc3Np b25EZW5pZWQpKTsKKyAgICBtX3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMucmVtb3ZlKGl0ZXIp OworICAgIG1fY2FjaGVkUGVybWlzc2lvbnMuYWRkKFN0cmluZzo6ZnJvbVVURjgoZXdrX3NlY3Vy aXR5X29yaWdpbl9zdHJpbmdfZ2V0KG9yaWdpbikpLCBpc0FsbG93ZWQpOworICAgIGV3a19zZWN1 cml0eV9vcmlnaW5fZnJlZShjb25zdF9jYXN0PEV3a19TZWN1cml0eV9PcmlnaW4qPihvcmlnaW4p KTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQv Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmggYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJD b3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaAppbmRleCBlY2U1Y2Nm ZTRiNjVkMTM1YTgxOGJkOTlmMTI0NTk1ZTAwYTJiZmUxLi45ODM2ZWU5OGM5ZGE4MDNmOGQ4YWQ0 NGI2Y2U2ZTM1NmIzMTUyNzlhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3Jl U3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaApA QCAtMjAsMjUgKzIwLDQxIEBACiAjaWZuZGVmIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVm bF9oCiAjZGVmaW5lIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbF9oCiAKLSNpZiBFTkFC TEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQorI2lmIEVO QUJMRShOT1RJRklDQVRJT05TKQogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbi5oIgogI2luY2x1ZGUg Ik5vdGlmaWNhdGlvbkNsaWVudC5oIgorI2luY2x1ZGUgImV3a19zZWN1cml0eV9vcmlnaW4uaCIK KyNpbmNsdWRlIDxFdmFzLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCiBjbGFzcyBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwgOiBwdWJs aWMgTm90aWZpY2F0aW9uQ2xpZW50IHsKLQogcHVibGljOgotICAgIE5vdGlmaWNhdGlvblByZXNl bnRlckNsaWVudEVmbCgpOworICAgIGV4cGxpY2l0IE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbChFdmFzX09iamVjdCogdmlldyk7CiAgICAgfk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbCgpOwogCiAgICAgdmlydHVhbCBib29sIHNob3coTm90aWZpY2F0aW9uKik7CiAgICAgdmly dHVhbCB2b2lkIGNhbmNlbChOb3RpZmljYXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgbm90aWZp Y2F0aW9uT2JqZWN0RGVzdHJveWVkKE5vdGlmaWNhdGlvbiopOwogICAgIHZpcnR1YWwgdm9pZCBu b3RpZmljYXRpb25Db250cm9sbGVyRGVzdHJveWVkKCk7Ci0gICAgdmlydHVhbCB2b2lkIHJlcXVl c3RQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFZvaWRDYWxs YmFjaz4pOworI2lmIEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyAgICB2aXJ0dWFsIHZv aWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8 Vm9pZENhbGxiYWNrPikgeyB9CisjZW5kaWYKKyAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1p c3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8Tm90aWZpY2F0aW9uUGVy bWlzc2lvbkNhbGxiYWNrPik7CiAgICAgdmlydHVhbCBOb3RpZmljYXRpb25DbGllbnQ6OlBlcm1p c3Npb24gY2hlY2tQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqKTsKLSAgICB2aXJ0 dWFsIHZvaWQgY2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQqKTsKKyAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQqKSB7IH0KKworICAgIHZvaWQgYWRkVG9QZXJtaXNzaW9uQ2FjaGUo U3RyaW5nIGRvbWFpbiwgYm9vbCBpc0FsbG93ZWQpOworICAgIHZvaWQgc2V0UGVybWlzc2lvbihj b25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiwgYm9vbCBpc0FsbG93ZWQpOworCitwcml2YXRlOgor ICAgIEV2YXNfT2JqZWN0KiBtX3ZpZXc7CisKKyAgICB0eXBlZGVmIEhhc2hNYXA8RXdrX1NlY3Vy aXR5X09yaWdpbiosIFJlZlB0cjxXZWJDb3JlOjpOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJh Y2s+ID4gUGVybWlzc2lvblJlcXVlc3RNYXA7CisgICAgUGVybWlzc2lvblJlcXVlc3RNYXAgbV9w ZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzOworICAgIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIGJv b2w+IFBlcm1pc3Npb25zTWFwOworICAgIFBlcm1pc3Npb25zTWFwIG1fY2FjaGVkUGVybWlzc2lv bnM7CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcu Y3BwIGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcAppbmRleCA0MGZiZmFkNmFk MTc0NjA4YWYzNDZjNjEyZjUzYzlmNGVjM2YzYjU3Li5kOTkyNDliNjgwMTk0NGMwNTg5NzRmZWNj YjdjM2QwODE3MGQ4ZTEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3Zp ZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKQEAgLTEwNyw2 ICsxMDcsMTEgQEAKICNpbmNsdWRlICJSZWdpc3RlclByb3RvY29sSGFuZGxlckNsaWVudEVmbC5o IgogI2VuZGlmCiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKKyNpbmNsdWRlICJOb3RpZmlj YXRpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsLmgiCisjZW5kaWYKKwogc3RhdGljIGNvbnN0IGZsb2F0IHpvb21NaW5pbXVtID0gMC4wNTsK IHN0YXRpYyBjb25zdCBmbG9hdCB6b29tTWF4aW11bSA9IDQuMDsKIApAQCAtNzY5LDYgKzc3NCwx MCBAQCBzdGF0aWMgRXdrX1ZpZXdfUHJpdmF0ZV9EYXRhKiBfZXdrX3ZpZXdfcHJpdl9uZXcoRXdr X1ZpZXdfU21hcnRfRGF0YSogc21hcnREYXRhKQogICAgIFdlYkNvcmU6OnByb3ZpZGVSZWdpc3Rl clByb3RvY29sSGFuZGxlclRvKHByaXYtPnBhZ2UuZ2V0KCksIHByaXYtPnJlZ2lzdGVyUHJvdG9j b2xIYW5kbGVyQ2xpZW50LmdldCgpKTsKICNlbmRpZgogCisjaWYgRU5BQkxFKE5PVElGSUNBVElP TlMpCisgICAgV2ViQ29yZTo6cHJvdmlkZU5vdGlmaWNhdGlvbihwcml2LT5wYWdlLmdldCgpLCBu ZXcgV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKHNtYXJ0RGF0YS0+c2Vs ZikpOworI2VuZGlmCisKICAgICBwcml2LT5wYWdlU2V0dGluZ3MgPSBwcml2LT5wYWdlLT5zZXR0 aW5ncygpOwogCiAgICAgcHJpdi0+dmlld3BvcnRBcmd1bWVudHMud2lkdGggPSBXZWJDb3JlOjpW aWV3cG9ydEFyZ3VtZW50czo6VmFsdWVBdXRvOwpAQCAtNDUwNCw2ICs0NTEzLDM3IEBAIHZvaWQg ZXdrX3ZpZXdfY3Vyc29yX3NldChFdmFzX09iamVjdCogZXdrVmlldywgY29uc3QgV2ViQ29yZTo6 Q3Vyc29yJiBjdXJzb3IpCiAgICAgfQogfQogCitFaW5hX0Jvb2wgZXdrX3ZpZXdfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25fY2FjaGVfYWRkKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBjaGFy KiBkb21haW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQpCit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElP TlMpCisgICAgRVdLX1ZJRVdfU0RfR0VUX09SX1JFVFVSTihld2tWaWV3LCBzbWFydERhdGEsIGZh bHNlKTsKKyAgICBFV0tfVklFV19QUklWX0dFVF9PUl9SRVRVUk4oc21hcnREYXRhLCBwcml2LCBm YWxzZSk7CisgICAgc3RhdGljX2Nhc3Q8V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xp ZW50RWZsKj4oV2ViQ29yZTo6Tm90aWZpY2F0aW9uQ29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2 LT5wYWdlLmdldCgpKSktPmFkZFRvUGVybWlzc2lvbkNhY2hlKFN0cmluZzo6ZnJvbVVURjgoZG9t YWluKSwgcGVybWl0dGVkKTsKKyAgICByZXR1cm4gdHJ1ZTsKKyNlbHNlCisgICAgcmV0dXJuIGZh bHNlOworI2VuZGlmCit9CisKK0VpbmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlz c2lvbnNfc2V0KEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2lu KiBvcmlnaW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQpCit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElP TlMpCisgICAgRVdLX1ZJRVdfU0RfR0VUX09SX1JFVFVSTihld2tWaWV3LCBzbWFydERhdGEsIGZh bHNlKTsKKyAgICBFV0tfVklFV19QUklWX0dFVF9PUl9SRVRVUk4oc21hcnREYXRhLCBwcml2LCBm YWxzZSk7CisgICAgc3RhdGljX2Nhc3Q8V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xp ZW50RWZsKj4oV2ViQ29yZTo6Tm90aWZpY2F0aW9uQ29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2 LT5wYWdlLmdldCgpKSktPnNldFBlcm1pc3Npb24ob3JpZ2luLCBwZXJtaXR0ZWQpOworICAgIHJl dHVybiB0cnVlOworI2Vsc2UKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKworI2lmIEVO QUJMRShOT1RJRklDQVRJT05TKQordm9pZCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lv bl9yZXF1ZXN0KEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2lu KiBvcmlnaW4pCit7CisgICAgZXZhc19vYmplY3Rfc21hcnRfY2FsbGJhY2tfY2FsbChld2tWaWV3 LCAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24scmVxdWVzdCIsIGNvbnN0X2Nhc3Q8RXdrX1NlY3Vy aXR5X09yaWdpbio+KG9yaWdpbikpOworfQorI2VuZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRl IHsKIAogV2ViQ29yZTo6UGFnZSogY29yZVBhZ2UoY29uc3QgRXZhc19PYmplY3QqIGV3a1ZpZXcp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuaCBiL1NvdXJjZS9X ZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCmluZGV4IGE1NzBkNjU1ZTliNTIwM2U0YWNjMzk5MGQy MDViNGNhNWU4MmMzYTQuLmFjYTM3NDY3ZGY3ODMyZjE5MTMwNmJlZTM1NjZmODk0ZWIxMDc4Y2Ug MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCisrKyBiL1NvdXJj ZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCkBAIC03NCw2ICs3NCw3IEBACiAgKiAgLSAibWl4 ZWRjb250ZW50LGRpc3BsYXllZCIsIHZvaWQ6IGFueSBvZiB0aGUgY29udGFpbmluZyBmcmFtZXMg aGFzIGxvYWRlZCBhbmQgZGlzcGxheWVkIG1peGVkIGNvbnRlbnQuCiAgKiAgLSAibWl4ZWRjb250 ZW50LHJ1biIsIHZvaWQ6IGFueSBvZiB0aGUgY29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBh bmQgcnVuIG1peGVkIGNvbnRlbnQuCiAgKiAgLSAibmF2aWdhdGUsd2l0aCxkYXRhIiwgRXdrX1Zp ZXdfTmF2aWdhdGlvbl9EYXRhKjogcmVwb3J0cyB0aGF0IHZpZXcgZGlkIG5hdmlnYXRpb24gYW5k IGdpdmVzIHRoZSBuYXZpZ2F0aW9uIGRldGFpbHMuCisgKiAgLSAibm90aWZpY2F0aW9uLHBlcm1p c3Npb24scmVxdWVzdCIsIGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qOiByZXF1ZXN0IHRvIGNv bmZpcm0gcGVybWlzc2lvbiBmb3Igc2VjdXJpdHkgb3JpZ2luIGZyb20gdXNlci4KICAqICAtICJw ZXJmb3JtLGNsaWVudCxyZWRpcmVjdCIsIEV3a19WaWV3X1JlZGlyZWN0aW9uX0RhdGEqOiByZXBv cnRzIHRoYXQgdmlldyBwZXJmb3JtZWQgYSBjbGllbnQgcmVkaXJlY3QgYW5kIGdpdmVzIHRoZSBy ZWRpcmVjdGlvbiBkZXRhaWxzLgogICogIC0gInBlcmZvcm0sc2VydmVyLHJlZGlyZWN0IiwgRXdr X1ZpZXdfUmVkaXJlY3Rpb25fRGF0YSo6IHJlcG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIHNl cnZlciByZWRpcmVjdCBhbmQgZ2l2ZXMgdGhlIHJlZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAi cHJvdG9jb2xoYW5kbGVyLHJlZ2lzdHJhdGlvbixyZXF1ZXN0ZWQiLCBFd2tfQ3VzdG9tX0hhbmRs ZXJfRGF0YTogYWRkIGEgaGFuZGxlciB1cmwgZm9yIHRoZSBnaXZlbiBwcm90b2NvbC4KQEAgLTI2 OTQsNiArMjY5NSwzMyBAQCBFQVBJIEV2YXNfT2JqZWN0KiBld2tfdmlld193ZWJfaW5zcGVjdG9y X3ZpZXdfZ2V0KGNvbnN0IEV2YXNfT2JqZWN0ICpvKTsKICAqLwogRUFQSSB2b2lkIGV3a192aWV3 X3dlYl9pbnNwZWN0b3Jfdmlld19zZXQoRXZhc19PYmplY3QgKm8sIEV2YXNfT2JqZWN0ICppbnNw ZWN0b3Jfdmlldyk7CiAKKy8qKgorICogQWRkIHBlcm1pdHRlZCBvciBkZW5pZWQgbGlzdCB0byB0 aGUgcGVybWlzc2lvbiBjYWNoZSBmb3IgV2ViIE5vdGlmaWNhaXRvbnMuCisgKgorICogSWYgdGhl cmUgYXJlIHN0b3JlZCBwZXJtaXNzaW9uIGxpc3RzIGZvciBXZWIgTm90aWZpY2F0aW9ucywKKyAq IHRoaXMgZnVuY3Rpb24gbmVlZCB0byBiZSBjYWxsZWQgd2l0aCBwZXJtaXNzaW9uLgorICoKKyAq IEBwYXJhbSBvIHZpZXcgb2JqZWN0IHRvIHNldCB0aGUgcGVybWlzc2lvbiBjYWNoZSBsaXN0Lgor ICogQHBhcmFtIGRvbWFpbiBzdHJpbmcgZm9yIGRldGVybWluZSB0aGUgcGVybWlzc2lvbi4KKyAq IEBwYXJhbSBwZXJtaXR0ZWQgQGMgRUlOQV9UUlVFIHRvIHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0 byBkZW55LgorICoKKyAqIEByZXR1cm4gQGMgRUlOQV9UUlVFIG9uIHN1Y2Nlc3Mgb3IgQGMgRUlO QV9GQUxTRSBvbiBmYWlsdXJlCisgKi8KK0VpbmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25f cGVybWlzc2lvbl9jYWNoZV9hZGQoRXZhc19PYmplY3QgKm8sIGNvbnN0IGNoYXIgKmRvbWFpbiwg RWluYV9Cb29sIHBlcm1pdHRlZCk7CisKKy8qKgorICogU2V0IHBlcm1pdHRlZCBvciBkZW5pZWQg bGlzdHMgdG8gdGhlIHBlcm1pc3Npb24gY2FjaGUgZm9yIHRoZSBXZWIgTm90aWZpY2FpdG9ucy4K KyAqCisgKiBBZnRlciBjaGVja2luZyBwZXJtaXNzaW9uLCB0aGlzIGZ1bmN0aW9uIGhhdmUgdG8g YmUgY2FsbGVkIHRvIHNldCBwZXJtaXNzaW9uLgorICoKKyAqIEBwYXJhbSBvIHZpZXcgb2JqZWN0 IHRvIHNldCB0aGUgcGVybWlzc2lvbi4KKyAqIEBwYXJhbSBvcmlnaW4gc2VjdXJpdHkgb3JpZ2lu IG9iamVjdAorICogQHBhcmFtIGFsbG93IEBjIEVJTkFfVFJVRSB0byBwZXJtaXQsIEBjIEVJTkFf RkFMU0UgdG8gZGVueS4KKyAqCisgKiBAcmV0dXJuIEBjIEVJTkFfVFJVRSBvbiBzdWNjZXNzIG9y IEBjIEVJTkFfRkFMU0Ugb24gZmFpbHVyZQorICovCitFQVBJIEVpbmFfQm9vbCBld2tfdmlld19u b3RpZmljYXRpb25fcGVybWlzc2lvbnNfc2V0KEV2YXNfT2JqZWN0ICpvLCBjb25zdCBFd2tfU2Vj dXJpdHlfT3JpZ2luICpvcmlnaW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQpOworCiAjaWZkZWYgX19j cGx1c3BsdXMKIH0KICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3 a192aWV3X3ByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRl LmgKaW5kZXggZGFlZTY3NzM0N2Y3ZGUyZmYyNjM0YWFjYTMxMGEyMWZiYWZmM2QxNi4uYWYyZjlk NTk5N2YzNWNkMDFiOGI1ZGFmZmU3N2QxM2E2YjgxYTJmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9l d2svZXdrX3ZpZXdfcHJpdmF0ZS5oCkBAIC0xNTYsNiArMTU2LDEwIEBAIGJvb2wgZXdrX3ZpZXdf YWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfb2JqZWN0X2NyZWF0ZShFdmFzX09iamVjdCogZXdrVmll dywgRXZhc19OCiBXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRCogZXdrX3ZpZXdfYWNjZWxlcmF0 ZWRfY29tcG9zaXRpbmdfY29udGV4dF9nZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcpOwogI2VuZGlm CiAKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKK3ZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0aW9u X3Blcm1pc3Npb25fcmVxdWVzdChFdmFzX09iamVjdCogZXdrVmlldywgY29uc3QgRXdrX1NlY3Vy aXR5X09yaWdpbiogb3JpZ2luKTsKKyNlbmRpZgorCiBuYW1lc3BhY2UgRVdLUHJpdmF0ZSB7CiBX ZWJDb3JlOjpQYWdlICpjb3JlUGFnZShjb25zdCBFdmFzX09iamVjdCAqZXdrVmlldyk7CiBQbGF0 Zm9ybVBhZ2VDbGllbnQgY29yZVBhZ2VDbGllbnQoRXZhc19PYmplY3QqIGV3a1ZpZXcpOwo= 162401 2012-09-05 20:18:58 -0700 2012-09-05 21:47:00 -0700 Patch notification.patch text/plain 12702 kihong.kwon ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQv ZWZsL0NoYW5nZUxvZwppbmRleCBiN2Y4YjE1Li44MTAxYTk5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L2VmbC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMzUgQEAKKzIwMTItMDktMDUgIEtpaG9uZyBLd29uICA8a2lob25nLmt3b25Ac2Ft c3VuZy5jb20+CisKKyAgICAgICAgW0VGTF0gU3VwcG9ydCB0aGUgcGVybWlzc2lvbiBmdW5jdGlv biBvZiB0aGUgV2ViIE5vdGlmaWNhdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTkwNjAzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgSW1wbGVtZW50IHBlcm1pc3Npb24gcmVsYXRlZCBmdW5jdGlvbnMg b2YgV2ViIE5vdGlmaWNhdGlvbnMuCisgICAgICAgIGNoZWNrUGVybWlzc2lvbiBmb3IgTm90aWZp Y2F0aW9uLnBlcm1pc3Npb25MZXZlbCgpLgorICAgICAgICByZXF1ZXN0UGVybWlzc2lvbiBmb3Ig Tm90aWZpY2F0aW9uLnJlcXVlc3RQZXJtaXNzaW9uKCkuCisgICAgICAgIEluIGFkZGl0aW9uLCBp ZiB0aGUgYXBwbGljYXRpb24obGlrZSBhIGJyb3dzZXIpIGhhcyBwZXJtaXR0ZWQgZG9tYWlucyBh bHJlYWR5LAorICAgICAgICBpdCBjYW4gYmUgY2FjaGVkIHVzaW5nIGV3a192aWV3X25vdGlmaWNh dGlvbl9wZXJtaXNzaW9uc19zdG9yZS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L05vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmlj YXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCk6 CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVl c3RQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbDo6Y2hlY2tQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6YWRkVG9QZXJtaXNzaW9uQ2FjaGUpOgorICAgICAgICAoV2Vi Q29yZSk6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6 OnNldFBlcm1pc3Npb24pOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbC5oOgorICAgICAgICAoTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2Vu dGVyQ2xpZW50RWZsOjpjYW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24pOgorICAgICAgICAqIGV3 ay9ld2tfdmlldy5jcHA6CisgICAgICAgIChfZXdrX3ZpZXdfcHJpdl9uZXcpOgorICAgICAgICAo ZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fY2FjaGVfYWRkKToKKyAgICAgICAgKGV3 a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQpOgorICAgICAgICAoZXdrX3ZpZXdf bm90aWZpY2F0aW9uX3Blcm1pc3Npb25fcmVxdWVzdCk6CisgICAgICAgICogZXdrL2V3a192aWV3 Lmg6CisgICAgICAgICogZXdrL2V3a192aWV3X3ByaXZhdGUuaDoKKwogMjAxMi0wOS0wNSAgS2Fu Z2lsIEhhbiAgPGthbmdpbC5oYW5Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gUmVtb3Zl ICcrPScgdXNhZ2UgaW4gU3RyaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJD b3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwIGIvU291cmNlL1dl YktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmNw cAppbmRleCBjNGU1Y2E4Li4zYTY3ZWRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9X ZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbC5jcHAKQEAgLTIwLDEzICsyMCwyMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oIgogCi0jaWYgRU5BQkxFKE5PVElG SUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyNpZiBFTkFCTEUoTk9U SUZJQ0FUSU9OUykKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgorI2luY2x1ZGUgIk5vdGlm aWNhdGlvbi5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRl ICJTZWN1cml0eU9yaWdpbi5oIgorI2luY2x1ZGUgImV3a19zZWN1cml0eV9vcmlnaW5fcHJpdmF0 ZS5oIgorI2luY2x1ZGUgImV3a192aWV3X3ByaXZhdGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCi1Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbCgpCitOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbChFdmFzX09iamVjdCogdmlldykKKyAgICA6IG1fdmlldyh2aWV3 KQogeworICAgIEFTU0VSVChtX3ZpZXcpOwogfQogCiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmw6On5Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKQpAQCAtNTQsMjAgKzYxLDQy IEBAIHZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpub3RpZmljYXRpb25Db250 cm9sbGVyRGVzdHJveWVkKCkKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIE5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+IGNhbGxiYWNrKQor dm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNzaW9uKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8Tm90aWZpY2F0aW9uUGVy bWlzc2lvbkNhbGxiYWNrPiBjYWxsYmFjaykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAg IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiA9IGV3a19zZWN1cml0eV9vcmlnaW5fbmV3KGNv bnRleHQtPnNlY3VyaXR5T3JpZ2luKCkpOworICAgIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0 cy5hZGQob3JpZ2luLCBjYWxsYmFjayk7CisgICAgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1p c3Npb25fcmVxdWVzdChtX3ZpZXcsIG9yaWdpbik7CiB9CiAKIE5vdGlmaWNhdGlvbkNsaWVudDo6 UGVybWlzc2lvbiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNoZWNrUGVybWlzc2lv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Np b25zLmZpbmQoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSk7CisgICAgaWYg KGl0ZXIgPT0gbV9jYWNoZWRQZXJtaXNzaW9ucy5lbmQoKSkKKyAgICAgICAgcmV0dXJuIFBlcm1p c3Npb25Ob3RBbGxvd2VkOworICAgIGlmIChpdGVyLT5zZWNvbmQpCisgICAgICAgIHJldHVybiBQ ZXJtaXNzaW9uQWxsb3dlZDsKKwogICAgIHJldHVybiBQZXJtaXNzaW9uRGVuaWVkOwogfQogCi12 b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJt aXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCit2b2lkIE5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6YWRkVG9QZXJtaXNzaW9uQ2FjaGUoY29uc3QgU3RyaW5nJiBk b21haW4sIGNvbnN0IGJvb2wgaXNBbGxvd2VkKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Cisg ICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Npb25zLmZp bmQoZG9tYWluKTsKKyAgICBpZiAoaXRlciA9PSBtX2NhY2hlZFBlcm1pc3Npb25zLmVuZCgpKQor ICAgICAgICByZXR1cm47CisgICAgbV9jYWNoZWRQZXJtaXNzaW9ucy5hZGQoZG9tYWluLCBpc0Fs bG93ZWQpOworfQorCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVy bWlzc2lvbihjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4sIGNvbnN0IGJvb2wgaXNB bGxvd2VkKQoreworICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwOjppdGVyYXRvciBpdGVyID0gbV9w ZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLmZpbmQob3JpZ2luKTsKKyAgICBpZiAoaXRlciA9PSBt X3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpCisgICAgICAgIHJldHVybjsKKworICAg IGl0ZXItPnNlY29uZC0+aGFuZGxlRXZlbnQoTm90aWZpY2F0aW9uOjpwZXJtaXNzaW9uU3RyaW5n KGlzQWxsb3dlZCA/IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbkFsbG93ZWQgOiBOb3Rp ZmljYXRpb25DbGllbnQ6OlBlcm1pc3Npb25EZW5pZWQpKTsKKyAgICBtX3BlbmRpbmdQZXJtaXNz aW9uUmVxdWVzdHMucmVtb3ZlKGl0ZXIpOworICAgIG1fY2FjaGVkUGVybWlzc2lvbnMuYWRkKFN0 cmluZzo6ZnJvbVVURjgoZXdrX3NlY3VyaXR5X29yaWdpbl9zdHJpbmdfZ2V0KG9yaWdpbikpLCBp c0FsbG93ZWQpOworICAgIGV3a19zZWN1cml0eV9vcmlnaW5fZnJlZShjb25zdF9jYXN0PEV3a19T ZWN1cml0eV9PcmlnaW4qPihvcmlnaW4pKTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmgg Yi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJD bGllbnRFZmwuaAppbmRleCBlY2U1Y2NmLi5jZTQ3YmU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaAor KysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50 ZXJDbGllbnRFZmwuaApAQCAtMjAsMjUgKzIwLDQzIEBACiAjaWZuZGVmIE5vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbF9oCiAjZGVmaW5lIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVm bF9oCiAKLSNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklD QVRJT05TKQotI2luY2x1ZGUgIk5vdGlmaWNhdGlvbi5oIgorI2lmIEVOQUJMRShOT1RJRklDQVRJ T05TKQogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNsaWVudC5oIgorI2luY2x1ZGUgImV3a19zZWN1 cml0eV9vcmlnaW4uaCIKKyNpbmNsdWRlIDxFdmFzLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAu aD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCi1jbGFzcyBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwgOiBwdWJsaWMgTm90aWZp Y2F0aW9uQ2xpZW50IHsKK2NsYXNzIE5vdGlmaWNhdGlvbjsKIAorY2xhc3MgTm90aWZpY2F0aW9u UHJlc2VudGVyQ2xpZW50RWZsIDogcHVibGljIE5vdGlmaWNhdGlvbkNsaWVudCB7CiBwdWJsaWM6 Ci0gICAgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CisgICAgZXhwbGljaXQgTm90 aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KTsKICAgICB+Tm90 aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CiAKICAgICB2aXJ0dWFsIGJvb2wgc2hvdyhO b3RpZmljYXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsKE5vdGlmaWNhdGlvbiopOwog ICAgIHZpcnR1YWwgdm9pZCBub3RpZmljYXRpb25PYmplY3REZXN0cm95ZWQoTm90aWZpY2F0aW9u Kik7CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0cm95ZWQoKTsK LSAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIFBhc3NSZWZQdHI8Vm9pZENhbGxiYWNrPik7CisjaWYgRU5BQkxFKExFR0FDWV9OT1RJRklD QVRJT05TKQorICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+KSB7IH0KKyNlbmRpZgorICAgIHZp cnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgUGFz c1JlZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+KTsKICAgICB2aXJ0dWFsIE5v dGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbiBjaGVja1Blcm1pc3Npb24oU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCopOwotICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Np b24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOworICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1 ZXN0c0ZvclBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopIHsgfQorCisgICAgdm9p ZCBhZGRUb1Blcm1pc3Npb25DYWNoZShjb25zdCBTdHJpbmcmIGRvbWFpbiwgYm9vbCBpc0FsbG93 ZWQpOworICAgIHZvaWQgc2V0UGVybWlzc2lvbihjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiwg Ym9vbCBpc0FsbG93ZWQpOworCitwcml2YXRlOgorICAgIEV2YXNfT2JqZWN0KiBtX3ZpZXc7CisK KyAgICB0eXBlZGVmIEhhc2hNYXA8Y29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbiosIFJlZlB0cjxX ZWJDb3JlOjpOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+ID4gUGVybWlzc2lvblJlcXVl c3RNYXA7CisgICAgUGVybWlzc2lvblJlcXVlc3RNYXAgbV9wZW5kaW5nUGVybWlzc2lvblJlcXVl c3RzOworICAgIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIGJvb2w+IFBlcm1pc3Npb25zTWFwOwor ICAgIFBlcm1pc3Npb25zTWFwIG1fY2FjaGVkUGVybWlzc2lvbnM7CiB9OwogCiB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwIGIvU291cmNlL1dlYktpdC9l ZmwvZXdrL2V3a192aWV3LmNwcAppbmRleCA0OTQ5YWFjLi5kYzU4MTI3IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZs L2V3ay9ld2tfdmlldy5jcHAKQEAgLTEwOSw2ICsxMDksMTEgQEAKICNpbmNsdWRlICJOYXZpZ2F0 b3JDb250ZW50VXRpbHNDbGllbnRFZmwuaCIKICNlbmRpZgogCisjaWYgRU5BQkxFKE5PVElGSUNB VElPTlMpCisjaW5jbHVkZSAiTm90aWZpY2F0aW9uQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIk5v dGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oIgorI2VuZGlmCisKIHN0YXRpYyBjb25zdCBm bG9hdCB6b29tTWluaW11bSA9IDAuMDU7CiBzdGF0aWMgY29uc3QgZmxvYXQgem9vbU1heGltdW0g PSA0LjA7CiAKQEAgLTc3NSw2ICs3ODAsMTAgQEAgc3RhdGljIEV3a19WaWV3X1ByaXZhdGVfRGF0 YSogX2V3a192aWV3X3ByaXZfbmV3KEV3a19WaWV3X1NtYXJ0X0RhdGEqIHNtYXJ0RGF0YSkKICAg ICBXZWJDb3JlOjpwcm92aWRlTmF2aWdhdG9yQ29udGVudFV0aWxzVG8ocHJpdi0+cGFnZS5nZXQo KSwgcHJpdi0+bmF2aWdhdG9yQ29udGVudFV0aWxzQ2xpZW50LmdldCgpKTsKICNlbmRpZgogCisj aWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgV2ViQ29yZTo6cHJvdmlkZU5vdGlmaWNhdGlv bihwcml2LT5wYWdlLmdldCgpLCBuZXcgV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xp ZW50RWZsKHNtYXJ0RGF0YS0+c2VsZikpOworI2VuZGlmCisKICAgICBwcml2LT5wYWdlU2V0dGlu Z3MgPSBwcml2LT5wYWdlLT5zZXR0aW5ncygpOwogCiAgICAgcHJpdi0+dmlld3BvcnRBcmd1bWVu dHMud2lkdGggPSBXZWJDb3JlOjpWaWV3cG9ydEFyZ3VtZW50czo6VmFsdWVBdXRvOwpAQCAtNDU2 NSw2ICs0NTc0LDM3IEBAIHZvaWQgZXdrX3ZpZXdfY3Vyc29yX3NldChFdmFzX09iamVjdCogZXdr VmlldywgY29uc3QgV2ViQ29yZTo6Q3Vyc29yJiBjdXJzb3IpCiAgICAgfQogfQogCitFaW5hX0Jv b2wgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fc3RvcmUoRXZhc19PYmplY3QqIGV3 a1ZpZXcsIGNvbnN0IGNoYXIqIGRvbWFpbiwgRWluYV9Cb29sIHBlcm1pdHRlZCkKK3sKKyNpZiBF TkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICBFV0tfVklFV19TRF9HRVRfT1JfUkVUVVJOKGV3a1Zp ZXcsIHNtYXJ0RGF0YSwgZmFsc2UpOworICAgIEVXS19WSUVXX1BSSVZfR0VUX09SX1JFVFVSTihz bWFydERhdGEsIHByaXYsIGZhbHNlKTsKKyAgICBzdGF0aWNfY2FzdDxXZWJDb3JlOjpOb3RpZmlj YXRpb25QcmVzZW50ZXJDbGllbnRFZmwqPihXZWJDb3JlOjpOb3RpZmljYXRpb25Db250cm9sbGVy OjpjbGllbnRGcm9tKHByaXYtPnBhZ2UuZ2V0KCkpKS0+YWRkVG9QZXJtaXNzaW9uQ2FjaGUoU3Ry aW5nOjpmcm9tVVRGOChkb21haW4pLCBwZXJtaXR0ZWQpOworICAgIHJldHVybiB0cnVlOworI2Vs c2UKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKworRWluYV9Cb29sIGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IEV3 a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiwgRWluYV9Cb29sIHBlcm1pdHRlZCkKK3sKKyNpZiBF TkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICBFV0tfVklFV19TRF9HRVRfT1JfUkVUVVJOKGV3a1Zp ZXcsIHNtYXJ0RGF0YSwgZmFsc2UpOworICAgIEVXS19WSUVXX1BSSVZfR0VUX09SX1JFVFVSTihz bWFydERhdGEsIHByaXYsIGZhbHNlKTsKKyAgICBzdGF0aWNfY2FzdDxXZWJDb3JlOjpOb3RpZmlj YXRpb25QcmVzZW50ZXJDbGllbnRFZmwqPihXZWJDb3JlOjpOb3RpZmljYXRpb25Db250cm9sbGVy OjpjbGllbnRGcm9tKHByaXYtPnBhZ2UuZ2V0KCkpKS0+c2V0UGVybWlzc2lvbihvcmlnaW4sIHBl cm1pdHRlZCk7CisgICAgcmV0dXJuIHRydWU7CisjZWxzZQorICAgIHJldHVybiBmYWxzZTsKKyNl bmRpZgorfQorCisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCit2b2lkIGV3a192aWV3X25vdGlm aWNhdGlvbl9wZXJtaXNzaW9uX3JlcXVlc3QoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IEV3 a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbikKK3sKKyAgICBldmFzX29iamVjdF9zbWFydF9jYWxs YmFja19jYWxsKGV3a1ZpZXcsICJub3RpZmljYXRpb24scGVybWlzc2lvbixyZXF1ZXN0IiwgY29u c3RfY2FzdDxFd2tfU2VjdXJpdHlfT3JpZ2luKj4ob3JpZ2luKSk7Cit9CisjZW5kaWYKKwogbmFt ZXNwYWNlIEVXS1ByaXZhdGUgewogCiBXZWJDb3JlOjpQYWdlKiBjb3JlUGFnZShjb25zdCBFdmFz X09iamVjdCogZXdrVmlldykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tf dmlldy5oIGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKaW5kZXggMmEyNjBmMS4u Nzc3NzAyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKKysr IGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKQEAgLTc0LDYgKzc0LDcgQEAKICAq ICAtICJtaXhlZGNvbnRlbnQsZGlzcGxheWVkIiwgdm9pZDogYW55IG9mIHRoZSBjb250YWluaW5n IGZyYW1lcyBoYXMgbG9hZGVkIGFuZCBkaXNwbGF5ZWQgbWl4ZWQgY29udGVudC4KICAqICAtICJt aXhlZGNvbnRlbnQscnVuIiwgdm9pZDogYW55IG9mIHRoZSBjb250YWluaW5nIGZyYW1lcyBoYXMg bG9hZGVkIGFuZCBydW4gbWl4ZWQgY29udGVudC4KICAqICAtICJuYXZpZ2F0ZSx3aXRoLGRhdGEi LCBFd2tfVmlld19OYXZpZ2F0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBkaWQgbmF2aWdh dGlvbiBhbmQgZ2l2ZXMgdGhlIG5hdmlnYXRpb24gZGV0YWlscy4KKyAqICAtICJub3RpZmljYXRp b24scGVybWlzc2lvbixyZXF1ZXN0IiwgY29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbio6IHJlcXVl c3QgdG8gY29uZmlybSBwZXJtaXNzaW9uIGZvciBzZWN1cml0eSBvcmlnaW4gZnJvbSB1c2VyLgog ICogIC0gInBlcmZvcm0sY2xpZW50LHJlZGlyZWN0IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0 YSo6IHJlcG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIGNsaWVudCByZWRpcmVjdCBhbmQgZ2l2 ZXMgdGhlIHJlZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAicGVyZm9ybSxzZXJ2ZXIscmVkaXJl Y3QiLCBFd2tfVmlld19SZWRpcmVjdGlvbl9EYXRhKjogcmVwb3J0cyB0aGF0IHZpZXcgcGVyZm9y bWVkIGEgc2VydmVyIHJlZGlyZWN0IGFuZCBnaXZlcyB0aGUgcmVkaXJlY3Rpb24gZGV0YWlscy4K ICAqICAtICJwcm90b2NvbGhhbmRsZXIscmVnaXN0cmF0aW9uLHJlcXVlc3RlZCIsIEV3a19DdXN0 b21fSGFuZGxlcl9EYXRhOiBhZGQgYSBoYW5kbGVyIHVybCBmb3IgdGhlIGdpdmVuIHByb3RvY29s LgpAQCAtMjc0Niw2ICsyNzQ3LDMzIEBAIEVBUEkgRXZhc19PYmplY3QqIGV3a192aWV3X3dlYl9p bnNwZWN0b3Jfdmlld19nZXQoY29uc3QgRXZhc19PYmplY3QgKm8pOwogICovCiBFQVBJIHZvaWQg ZXdrX3ZpZXdfd2ViX2luc3BlY3Rvcl92aWV3X3NldChFdmFzX09iamVjdCAqbywgRXZhc19PYmpl Y3QgKmluc3BlY3Rvcl92aWV3KTsKIAorLyoqCisgKiBBZGQgcGVybWl0dGVkIG9yIGRlbmllZCBs aXN0IHRvIHRoZSBwZXJtaXNzaW9uIGNhY2hlIGZvciBXZWIgTm90aWZpY2F0aW9ucy4KKyAqCisg KiBJZiB0aGVyZSBhcmUgc3RvcmVkIHBlcm1pc3Npb24gbGlzdHMgZm9yIFdlYiBOb3RpZmljYXRp b25zLAorICogdGhpcyBmdW5jdGlvbiBuZWVkIHRvIGJlIGNhbGxlZCB3aXRoIHBlcm1pc3Npb24u CisgKgorICogQHBhcmFtIG8gdmlldyBvYmplY3QgdG8gc2V0IHRoZSBwZXJtaXNzaW9uIGNhY2hl IGxpc3QuCisgKiBAcGFyYW0gZG9tYWluIHN0cmluZyBmb3IgZGV0ZXJtaW5lIHRoZSBwZXJtaXNz aW9uLgorICogQHBhcmFtIHBlcm1pdHRlZCBAYyBFSU5BX1RSVUUgdG8gcGVybWl0LCBAYyBFSU5B X0ZBTFNFIHRvIGRlbnkuCisgKgorICogQHJldHVybiBAYyBFSU5BX1RSVUUgb24gc3VjY2VzcyBv ciBAYyBFSU5BX0ZBTFNFIG9uIGZhaWx1cmUKKyAqLworRWluYV9Cb29sIGV3a192aWV3X25vdGlm aWNhdGlvbl9wZXJtaXNzaW9uX3N0b3JlKEV2YXNfT2JqZWN0ICpvLCBjb25zdCBjaGFyICpkb21h aW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQpOworCisvKioKKyAqIFNldCBwZXJtaXR0ZWQgb3IgZGVu aWVkIGxpc3RzIHRvIHRoZSBwZXJtaXNzaW9uIGNhY2hlIGZvciB0aGUgV2ViIE5vdGlmaWNhdGlv bnMuCisgKgorICogQWZ0ZXIgY2hlY2tpbmcgcGVybWlzc2lvbiwgdGhpcyBmdW5jdGlvbiBoYXZl IHRvIGJlIGNhbGxlZCB0byBzZXQgcGVybWlzc2lvbi4KKyAqCisgKiBAcGFyYW0gbyB2aWV3IG9i amVjdCB0byBzZXQgdGhlIHBlcm1pc3Npb24uCisgKiBAcGFyYW0gb3JpZ2luIHNlY3VyaXR5IG9y aWdpbiBvYmplY3QKKyAqIEBwYXJhbSBhbGxvdyBAYyBFSU5BX1RSVUUgdG8gcGVybWl0LCBAYyBF SU5BX0ZBTFNFIHRvIGRlbnkuCisgKgorICogQHJldHVybiBAYyBFSU5BX1RSVUUgb24gc3VjY2Vz cyBvciBAYyBFSU5BX0ZBTFNFIG9uIGZhaWx1cmUKKyAqLworRUFQSSBFaW5hX0Jvb2wgZXdrX3Zp ZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zX3NldChFdmFzX09iamVjdCAqbywgY29uc3QgRXdr X1NlY3VyaXR5X09yaWdpbiAqb3JpZ2luLCBFaW5hX0Jvb2wgcGVybWl0dGVkKTsKKwogI2lmZGVm IF9fY3BsdXNwbHVzCiB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL2V3 ay9ld2tfdmlld19wcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJp dmF0ZS5oCmluZGV4IGRhZWU2NzcuLmFmMmY5ZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv ZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3 a192aWV3X3ByaXZhdGUuaApAQCAtMTU2LDYgKzE1NiwxMCBAQCBib29sIGV3a192aWV3X2FjY2Vs ZXJhdGVkX2NvbXBvc2l0aW5nX29iamVjdF9jcmVhdGUoRXZhc19PYmplY3QqIGV3a1ZpZXcsIEV2 YXNfTgogV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0QqIGV3a192aWV3X2FjY2VsZXJhdGVkX2Nv bXBvc2l0aW5nX2NvbnRleHRfZ2V0KEV2YXNfT2JqZWN0KiBld2tWaWV3KTsKICNlbmRpZgogCisj aWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCit2b2lkIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJt aXNzaW9uX3JlcXVlc3QoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IEV3a19TZWN1cml0eV9P cmlnaW4qIG9yaWdpbik7CisjZW5kaWYKKwogbmFtZXNwYWNlIEVXS1ByaXZhdGUgewogV2ViQ29y ZTo6UGFnZSAqY29yZVBhZ2UoY29uc3QgRXZhc19PYmplY3QgKmV3a1ZpZXcpOwogUGxhdGZvcm1Q YWdlQ2xpZW50IGNvcmVQYWdlQ2xpZW50KEV2YXNfT2JqZWN0KiBld2tWaWV3KTsK 162411 2012-09-05 21:47:09 -0700 2012-09-06 03:59:07 -0700 Patch bug-90603-20120906134650.patch text/plain 13072 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3Njg0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggYjdmOGIxNTMx ZjMzMzE4NDJhYzk2YTExMjUyMGQ4MmRmN2EzNmY5Ni4uYzg0YjdhYzk2MzBiZWUwNDM1OTEzNGVi ZmVjOGFhZWZkOGE5YWU4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEy LTA5LTA1ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z LgorICAgICAgICBjaGVja1Blcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uTGV2 ZWwoKS4KKyAgICAgICAgcmVxdWVzdFBlcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5yZXF1ZXN0 UGVybWlzc2lvbigpLgorICAgICAgICBJbiBhZGRpdGlvbiwgaWYgdGhlIGFwcGxpY2F0aW9uKGxp a2UgYSBicm93c2VyKSBoYXMgcGVybWl0dGVkIGRvbWFpbnMgYWxyZWFkeSwKKyAgICAgICAgaXQg Y2FuIGJlIGNhY2hlZCB1c2luZyBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc3Rv cmUuCisKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAo V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpjaGVja1Blcm1pc3Npb24p OgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjphZGRU b1Blcm1pc3Npb25DYWNoZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVybWlzc2lvbik6CisgICAgICAg ICogV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmg6CisgICAg ICAgIChXZWJDb3JlKToKKyAgICAgICAgKE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCk6 CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVl c3RQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKToKKyAgICAgICAgKiBld2svZXdr X3ZpZXcuY3BwOgorICAgICAgICAoX2V3a192aWV3X3ByaXZfbmV3KToKKyAgICAgICAgKGV3a192 aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3N0b3JlKToKKyAgICAgICAgKGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQpOgorICAgICAgICAoZXdrX3ZpZXdfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25fcmVxdWVzdCk6CisgICAgICAgICogZXdrL2V3a192aWV3Lmg6CisgICAg ICAgICogZXdrL2V3a192aWV3X3ByaXZhdGUuaDoKKwogMjAxMi0wOS0wNSAgS2FuZ2lsIEhhbiAg PGthbmdpbC5oYW5Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gUmVtb3ZlICcrPScgdXNh Z2UgaW4gU3RyaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9y dC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwIGIvU291cmNlL1dlYktpdC9lZmwv V2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmNwcAppbmRleCBj NGU1Y2E4ZGE0OGE3MWFjYTI0N2U4ODMzMTY0YzBjYmI5N2M0ZDVkLi4zMGNmYjY5NjZmNWYzZWJk MzA2OWU2OWI5YzI0MjhmMjI2NDc4YWIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9X ZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbC5jcHAKQEAgLTIwLDEzICsyMCwyMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oIgogCi0jaWYgRU5BQkxFKE5PVElG SUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyNpZiBFTkFCTEUoTk9U SUZJQ0FUSU9OUykKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgorI2luY2x1ZGUgIk5vdGlm aWNhdGlvbi5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRl ICJTZWN1cml0eU9yaWdpbi5oIgorI2luY2x1ZGUgImV3a19zZWN1cml0eV9vcmlnaW5fcHJpdmF0 ZS5oIgorI2luY2x1ZGUgImV3a192aWV3X3ByaXZhdGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCi1Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbCgpCitOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbChFdmFzX09iamVjdCogdmlldykKKyAgICA6IG1fdmlldyh2aWV3 KQogeworICAgIEFTU0VSVChtX3ZpZXcpOwogfQogCiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmw6On5Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKQpAQCAtNTQsMjAgKzYxLDQy IEBAIHZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpub3RpZmljYXRpb25Db250 cm9sbGVyRGVzdHJveWVkKCkKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIE5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+IGNhbGxiYWNrKQor dm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNzaW9uKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8Tm90aWZpY2F0aW9uUGVy bWlzc2lvbkNhbGxiYWNrPiBjYWxsYmFjaykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAg IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiA9IGV3a19zZWN1cml0eV9vcmlnaW5fbmV3KGNv bnRleHQtPnNlY3VyaXR5T3JpZ2luKCkpOworICAgIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0 cy5hZGQob3JpZ2luLCBjYWxsYmFjayk7CisgICAgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1p c3Npb25fcmVxdWVzdChtX3ZpZXcsIG9yaWdpbik7CiB9CiAKIE5vdGlmaWNhdGlvbkNsaWVudDo6 UGVybWlzc2lvbiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNoZWNrUGVybWlzc2lv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Np b25zLmZpbmQoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSk7CisgICAgaWYg KGl0ZXIgPT0gbV9jYWNoZWRQZXJtaXNzaW9ucy5lbmQoKSkKKyAgICAgICAgcmV0dXJuIFBlcm1p c3Npb25Ob3RBbGxvd2VkOworICAgIGlmIChpdGVyLT5zZWNvbmQpCisgICAgICAgIHJldHVybiBQ ZXJtaXNzaW9uQWxsb3dlZDsKKwogICAgIHJldHVybiBQZXJtaXNzaW9uRGVuaWVkOwogfQogCi12 b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJt aXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCit2b2lkIE5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6YWRkVG9QZXJtaXNzaW9uQ2FjaGUoY29uc3QgU3RyaW5nJiBk b21haW4sIGNvbnN0IGJvb2wgYWxsb3dlZCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAg IFBlcm1pc3Npb25zTWFwOjppdGVyYXRvciBpdGVyID0gbV9jYWNoZWRQZXJtaXNzaW9ucy5maW5k KGRvbWFpbik7CisgICAgaWYgKGl0ZXIgPT0gbV9jYWNoZWRQZXJtaXNzaW9ucy5lbmQoKSkKKyAg ICAgICAgcmV0dXJuOworICAgIG1fY2FjaGVkUGVybWlzc2lvbnMuYWRkKGRvbWFpbiwgaXNBbGxv d2VkKTsKK30KKwordm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnNldFBlcm1p c3Npb24oY29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbiogb3JpZ2luLCBjb25zdCBib29sIGFsbG93 ZWQpCit7CisgICAgUGVybWlzc2lvblJlcXVlc3RNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX3BlbmRp bmdQZXJtaXNzaW9uUmVxdWVzdHMuZmluZChvcmlnaW4pOworICAgIGlmIChpdGVyID09IG1fcGVu ZGluZ1Blcm1pc3Npb25SZXF1ZXN0cy5lbmQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaXRl ci0+c2Vjb25kLT5oYW5kbGVFdmVudChOb3RpZmljYXRpb246OnBlcm1pc3Npb25TdHJpbmcoaXNB bGxvd2VkID8gTm90aWZpY2F0aW9uQ2xpZW50OjpQZXJtaXNzaW9uQWxsb3dlZCA6IE5vdGlmaWNh dGlvbkNsaWVudDo6UGVybWlzc2lvbkRlbmllZCkpOworICAgIG1fcGVuZGluZ1Blcm1pc3Npb25S ZXF1ZXN0cy5yZW1vdmUoaXRlcik7CisgICAgbV9jYWNoZWRQZXJtaXNzaW9ucy5hZGQoU3RyaW5n Ojpmcm9tVVRGOChld2tfc2VjdXJpdHlfb3JpZ2luX3N0cmluZ19nZXQob3JpZ2luKSksIGlzQWxs b3dlZCk7CisgICAgZXdrX3NlY3VyaXR5X29yaWdpbl9mcmVlKGNvbnN0X2Nhc3Q8RXdrX1NlY3Vy aXR5X09yaWdpbio+KG9yaWdpbikpOwogfQogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaCBiL1Nv dXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbC5oCmluZGV4IGVjZTVjY2ZlNGI2NWQxMzVhODE4YmQ5OWYxMjQ1OTVlMDBhMmJmZTEuLjA0 NjBiOGIzM2MwNTY1YzEzMmI2ZTA0MWVlZDI5ZDQ4MDE0ZTJjYzUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVm bC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbC5oCkBAIC0yMCwyNSArMjAsNDMgQEAKICNpZm5kZWYgTm90aWZpY2F0 aW9uUHJlc2VudGVyQ2xpZW50RWZsX2gKICNkZWZpbmUgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xp ZW50RWZsX2gKIAotI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKSB8fCBFTkFCTEUoTEVHQUNZX05P VElGSUNBVElPTlMpCi0jaW5jbHVkZSAiTm90aWZpY2F0aW9uLmgiCisjaWYgRU5BQkxFKE5PVElG SUNBVElPTlMpCiAjaW5jbHVkZSAiTm90aWZpY2F0aW9uQ2xpZW50LmgiCisjaW5jbHVkZSAiZXdr X3NlY3VyaXR5X29yaWdpbi5oIgorI2luY2x1ZGUgPEV2YXMuaD4KKyNpbmNsdWRlIDx3dGYvSGFz aE1hcC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKLWNsYXNzIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCA6IHB1YmxpYyBO b3RpZmljYXRpb25DbGllbnQgeworY2xhc3MgTm90aWZpY2F0aW9uOwogCitjbGFzcyBOb3RpZmlj YXRpb25QcmVzZW50ZXJDbGllbnRFZmwgOiBwdWJsaWMgTm90aWZpY2F0aW9uQ2xpZW50IHsKIHB1 YmxpYzoKLSAgICBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKTsKKyAgICBleHBsaWNp dCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoRXZhc19PYmplY3QqIHZpZXcpOwogICAg IH5Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKTsKIAogICAgIHZpcnR1YWwgYm9vbCBz aG93KE5vdGlmaWNhdGlvbiopOwogICAgIHZpcnR1YWwgdm9pZCBjYW5jZWwoTm90aWZpY2F0aW9u Kik7CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbk9iamVjdERlc3Ryb3llZChOb3RpZmlj YXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgbm90aWZpY2F0aW9uQ29udHJvbGxlckRlc3Ryb3ll ZCgpOwotICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25D b250ZXh0KiwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+KTsKKyNpZiBFTkFCTEUoTEVHQUNZX05P VElGSUNBVElPTlMpCisgICAgdmlydHVhbCB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqLCBQYXNzUmVmUHRyPFZvaWRDYWxsYmFjaz4pIHsgfQorI2VuZGlmCisg ICAgdmlydHVhbCB2b2lkIHJlcXVlc3RQZXJtaXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBQYXNzUmVmUHRyPE5vdGlmaWNhdGlvblBlcm1pc3Npb25DYWxsYmFjaz4pOwogICAgIHZpcnR1 YWwgTm90aWZpY2F0aW9uQ2xpZW50OjpQZXJtaXNzaW9uIGNoZWNrUGVybWlzc2lvbihTY3JpcHRF eGVjdXRpb25Db250ZXh0Kik7Ci0gICAgdmlydHVhbCB2b2lkIGNhbmNlbFJlcXVlc3RzRm9yUGVy bWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0Kik7CisgICAgdmlydHVhbCB2b2lkIGNhbmNl bFJlcXVlc3RzRm9yUGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KikgeyB9CisKKyAg ICB2b2lkIGFkZFRvUGVybWlzc2lvbkNhY2hlKGNvbnN0IFN0cmluZyYgZG9tYWluLCBib29sIGFs bG93ZWQpOworICAgIHZvaWQgc2V0UGVybWlzc2lvbihjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2lu KiwgYm9vbCBhbGxvd2VkKTsKKworcHJpdmF0ZToKKyAgICBFdmFzX09iamVjdCogbV92aWV3Owor CisgICAgdHlwZWRlZiBIYXNoTWFwPGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qLCBSZWZQdHI8 V2ViQ29yZTo6Tm90aWZpY2F0aW9uUGVybWlzc2lvbkNhbGxiYWNrPiA+IFBlcm1pc3Npb25SZXF1 ZXN0TWFwOworICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1 ZXN0czsKKyAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBib29sPiBQZXJtaXNzaW9uc01hcDsK KyAgICBQZXJtaXNzaW9uc01hcCBtX2NhY2hlZFBlcm1pc3Npb25zOwogfTsKIAogfQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQv ZWZsL2V3ay9ld2tfdmlldy5jcHAKaW5kZXggNDk0OWFhYzRlMjdiNmY3ZGMyODAxNTJhNmMxNmZh NDUyZjM5MTQxMi4uZGM1ODEyNzgwNTliNTNkNjhiZWI2OGI0ODJlZThjZmRhNWJkNWUwZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwCkBAIC0xMDksNiArMTA5LDExIEBACiAjaW5jbHVk ZSAiTmF2aWdhdG9yQ29udGVudFV0aWxzQ2xpZW50RWZsLmgiCiAjZW5kaWYKIAorI2lmIEVOQUJM RShOT1RJRklDQVRJT05TKQorI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNvbnRyb2xsZXIuaCIKKyNp bmNsdWRlICJOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaCIKKyNlbmRpZgorCiBzdGF0 aWMgY29uc3QgZmxvYXQgem9vbU1pbmltdW0gPSAwLjA1Owogc3RhdGljIGNvbnN0IGZsb2F0IHpv b21NYXhpbXVtID0gNC4wOwogCkBAIC03NzUsNiArNzgwLDEwIEBAIHN0YXRpYyBFd2tfVmlld19Q cml2YXRlX0RhdGEqIF9ld2tfdmlld19wcml2X25ldyhFd2tfVmlld19TbWFydF9EYXRhKiBzbWFy dERhdGEpCiAgICAgV2ViQ29yZTo6cHJvdmlkZU5hdmlnYXRvckNvbnRlbnRVdGlsc1RvKHByaXYt PnBhZ2UuZ2V0KCksIHByaXYtPm5hdmlnYXRvckNvbnRlbnRVdGlsc0NsaWVudC5nZXQoKSk7CiAj ZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQorICAgIFdlYkNvcmU6OnByb3ZpZGVO b3RpZmljYXRpb24ocHJpdi0+cGFnZS5nZXQoKSwgbmV3IFdlYkNvcmU6Ok5vdGlmaWNhdGlvblBy ZXNlbnRlckNsaWVudEVmbChzbWFydERhdGEtPnNlbGYpKTsKKyNlbmRpZgorCiAgICAgcHJpdi0+ cGFnZVNldHRpbmdzID0gcHJpdi0+cGFnZS0+c2V0dGluZ3MoKTsKIAogICAgIHByaXYtPnZpZXdw b3J0QXJndW1lbnRzLndpZHRoID0gV2ViQ29yZTo6Vmlld3BvcnRBcmd1bWVudHM6OlZhbHVlQXV0 bzsKQEAgLTQ1NjUsNiArNDU3NCwzNyBAQCB2b2lkIGV3a192aWV3X2N1cnNvcl9zZXQoRXZhc19P YmplY3QqIGV3a1ZpZXcsIGNvbnN0IFdlYkNvcmU6OkN1cnNvciYgY3Vyc29yKQogICAgIH0KIH0K IAorRWluYV9Cb29sIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3N0b3JlKEV2YXNf T2JqZWN0KiBld2tWaWV3LCBjb25zdCBjaGFyKiBkb21haW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQp Cit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdfU0RfR0VUX09SX1JF VFVSTihld2tWaWV3LCBzbWFydERhdGEsIGZhbHNlKTsKKyAgICBFV0tfVklFV19QUklWX0dFVF9P Ul9SRVRVUk4oc21hcnREYXRhLCBwcml2LCBmYWxzZSk7CisgICAgc3RhdGljX2Nhc3Q8V2ViQ29y ZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKj4oV2ViQ29yZTo6Tm90aWZpY2F0aW9u Q29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2LT5wYWdlLmdldCgpKSktPmFkZFRvUGVybWlzc2lv bkNhY2hlKFN0cmluZzo6ZnJvbVVURjgoZG9tYWluKSwgcGVybWl0dGVkKTsKKyAgICByZXR1cm4g dHJ1ZTsKKyNlbHNlCisgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCit9CisKK0VpbmFfQm9vbCBl d2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc2V0KEV2YXNfT2JqZWN0KiBld2tWaWV3 LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQp Cit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdfU0RfR0VUX09SX1JF VFVSTihld2tWaWV3LCBzbWFydERhdGEsIGZhbHNlKTsKKyAgICBFV0tfVklFV19QUklWX0dFVF9P Ul9SRVRVUk4oc21hcnREYXRhLCBwcml2LCBmYWxzZSk7CisgICAgc3RhdGljX2Nhc3Q8V2ViQ29y ZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKj4oV2ViQ29yZTo6Tm90aWZpY2F0aW9u Q29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2LT5wYWdlLmdldCgpKSktPnNldFBlcm1pc3Npb24o b3JpZ2luLCBwZXJtaXR0ZWQpOworICAgIHJldHVybiB0cnVlOworI2Vsc2UKKyAgICByZXR1cm4g ZmFsc2U7CisjZW5kaWYKK30KKworI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQordm9pZCBld2tf dmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNfT2JqZWN0KiBld2tWaWV3 LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4pCit7CisgICAgZXZhc19vYmplY3Rf c21hcnRfY2FsbGJhY2tfY2FsbChld2tWaWV3LCAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24scmVx dWVzdCIsIGNvbnN0X2Nhc3Q8RXdrX1NlY3VyaXR5X09yaWdpbio+KG9yaWdpbikpOworfQorI2Vu ZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRlIHsKIAogV2ViQ29yZTo6UGFnZSogY29yZVBhZ2Uo Y29uc3QgRXZhc19PYmplY3QqIGV3a1ZpZXcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9ld2svZXdrX3ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCmluZGV4 IDJhMjYwZjFkZTg3MzEzZWVmNWM2YzE4MzhmMzA2ZjA0NmM2ZDM1OGEuLjc3NzcwMjg1MjEwYWE4 MTZiYTI5MzRiYmU5ZGI2MzFiZmZkNTQ4ZDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZs L2V3ay9ld2tfdmlldy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCkBA IC03NCw2ICs3NCw3IEBACiAgKiAgLSAibWl4ZWRjb250ZW50LGRpc3BsYXllZCIsIHZvaWQ6IGFu eSBvZiB0aGUgY29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgZGlzcGxheWVkIG1peGVk IGNvbnRlbnQuCiAgKiAgLSAibWl4ZWRjb250ZW50LHJ1biIsIHZvaWQ6IGFueSBvZiB0aGUgY29u dGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgcnVuIG1peGVkIGNvbnRlbnQuCiAgKiAgLSAi bmF2aWdhdGUsd2l0aCxkYXRhIiwgRXdrX1ZpZXdfTmF2aWdhdGlvbl9EYXRhKjogcmVwb3J0cyB0 aGF0IHZpZXcgZGlkIG5hdmlnYXRpb24gYW5kIGdpdmVzIHRoZSBuYXZpZ2F0aW9uIGRldGFpbHMu CisgKiAgLSAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24scmVxdWVzdCIsIGNvbnN0IEV3a19TZWN1 cml0eV9PcmlnaW4qOiByZXF1ZXN0IHRvIGNvbmZpcm0gcGVybWlzc2lvbiBmb3Igc2VjdXJpdHkg b3JpZ2luIGZyb20gdXNlci4KICAqICAtICJwZXJmb3JtLGNsaWVudCxyZWRpcmVjdCIsIEV3a19W aWV3X1JlZGlyZWN0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBwZXJmb3JtZWQgYSBjbGll bnQgcmVkaXJlY3QgYW5kIGdpdmVzIHRoZSByZWRpcmVjdGlvbiBkZXRhaWxzLgogICogIC0gInBl cmZvcm0sc2VydmVyLHJlZGlyZWN0IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0YSo6IHJlcG9y dHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIHNlcnZlciByZWRpcmVjdCBhbmQgZ2l2ZXMgdGhlIHJl ZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAicHJvdG9jb2xoYW5kbGVyLHJlZ2lzdHJhdGlvbixy ZXF1ZXN0ZWQiLCBFd2tfQ3VzdG9tX0hhbmRsZXJfRGF0YTogYWRkIGEgaGFuZGxlciB1cmwgZm9y IHRoZSBnaXZlbiBwcm90b2NvbC4KQEAgLTI3NDYsNiArMjc0NywzMyBAQCBFQVBJIEV2YXNfT2Jq ZWN0KiBld2tfdmlld193ZWJfaW5zcGVjdG9yX3ZpZXdfZ2V0KGNvbnN0IEV2YXNfT2JqZWN0ICpv KTsKICAqLwogRUFQSSB2b2lkIGV3a192aWV3X3dlYl9pbnNwZWN0b3Jfdmlld19zZXQoRXZhc19P YmplY3QgKm8sIEV2YXNfT2JqZWN0ICppbnNwZWN0b3Jfdmlldyk7CiAKKy8qKgorICogQWRkIHBl cm1pdHRlZCBvciBkZW5pZWQgbGlzdCB0byB0aGUgcGVybWlzc2lvbiBjYWNoZSBmb3IgV2ViIE5v dGlmaWNhdGlvbnMuCisgKgorICogSWYgdGhlcmUgYXJlIHN0b3JlZCBwZXJtaXNzaW9uIGxpc3Rz IGZvciBXZWIgTm90aWZpY2F0aW9ucywKKyAqIHRoaXMgZnVuY3Rpb24gbmVlZCB0byBiZSBjYWxs ZWQgd2l0aCBwZXJtaXNzaW9uLgorICoKKyAqIEBwYXJhbSBvIHZpZXcgb2JqZWN0IHRvIHNldCB0 aGUgcGVybWlzc2lvbiBjYWNoZSBsaXN0LgorICogQHBhcmFtIGRvbWFpbiBzdHJpbmcgZm9yIGRl dGVybWluZSB0aGUgcGVybWlzc2lvbi4KKyAqIEBwYXJhbSBwZXJtaXR0ZWQgQGMgRUlOQV9UUlVF IHRvIHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0byBkZW55LgorICoKKyAqIEByZXR1cm4gQGMgRUlO QV9UUlVFIG9uIHN1Y2Nlc3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWlsdXJlCisgKi8KK0VpbmFf Qm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9zdG9yZShFdmFzX09iamVjdCAq bywgY29uc3QgY2hhciAqZG9tYWluLCBFaW5hX0Jvb2wgcGVybWl0dGVkKTsKKworLyoqCisgKiBT ZXQgcGVybWl0dGVkIG9yIGRlbmllZCBsaXN0cyB0byB0aGUgcGVybWlzc2lvbiBjYWNoZSBmb3Ig dGhlIFdlYiBOb3RpZmljYXRpb25zLgorICoKKyAqIEFmdGVyIGNoZWNraW5nIHBlcm1pc3Npb24s IHRoaXMgZnVuY3Rpb24gaGF2ZSB0byBiZSBjYWxsZWQgdG8gc2V0IHBlcm1pc3Npb24uCisgKgor ICogQHBhcmFtIG8gdmlldyBvYmplY3QgdG8gc2V0IHRoZSBwZXJtaXNzaW9uLgorICogQHBhcmFt IG9yaWdpbiBzZWN1cml0eSBvcmlnaW4gb2JqZWN0CisgKiBAcGFyYW0gYWxsb3cgQGMgRUlOQV9U UlVFIHRvIHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0byBkZW55LgorICoKKyAqIEByZXR1cm4gQGMg RUlOQV9UUlVFIG9uIHN1Y2Nlc3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWlsdXJlCisgKi8KK0VB UEkgRWluYV9Cb29sIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQoRXZhc19P YmplY3QgKm8sIGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4gKm9yaWdpbiwgRWluYV9Cb29sIHBl cm1pdHRlZCk7CisKICNpZmRlZiBfX2NwbHVzcGx1cwogfQogI2VuZGlmCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9l ZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaAppbmRleCBkYWVlNjc3MzQ3ZjdkZTJmZjI2MzRhYWNh MzEwYTIxZmJhZmYzZDE2Li5hZjJmOWQ1OTk3ZjM1Y2QwMWI4YjVkYWZmZTc3ZDEzYTZiODFhMmZk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5oCisr KyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgKQEAgLTE1Niw2ICsx NTYsMTAgQEAgYm9vbCBld2tfdmlld19hY2NlbGVyYXRlZF9jb21wb3NpdGluZ19vYmplY3RfY3Jl YXRlKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBFdmFzX04KIFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDNEKiBld2tfdmlld19hY2NlbGVyYXRlZF9jb21wb3NpdGluZ19jb250ZXh0X2dldChFdmFzX09i amVjdCogZXdrVmlldyk7CiAjZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQordm9p ZCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNfT2JqZWN0KiBl d2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4pOworI2VuZGlmCisKIG5h bWVzcGFjZSBFV0tQcml2YXRlIHsKIFdlYkNvcmU6OlBhZ2UgKmNvcmVQYWdlKGNvbnN0IEV2YXNf T2JqZWN0ICpld2tWaWV3KTsKIFBsYXRmb3JtUGFnZUNsaWVudCBjb3JlUGFnZUNsaWVudChFdmFz X09iamVjdCogZXdrVmlldyk7Cg== 162471 2012-09-06 03:59:14 -0700 2012-09-06 20:07:09 -0700 Patch bug-90603-20120906195855.patch text/plain 13084 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3Njg0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggYjdmOGIxNTMx ZjMzMzE4NDJhYzk2YTExMjUyMGQ4MmRmN2EzNmY5Ni4uYzg0YjdhYzk2MzBiZWUwNDM1OTEzNGVi ZmVjOGFhZWZkOGE5YWU4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEy LTA5LTA1ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z LgorICAgICAgICBjaGVja1Blcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uTGV2 ZWwoKS4KKyAgICAgICAgcmVxdWVzdFBlcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5yZXF1ZXN0 UGVybWlzc2lvbigpLgorICAgICAgICBJbiBhZGRpdGlvbiwgaWYgdGhlIGFwcGxpY2F0aW9uKGxp a2UgYSBicm93c2VyKSBoYXMgcGVybWl0dGVkIGRvbWFpbnMgYWxyZWFkeSwKKyAgICAgICAgaXQg Y2FuIGJlIGNhY2hlZCB1c2luZyBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc3Rv cmUuCisKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAo V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpjaGVja1Blcm1pc3Npb24p OgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjphZGRU b1Blcm1pc3Npb25DYWNoZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6 Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVybWlzc2lvbik6CisgICAgICAg ICogV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmg6CisgICAg ICAgIChXZWJDb3JlKToKKyAgICAgICAgKE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCk6 CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVl c3RQZXJtaXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJtaXNzaW9uKToKKyAgICAgICAgKiBld2svZXdr X3ZpZXcuY3BwOgorICAgICAgICAoX2V3a192aWV3X3ByaXZfbmV3KToKKyAgICAgICAgKGV3a192 aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3N0b3JlKToKKyAgICAgICAgKGV3a192aWV3X25v dGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQpOgorICAgICAgICAoZXdrX3ZpZXdfbm90aWZpY2F0 aW9uX3Blcm1pc3Npb25fcmVxdWVzdCk6CisgICAgICAgICogZXdrL2V3a192aWV3Lmg6CisgICAg ICAgICogZXdrL2V3a192aWV3X3ByaXZhdGUuaDoKKwogMjAxMi0wOS0wNSAgS2FuZ2lsIEhhbiAg PGthbmdpbC5oYW5Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gUmVtb3ZlICcrPScgdXNh Z2UgaW4gU3RyaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9y dC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwIGIvU291cmNlL1dlYktpdC9lZmwv V2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmNwcAppbmRleCBj NGU1Y2E4ZGE0OGE3MWFjYTI0N2U4ODMzMTY0YzBjYmI5N2M0ZDVkLi43YWYzMzgyNDhkNDZiMmVl ZDZmN2M5M2JmYjUwMTA5N2JlN2M4NDZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9X ZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVu dEVmbC5jcHAKQEAgLTIwLDEzICsyMCwyMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oIgogCi0jaWYgRU5BQkxFKE5PVElG SUNBVElPTlMpIHx8IEVOQUJMRShMRUdBQ1lfTk9USUZJQ0FUSU9OUykKKyNpZiBFTkFCTEUoTk9U SUZJQ0FUSU9OUykKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgorI2luY2x1ZGUgIk5vdGlm aWNhdGlvbi5oIgorI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKKyNpbmNsdWRl ICJTZWN1cml0eU9yaWdpbi5oIgorI2luY2x1ZGUgImV3a19zZWN1cml0eV9vcmlnaW5fcHJpdmF0 ZS5oIgorI2luY2x1ZGUgImV3a192aWV3X3ByaXZhdGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCi1Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbCgpCitOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Ok5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbChFdmFzX09iamVjdCogdmlldykKKyAgICA6IG1fdmlldyh2aWV3 KQogeworICAgIEFTU0VSVChtX3ZpZXcpOwogfQogCiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmw6On5Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwoKQpAQCAtNTQsMjAgKzYxLDQy IEBAIHZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpub3RpZmljYXRpb25Db250 cm9sbGVyRGVzdHJveWVkKCkKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIE5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+IGNhbGxiYWNrKQor dm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OnJlcXVlc3RQZXJtaXNzaW9uKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8Tm90aWZpY2F0aW9uUGVy bWlzc2lvbkNhbGxiYWNrPiBjYWxsYmFjaykKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAg IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiA9IGV3a19zZWN1cml0eV9vcmlnaW5fbmV3KGNv bnRleHQtPnNlY3VyaXR5T3JpZ2luKCkpOworICAgIG1fcGVuZGluZ1Blcm1pc3Npb25SZXF1ZXN0 cy5hZGQob3JpZ2luLCBjYWxsYmFjayk7CisgICAgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1p c3Npb25fcmVxdWVzdChtX3ZpZXcsIG9yaWdpbik7CiB9CiAKIE5vdGlmaWNhdGlvbkNsaWVudDo6 UGVybWlzc2lvbiBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNoZWNrUGVybWlzc2lv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0KQogewotICAgIG5vdEltcGxlbWVudGVk KCk7CisgICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Np b25zLmZpbmQoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSk7CisgICAgaWYg KGl0ZXIgPT0gbV9jYWNoZWRQZXJtaXNzaW9ucy5lbmQoKSkKKyAgICAgICAgcmV0dXJuIFBlcm1p c3Npb25Ob3RBbGxvd2VkOworICAgIGlmIChpdGVyLT5zZWNvbmQpCisgICAgICAgIHJldHVybiBQ ZXJtaXNzaW9uQWxsb3dlZDsKKwogICAgIHJldHVybiBQZXJtaXNzaW9uRGVuaWVkOwogfQogCi12 b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Y2FuY2VsUmVxdWVzdHNGb3JQZXJt aXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCit2b2lkIE5vdGlmaWNhdGlv blByZXNlbnRlckNsaWVudEVmbDo6YWRkVG9QZXJtaXNzaW9uQ2FjaGUoY29uc3QgU3RyaW5nJiBk b21haW4sIGNvbnN0IGJvb2wgcGVybWl0dGVkKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Cisg ICAgUGVybWlzc2lvbnNNYXA6Oml0ZXJhdG9yIGl0ZXIgPSBtX2NhY2hlZFBlcm1pc3Npb25zLmZp bmQoZG9tYWluKTsKKyAgICBpZiAoaXRlciA9PSBtX2NhY2hlZFBlcm1pc3Npb25zLmVuZCgpKQor ICAgICAgICByZXR1cm47CisgICAgbV9jYWNoZWRQZXJtaXNzaW9ucy5hZGQoZG9tYWluLCBwZXJt aXR0ZWQpOworfQorCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6c2V0UGVy bWlzc2lvbihjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4sIGNvbnN0IGJvb2wgcGVy bWl0dGVkKQoreworICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwOjppdGVyYXRvciBpdGVyID0gbV9w ZW5kaW5nUGVybWlzc2lvblJlcXVlc3RzLmZpbmQob3JpZ2luKTsKKyAgICBpZiAoaXRlciA9PSBt X3BlbmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpCisgICAgICAgIHJldHVybjsKKworICAg IGl0ZXItPnNlY29uZC0+aGFuZGxlRXZlbnQoTm90aWZpY2F0aW9uOjpwZXJtaXNzaW9uU3RyaW5n KHBlcm1pdHRlZCA/IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbkFsbG93ZWQgOiBOb3Rp ZmljYXRpb25DbGllbnQ6OlBlcm1pc3Npb25EZW5pZWQpKTsKKyAgICBtX3BlbmRpbmdQZXJtaXNz aW9uUmVxdWVzdHMucmVtb3ZlKGl0ZXIpOworICAgIG1fY2FjaGVkUGVybWlzc2lvbnMuYWRkKFN0 cmluZzo6ZnJvbVVURjgoZXdrX3NlY3VyaXR5X29yaWdpbl9zdHJpbmdfZ2V0KG9yaWdpbikpLCBw ZXJtaXR0ZWQpOworICAgIGV3a19zZWN1cml0eV9vcmlnaW5fZnJlZShjb25zdF9jYXN0PEV3a19T ZWN1cml0eV9PcmlnaW4qPihvcmlnaW4pKTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmgg Yi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJD bGllbnRFZmwuaAppbmRleCBlY2U1Y2NmZTRiNjVkMTM1YTgxOGJkOTlmMTI0NTk1ZTAwYTJiZmUx Li5jYjhjYjYxNWI4NTlkMTFiMzJmMWZhNWIxZjU5YmI3YTkwNTE4ZWVkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRp b25QcmVzZW50ZXJDbGllbnRFZmwuaApAQCAtMjAsMjUgKzIwLDQzIEBACiAjaWZuZGVmIE5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbF9oCiAjZGVmaW5lIE5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbF9oCiAKLSNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FD WV9OT1RJRklDQVRJT05TKQotI2luY2x1ZGUgIk5vdGlmaWNhdGlvbi5oIgorI2lmIEVOQUJMRShO T1RJRklDQVRJT05TKQogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNsaWVudC5oIgorI2luY2x1ZGUg ImV3a19zZWN1cml0eV9vcmlnaW4uaCIKKyNpbmNsdWRlIDxFdmFzLmg+CisjaW5jbHVkZSA8d3Rm L0hhc2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCi1jbGFzcyBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwgOiBwdWJs aWMgTm90aWZpY2F0aW9uQ2xpZW50IHsKK2NsYXNzIE5vdGlmaWNhdGlvbjsKIAorY2xhc3MgTm90 aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsIDogcHVibGljIE5vdGlmaWNhdGlvbkNsaWVudCB7 CiBwdWJsaWM6Ci0gICAgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CisgICAgZXhw bGljaXQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KTsK ICAgICB+Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CiAKICAgICB2aXJ0dWFsIGJv b2wgc2hvdyhOb3RpZmljYXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsKE5vdGlmaWNh dGlvbiopOwogICAgIHZpcnR1YWwgdm9pZCBub3RpZmljYXRpb25PYmplY3REZXN0cm95ZWQoTm90 aWZpY2F0aW9uKik7CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0 cm95ZWQoKTsKLSAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0 aW9uQ29udGV4dCosIFBhc3NSZWZQdHI8Vm9pZENhbGxiYWNrPik7CisjaWYgRU5BQkxFKExFR0FD WV9OT1RJRklDQVRJT05TKQorICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+KSB7IH0KKyNlbmRp ZgorICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgUGFzc1JlZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+KTsKICAgICB2 aXJ0dWFsIE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbiBjaGVja1Blcm1pc3Npb24oU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCopOwotICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0c0Zv clBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOworICAgIHZpcnR1YWwgdm9pZCBj YW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopIHsgfQor CisgICAgdm9pZCBhZGRUb1Blcm1pc3Npb25DYWNoZShjb25zdCBTdHJpbmcmIGRvbWFpbiwgYm9v bCBwZXJtaXR0ZWQpOworICAgIHZvaWQgc2V0UGVybWlzc2lvbihjb25zdCBFd2tfU2VjdXJpdHlf T3JpZ2luKiwgYm9vbCBwZXJtaXR0ZWQpOworCitwcml2YXRlOgorICAgIEV2YXNfT2JqZWN0KiBt X3ZpZXc7CisKKyAgICB0eXBlZGVmIEhhc2hNYXA8Y29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbios IFJlZlB0cjxXZWJDb3JlOjpOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+ID4gUGVybWlz c2lvblJlcXVlc3RNYXA7CisgICAgUGVybWlzc2lvblJlcXVlc3RNYXAgbV9wZW5kaW5nUGVybWlz c2lvblJlcXVlc3RzOworICAgIHR5cGVkZWYgSGFzaE1hcDxTdHJpbmcsIGJvb2w+IFBlcm1pc3Np b25zTWFwOworICAgIFBlcm1pc3Npb25zTWFwIG1fY2FjaGVkUGVybWlzc2lvbnM7CiB9OwogCiB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwIGIvU291cmNl L1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcAppbmRleCA0OTQ5YWFjNGUyN2I2ZjdkYzI4MDE1 MmE2YzE2ZmE0NTJmMzkxNDEyLi5kYzU4MTI3ODA1OWI1M2Q2OGJlYjY4YjQ4MmVlOGNmZGE1YmQ1 ZTBkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKQEAgLTEwOSw2ICsxMDksMTEgQEAK ICNpbmNsdWRlICJOYXZpZ2F0b3JDb250ZW50VXRpbHNDbGllbnRFZmwuaCIKICNlbmRpZgogCisj aWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisjaW5jbHVkZSAiTm90aWZpY2F0aW9uQ29udHJvbGxl ci5oIgorI2luY2x1ZGUgIk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5oIgorI2VuZGlm CisKIHN0YXRpYyBjb25zdCBmbG9hdCB6b29tTWluaW11bSA9IDAuMDU7CiBzdGF0aWMgY29uc3Qg ZmxvYXQgem9vbU1heGltdW0gPSA0LjA7CiAKQEAgLTc3NSw2ICs3ODAsMTAgQEAgc3RhdGljIEV3 a19WaWV3X1ByaXZhdGVfRGF0YSogX2V3a192aWV3X3ByaXZfbmV3KEV3a19WaWV3X1NtYXJ0X0Rh dGEqIHNtYXJ0RGF0YSkKICAgICBXZWJDb3JlOjpwcm92aWRlTmF2aWdhdG9yQ29udGVudFV0aWxz VG8ocHJpdi0+cGFnZS5nZXQoKSwgcHJpdi0+bmF2aWdhdG9yQ29udGVudFV0aWxzQ2xpZW50Lmdl dCgpKTsKICNlbmRpZgogCisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgV2ViQ29yZTo6 cHJvdmlkZU5vdGlmaWNhdGlvbihwcml2LT5wYWdlLmdldCgpLCBuZXcgV2ViQ29yZTo6Tm90aWZp Y2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKHNtYXJ0RGF0YS0+c2VsZikpOworI2VuZGlmCisKICAg ICBwcml2LT5wYWdlU2V0dGluZ3MgPSBwcml2LT5wYWdlLT5zZXR0aW5ncygpOwogCiAgICAgcHJp di0+dmlld3BvcnRBcmd1bWVudHMud2lkdGggPSBXZWJDb3JlOjpWaWV3cG9ydEFyZ3VtZW50czo6 VmFsdWVBdXRvOwpAQCAtNDU2NSw2ICs0NTc0LDM3IEBAIHZvaWQgZXdrX3ZpZXdfY3Vyc29yX3Nl dChFdmFzX09iamVjdCogZXdrVmlldywgY29uc3QgV2ViQ29yZTo6Q3Vyc29yJiBjdXJzb3IpCiAg ICAgfQogfQogCitFaW5hX0Jvb2wgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fc3Rv cmUoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IGNoYXIqIGRvbWFpbiwgRWluYV9Cb29sIHBl cm1pdHRlZCkKK3sKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICBFV0tfVklFV19TRF9H RVRfT1JfUkVUVVJOKGV3a1ZpZXcsIHNtYXJ0RGF0YSwgZmFsc2UpOworICAgIEVXS19WSUVXX1BS SVZfR0VUX09SX1JFVFVSTihzbWFydERhdGEsIHByaXYsIGZhbHNlKTsKKyAgICBzdGF0aWNfY2Fz dDxXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwqPihXZWJDb3JlOjpOb3Rp ZmljYXRpb25Db250cm9sbGVyOjpjbGllbnRGcm9tKHByaXYtPnBhZ2UuZ2V0KCkpKS0+YWRkVG9Q ZXJtaXNzaW9uQ2FjaGUoU3RyaW5nOjpmcm9tVVRGOChkb21haW4pLCBwZXJtaXR0ZWQpOworICAg IHJldHVybiB0cnVlOworI2Vsc2UKKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKworRWlu YV9Cb29sIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uc19zZXQoRXZhc19PYmplY3Qq IGV3a1ZpZXcsIGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiwgRWluYV9Cb29sIHBl cm1pdHRlZCkKK3sKKyNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykKKyAgICBFV0tfVklFV19TRF9H RVRfT1JfUkVUVVJOKGV3a1ZpZXcsIHNtYXJ0RGF0YSwgZmFsc2UpOworICAgIEVXS19WSUVXX1BS SVZfR0VUX09SX1JFVFVSTihzbWFydERhdGEsIHByaXYsIGZhbHNlKTsKKyAgICBzdGF0aWNfY2Fz dDxXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwqPihXZWJDb3JlOjpOb3Rp ZmljYXRpb25Db250cm9sbGVyOjpjbGllbnRGcm9tKHByaXYtPnBhZ2UuZ2V0KCkpKS0+c2V0UGVy bWlzc2lvbihvcmlnaW4sIHBlcm1pdHRlZCk7CisgICAgcmV0dXJuIHRydWU7CisjZWxzZQorICAg IHJldHVybiBmYWxzZTsKKyNlbmRpZgorfQorCisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCit2 b2lkIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3JlcXVlc3QoRXZhc19PYmplY3Qq IGV3a1ZpZXcsIGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbikKK3sKKyAgICBldmFz X29iamVjdF9zbWFydF9jYWxsYmFja19jYWxsKGV3a1ZpZXcsICJub3RpZmljYXRpb24scGVybWlz c2lvbixyZXF1ZXN0IiwgY29uc3RfY2FzdDxFd2tfU2VjdXJpdHlfT3JpZ2luKj4ob3JpZ2luKSk7 Cit9CisjZW5kaWYKKwogbmFtZXNwYWNlIEVXS1ByaXZhdGUgewogCiBXZWJDb3JlOjpQYWdlKiBj b3JlUGFnZShjb25zdCBFdmFzX09iamVjdCogZXdrVmlldykKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oIGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3 LmgKaW5kZXggMmEyNjBmMWRlODczMTNlZWY1YzZjMTgzOGYzMDZmMDQ2YzZkMzU4YS4uOTNkYzdj ZmJmMzlkMjc3ZGIyZGE2YzRiNjE0ODhjZDkyOGZiNGJiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9lZmwvZXdrL2V3a192aWV3LmgKKysrIGIvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192 aWV3LmgKQEAgLTc0LDYgKzc0LDcgQEAKICAqICAtICJtaXhlZGNvbnRlbnQsZGlzcGxheWVkIiwg dm9pZDogYW55IG9mIHRoZSBjb250YWluaW5nIGZyYW1lcyBoYXMgbG9hZGVkIGFuZCBkaXNwbGF5 ZWQgbWl4ZWQgY29udGVudC4KICAqICAtICJtaXhlZGNvbnRlbnQscnVuIiwgdm9pZDogYW55IG9m IHRoZSBjb250YWluaW5nIGZyYW1lcyBoYXMgbG9hZGVkIGFuZCBydW4gbWl4ZWQgY29udGVudC4K ICAqICAtICJuYXZpZ2F0ZSx3aXRoLGRhdGEiLCBFd2tfVmlld19OYXZpZ2F0aW9uX0RhdGEqOiBy ZXBvcnRzIHRoYXQgdmlldyBkaWQgbmF2aWdhdGlvbiBhbmQgZ2l2ZXMgdGhlIG5hdmlnYXRpb24g ZGV0YWlscy4KKyAqICAtICJub3RpZmljYXRpb24scGVybWlzc2lvbixyZXF1ZXN0IiwgY29uc3Qg RXdrX1NlY3VyaXR5X09yaWdpbio6IHJlcXVlc3QgdG8gY29uZmlybSBwZXJtaXNzaW9uIGZvciBz ZWN1cml0eSBvcmlnaW4gZnJvbSB1c2VyLgogICogIC0gInBlcmZvcm0sY2xpZW50LHJlZGlyZWN0 IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0YSo6IHJlcG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1l ZCBhIGNsaWVudCByZWRpcmVjdCBhbmQgZ2l2ZXMgdGhlIHJlZGlyZWN0aW9uIGRldGFpbHMuCiAg KiAgLSAicGVyZm9ybSxzZXJ2ZXIscmVkaXJlY3QiLCBFd2tfVmlld19SZWRpcmVjdGlvbl9EYXRh KjogcmVwb3J0cyB0aGF0IHZpZXcgcGVyZm9ybWVkIGEgc2VydmVyIHJlZGlyZWN0IGFuZCBnaXZl cyB0aGUgcmVkaXJlY3Rpb24gZGV0YWlscy4KICAqICAtICJwcm90b2NvbGhhbmRsZXIscmVnaXN0 cmF0aW9uLHJlcXVlc3RlZCIsIEV3a19DdXN0b21fSGFuZGxlcl9EYXRhOiBhZGQgYSBoYW5kbGVy IHVybCBmb3IgdGhlIGdpdmVuIHByb3RvY29sLgpAQCAtMjc0Niw2ICsyNzQ3LDMzIEBAIEVBUEkg RXZhc19PYmplY3QqIGV3a192aWV3X3dlYl9pbnNwZWN0b3Jfdmlld19nZXQoY29uc3QgRXZhc19P YmplY3QgKm8pOwogICovCiBFQVBJIHZvaWQgZXdrX3ZpZXdfd2ViX2luc3BlY3Rvcl92aWV3X3Nl dChFdmFzX09iamVjdCAqbywgRXZhc19PYmplY3QgKmluc3BlY3Rvcl92aWV3KTsKIAorLyoqCisg KiBBZGQgcGVybWl0dGVkIG9yIGRlbmllZCBsaXN0IHRvIHRoZSBwZXJtaXNzaW9uIGNhY2hlIGZv ciBXZWIgTm90aWZpY2F0aW9ucy4KKyAqCisgKiBJZiB0aGVyZSBhcmUgc3RvcmVkIHBlcm1pc3Np b24gbGlzdHMgZm9yIFdlYiBOb3RpZmljYXRpb25zLAorICogdGhpcyBmdW5jdGlvbiBuZWVkIHRv IGJlIGNhbGxlZCB3aXRoIHBlcm1pc3Npb24uCisgKgorICogQHBhcmFtIG8gdmlldyBvYmplY3Qg dG8gc2V0IHRoZSBwZXJtaXNzaW9uIGNhY2hlIGxpc3QuCisgKiBAcGFyYW0gZG9tYWluIHN0cmlu ZyBmb3IgZGV0ZXJtaW5lIHRoZSBwZXJtaXNzaW9uLgorICogQHBhcmFtIHBlcm1pdHRlZCBAYyBF SU5BX1RSVUUgdG8gcGVybWl0LCBAYyBFSU5BX0ZBTFNFIHRvIGRlbnkuCisgKgorICogQHJldHVy biBAYyBFSU5BX1RSVUUgb24gc3VjY2VzcyBvciBAYyBFSU5BX0ZBTFNFIG9uIGZhaWx1cmUKKyAq LworRWluYV9Cb29sIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3N0b3JlKEV2YXNf T2JqZWN0ICpvLCBjb25zdCBjaGFyICpkb21haW4sIEVpbmFfQm9vbCBwZXJtaXR0ZWQpOworCisv KioKKyAqIFNldCBwZXJtaXR0ZWQgb3IgZGVuaWVkIGxpc3RzIHRvIHRoZSBwZXJtaXNzaW9uIGNh Y2hlIGZvciB0aGUgV2ViIE5vdGlmaWNhdGlvbnMuCisgKgorICogQWZ0ZXIgY2hlY2tpbmcgcGVy bWlzc2lvbiwgdGhpcyBmdW5jdGlvbiBoYXZlIHRvIGJlIGNhbGxlZCB0byBzZXQgcGVybWlzc2lv bi4KKyAqCisgKiBAcGFyYW0gbyB2aWV3IG9iamVjdCB0byBzZXQgdGhlIHBlcm1pc3Npb24uCisg KiBAcGFyYW0gb3JpZ2luIHNlY3VyaXR5IG9yaWdpbiBvYmplY3QKKyAqIEBwYXJhbSBwZXJtaXR0 ZWQgQGMgRUlOQV9UUlVFIHRvIHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0byBkZW55LgorICoKKyAq IEByZXR1cm4gQGMgRUlOQV9UUlVFIG9uIHN1Y2Nlc3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWls dXJlCisgKi8KK0VBUEkgRWluYV9Cb29sIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9u c19zZXQoRXZhc19PYmplY3QgKm8sIGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4gKm9yaWdpbiwg RWluYV9Cb29sIHBlcm1pdHRlZCk7CisKICNpZmRlZiBfX2NwbHVzcGx1cwogfQogI2VuZGlmCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5oIGIvU291 cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaAppbmRleCBkYWVlNjc3MzQ3Zjdk ZTJmZjI2MzRhYWNhMzEwYTIxZmJhZmYzZDE2Li5hZjJmOWQ1OTk3ZjM1Y2QwMWI4YjVkYWZmZTc3 ZDEzYTZiODFhMmZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdf cHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgK QEAgLTE1Niw2ICsxNTYsMTAgQEAgYm9vbCBld2tfdmlld19hY2NlbGVyYXRlZF9jb21wb3NpdGlu Z19vYmplY3RfY3JlYXRlKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBFdmFzX04KIFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dDNEKiBld2tfdmlld19hY2NlbGVyYXRlZF9jb21wb3NpdGluZ19jb250ZXh0 X2dldChFdmFzX09iamVjdCogZXdrVmlldyk7CiAjZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklD QVRJT05TKQordm9pZCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2 YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4pOwor I2VuZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRlIHsKIFdlYkNvcmU6OlBhZ2UgKmNvcmVQYWdl KGNvbnN0IEV2YXNfT2JqZWN0ICpld2tWaWV3KTsKIFBsYXRmb3JtUGFnZUNsaWVudCBjb3JlUGFn ZUNsaWVudChFdmFzX09iamVjdCogZXdrVmlldyk7Cg== 162660 2012-09-06 20:07:16 -0700 2012-09-07 02:10:58 -0700 Patch bug-90603-20120907120656.patch text/plain 13142 kihong.kwon U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3Njg0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggYjdmOGIxNTMx ZjMzMzE4NDJhYzk2YTExMjUyMGQ4MmRmN2EzNmY5Ni4uZGE3ODllZjliODBiYTY1ZTVmNjA1YjZm MTFhNjZmODRiMTc3Njg5MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEy LTA5LTA2ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgorCisgICAgICAg IFtFRkxdIFN1cHBvcnQgdGhlIHBlcm1pc3Npb24gZnVuY3Rpb24gb2YgdGhlIFdlYiBOb3RpZmlj YXRpb24uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 MDYwMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIElt cGxlbWVudCBwZXJtaXNzaW9uIHJlbGF0ZWQgZnVuY3Rpb25zIG9mIFdlYiBOb3RpZmljYXRpb25z LgorICAgICAgICBjaGVja1Blcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5wZXJtaXNzaW9uTGV2 ZWwoKS4KKyAgICAgICAgcmVxdWVzdFBlcm1pc3Npb24gZm9yIE5vdGlmaWNhdGlvbi5yZXF1ZXN0 UGVybWlzc2lvbigpLgorICAgICAgICBJbiBhZGRpdGlvbiwgaWYgdGhlIGFwcGxpY2F0aW9uKGxp a2UgYSBicm93c2VyKSBoYXMgcGVybWl0dGVkIGRvbWFpbnMgYWxyZWFkeSwKKyAgICAgICAgaXQg Y2FuIGJlIGNhY2hlZCB1c2luZyBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc3Rv cmUuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwpOgorICAgICAgICAoV2ViQ29yZTo6 Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpyZXF1ZXN0UGVybWlzc2lvbik6CisgICAg ICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6OmNoZWNrUGVybWlz c2lvbik6CisgICAgICAgIChXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6 OmFkZFRvUGVybWlzc2lvbkNhY2hlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2Vi Q29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpzZXRQZXJtaXNzaW9uKToKKyAg ICAgICAgKiBXZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaDoK KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50 RWZsKToKKyAgICAgICAgKFdlYkNvcmU6Ok5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6 cmVxdWVzdFBlcm1pc3Npb24pOgorICAgICAgICAoV2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2Vu dGVyQ2xpZW50RWZsOjpjYW5jZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24pOgorICAgICAgICAqIGV3 ay9ld2tfdmlldy5jcHA6CisgICAgICAgIChfZXdrX3ZpZXdfcHJpdl9uZXcpOgorICAgICAgICAo ZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fc3RvcmUpOgorICAgICAgICAoZXdrX3Zp ZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25zX3NldCk6CisgICAgICAgIChld2tfdmlld19ub3Rp ZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KToKKyAgICAgICAgKiBld2svZXdrX3ZpZXcuaDoK KyAgICAgICAgKiBld2svZXdrX3ZpZXdfcHJpdmF0ZS5oOgorCiAyMDEyLTA5LTA1ICBLYW5naWwg SGFuICA8a2FuZ2lsLmhhbkBzYW1zdW5nLmNvbT4KIAogICAgICAgICBbRUZMXSBSZW1vdmUgJys9 JyB1c2FnZSBpbiBTdHJpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVT dXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuY3BwCmlu ZGV4IGM0ZTVjYThkYTQ4YTcxYWNhMjQ3ZTg4MzMxNjRjMGNiYjk3YzRkNWQuLmRhYjM2YjZlMGEx MjU0YzE1NDAxMGI0ZTUwOWFlZGZiMzgxYjUxMDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv ZWZsL1dlYkNvcmVTdXBwb3J0L05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbC5jcHAKKysr IGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVy Q2xpZW50RWZsLmNwcApAQCAtMjAsMTMgKzIwLDIwIEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAj aW5jbHVkZSAiTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmgiCiAKLSNpZiBFTkFCTEUo Tk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9OT1RJRklDQVRJT05TKQorI2lmIEVOQUJM RShOT1RJRklDQVRJT05TKQogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCisjaW5jbHVkZSAi Tm90aWZpY2F0aW9uLmgiCisjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgorI2lu Y2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCisjaW5jbHVkZSAiZXdrX3NlY3VyaXR5X29yaWdpbl9w cml2YXRlLmgiCisjaW5jbHVkZSAiZXdrX3ZpZXdfcHJpdmF0ZS5oIgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKLU5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Tm90aWZpY2F0aW9uUHJl c2VudGVyQ2xpZW50RWZsKCkKK05vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Tm90aWZp Y2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KQorICAgIDogbV92aWV3 KHZpZXcpCiB7CisgICAgQVNTRVJUKG1fdmlldyk7CiB9CiAKIE5vdGlmaWNhdGlvblByZXNlbnRl ckNsaWVudEVmbDo6fk5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbCgpCkBAIC01NCwyMCAr NjEsNDIgQEAgdm9pZCBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmw6Om5vdGlmaWNhdGlv bkNvbnRyb2xsZXJEZXN0cm95ZWQoKQogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQg Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpyZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPFZvaWRDYWxsYmFjaz4gY2FsbGJh Y2spCit2b2lkIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6cmVxdWVzdFBlcm1pc3Np b24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxOb3RpZmljYXRp b25QZXJtaXNzaW9uQ2FsbGJhY2s+IGNhbGxiYWNrKQogewotICAgIG5vdEltcGxlbWVudGVkKCk7 CisgICAgRXdrX1NlY3VyaXR5X09yaWdpbiogb3JpZ2luID0gZXdrX3NlY3VyaXR5X29yaWdpbl9u ZXcoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKSk7CisgICAgbV9wZW5kaW5nUGVybWlzc2lvblJl cXVlc3RzLmFkZChvcmlnaW4sIGNhbGxiYWNrKTsKKyAgICBld2tfdmlld19ub3RpZmljYXRpb25f cGVybWlzc2lvbl9yZXF1ZXN0KG1fdmlldywgb3JpZ2luKTsKIH0KIAogTm90aWZpY2F0aW9uQ2xp ZW50OjpQZXJtaXNzaW9uIE5vdGlmaWNhdGlvblByZXNlbnRlckNsaWVudEVmbDo6Y2hlY2tQZXJt aXNzaW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQpCiB7Ci0gICAgbm90SW1wbGVt ZW50ZWQoKTsKKyAgICBQZXJtaXNzaW9uc01hcDo6aXRlcmF0b3IgaXQgPSBtX2NhY2hlZFBlcm1p c3Npb25zLmZpbmQoY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKSk7CisgICAg aWYgKGl0ID09IG1fY2FjaGVkUGVybWlzc2lvbnMuZW5kKCkpCisgICAgICAgIHJldHVybiBQZXJt aXNzaW9uTm90QWxsb3dlZDsKKyAgICBpZiAoaXQtPnNlY29uZCkKKyAgICAgICAgcmV0dXJuIFBl cm1pc3Npb25BbGxvd2VkOworCiAgICAgcmV0dXJuIFBlcm1pc3Npb25EZW5pZWQ7CiB9CiAKLXZv aWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpjYW5jZWxSZXF1ZXN0c0ZvclBlcm1p c3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCkKK3ZvaWQgTm90aWZpY2F0aW9u UHJlc2VudGVyQ2xpZW50RWZsOjphZGRUb1Blcm1pc3Npb25DYWNoZShjb25zdCBTdHJpbmcmIGRv bWFpbiwgY29uc3QgYm9vbCBpc1Blcm1pdHRlZCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwor ICAgIFBlcm1pc3Npb25zTWFwOjppdGVyYXRvciBpdCA9IG1fY2FjaGVkUGVybWlzc2lvbnMuZmlu ZChkb21haW4pOworICAgIGlmIChpdCAhPSBtX2NhY2hlZFBlcm1pc3Npb25zLmVuZCgpKQorICAg ICAgICByZXR1cm47CisgICAgbV9jYWNoZWRQZXJtaXNzaW9ucy5hZGQoZG9tYWluLCBpc1Blcm1p dHRlZCk7Cit9CisKK3ZvaWQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsOjpzZXRQZXJt aXNzaW9uKGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4qIG9yaWdpbiwgY29uc3QgYm9vbCBpc1Bl cm1pdHRlZCkKK3sKKyAgICBQZXJtaXNzaW9uUmVxdWVzdE1hcDo6aXRlcmF0b3IgaXQgPSBtX3Bl bmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZmluZChvcmlnaW4pOworICAgIGlmIChpdCA9PSBtX3Bl bmRpbmdQZXJtaXNzaW9uUmVxdWVzdHMuZW5kKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGl0 LT5zZWNvbmQtPmhhbmRsZUV2ZW50KE5vdGlmaWNhdGlvbjo6cGVybWlzc2lvblN0cmluZyhpc1Bl cm1pdHRlZCA/IE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbkFsbG93ZWQgOiBOb3RpZmlj YXRpb25DbGllbnQ6OlBlcm1pc3Npb25EZW5pZWQpKTsKKyAgICBtX3BlbmRpbmdQZXJtaXNzaW9u UmVxdWVzdHMucmVtb3ZlKGl0KTsKKyAgICBtX2NhY2hlZFBlcm1pc3Npb25zLmFkZChTdHJpbmc6 OmZyb21VVEY4KGV3a19zZWN1cml0eV9vcmlnaW5fc3RyaW5nX2dldChvcmlnaW4pKSwgaXNQZXJt aXR0ZWQpOworICAgIGV3a19zZWN1cml0eV9vcmlnaW5fZnJlZShjb25zdF9jYXN0PEV3a19TZWN1 cml0eV9PcmlnaW4qPihvcmlnaW4pKTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9lZmwvV2ViQ29yZVN1cHBvcnQvTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsLmggYi9T b3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGll bnRFZmwuaAppbmRleCBlY2U1Y2NmZTRiNjVkMTM1YTgxOGJkOTlmMTI0NTk1ZTAwYTJiZmUxLi43 MzA2MzY4NzI1NzAzZjRjMmRlZmFmOGVmY2Y1ODJhNGIzNmU0YjY4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRF ZmwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9Ob3RpZmljYXRpb25Q cmVzZW50ZXJDbGllbnRFZmwuaApAQCAtMjAsMjUgKzIwLDQzIEBACiAjaWZuZGVmIE5vdGlmaWNh dGlvblByZXNlbnRlckNsaWVudEVmbF9oCiAjZGVmaW5lIE5vdGlmaWNhdGlvblByZXNlbnRlckNs aWVudEVmbF9oCiAKLSNpZiBFTkFCTEUoTk9USUZJQ0FUSU9OUykgfHwgRU5BQkxFKExFR0FDWV9O T1RJRklDQVRJT05TKQotI2luY2x1ZGUgIk5vdGlmaWNhdGlvbi5oIgorI2lmIEVOQUJMRShOT1RJ RklDQVRJT05TKQogI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNsaWVudC5oIgorI2luY2x1ZGUgImV3 a19zZWN1cml0eV9vcmlnaW4uaCIKKyNpbmNsdWRlIDxFdmFzLmg+CisjaW5jbHVkZSA8d3RmL0hh c2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAogbmFtZXNwYWNlIFdl YkNvcmUgewogCi1jbGFzcyBOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwgOiBwdWJsaWMg Tm90aWZpY2F0aW9uQ2xpZW50IHsKK2NsYXNzIE5vdGlmaWNhdGlvbjsKIAorY2xhc3MgTm90aWZp Y2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsIDogcHVibGljIE5vdGlmaWNhdGlvbkNsaWVudCB7CiBw dWJsaWM6Ci0gICAgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CisgICAgZXhwbGlj aXQgTm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKEV2YXNfT2JqZWN0KiB2aWV3KTsKICAg ICB+Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKCk7CiAKICAgICB2aXJ0dWFsIGJvb2wg c2hvdyhOb3RpZmljYXRpb24qKTsKICAgICB2aXJ0dWFsIHZvaWQgY2FuY2VsKE5vdGlmaWNhdGlv biopOwogICAgIHZpcnR1YWwgdm9pZCBub3RpZmljYXRpb25PYmplY3REZXN0cm95ZWQoTm90aWZp Y2F0aW9uKik7CiAgICAgdmlydHVhbCB2b2lkIG5vdGlmaWNhdGlvbkNvbnRyb2xsZXJEZXN0cm95 ZWQoKTsKLSAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9u Q29udGV4dCosIFBhc3NSZWZQdHI8Vm9pZENhbGxiYWNrPik7CisjaWYgRU5BQkxFKExFR0FDWV9O T1RJRklDQVRJT05TKQorICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRF eGVjdXRpb25Db250ZXh0KiwgUGFzc1JlZlB0cjxWb2lkQ2FsbGJhY2s+KSB7IH0KKyNlbmRpZgor ICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVybWlzc2lvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0 KiwgUGFzc1JlZlB0cjxOb3RpZmljYXRpb25QZXJtaXNzaW9uQ2FsbGJhY2s+KTsKICAgICB2aXJ0 dWFsIE5vdGlmaWNhdGlvbkNsaWVudDo6UGVybWlzc2lvbiBjaGVja1Blcm1pc3Npb24oU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCopOwotICAgIHZpcnR1YWwgdm9pZCBjYW5jZWxSZXF1ZXN0c0ZvclBl cm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOworICAgIHZpcnR1YWwgdm9pZCBjYW5j ZWxSZXF1ZXN0c0ZvclBlcm1pc3Npb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopIHsgfQorCisg ICAgdm9pZCBhZGRUb1Blcm1pc3Npb25DYWNoZShjb25zdCBTdHJpbmcmIGRvbWFpbiwgYm9vbCBp c1Blcm1pdHRlZCk7CisgICAgdm9pZCBzZXRQZXJtaXNzaW9uKGNvbnN0IEV3a19TZWN1cml0eV9P cmlnaW4qLCBib29sIGlzUGVybWl0dGVkKTsKKworcHJpdmF0ZToKKyAgICBFdmFzX09iamVjdCog bV92aWV3OworCisgICAgdHlwZWRlZiBIYXNoTWFwPGNvbnN0IEV3a19TZWN1cml0eV9PcmlnaW4q LCBSZWZQdHI8V2ViQ29yZTo6Tm90aWZpY2F0aW9uUGVybWlzc2lvbkNhbGxiYWNrPiA+IFBlcm1p c3Npb25SZXF1ZXN0TWFwOworICAgIFBlcm1pc3Npb25SZXF1ZXN0TWFwIG1fcGVuZGluZ1Blcm1p c3Npb25SZXF1ZXN0czsKKyAgICB0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBib29sPiBQZXJtaXNz aW9uc01hcDsKKyAgICBQZXJtaXNzaW9uc01hcCBtX2NhY2hlZFBlcm1pc3Npb25zOwogfTsKIAog fQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcCBiL1NvdXJj ZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKaW5kZXggNDk0OWFhYzRlMjdiNmY3ZGMyODAx NTJhNmMxNmZhNDUyZjM5MTQxMi4uZGM1ODEyNzgwNTliNTNkNjhiZWI2OGI0ODJlZThjZmRhNWJk NWUwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3BwCkBAIC0xMDksNiArMTA5LDExIEBA CiAjaW5jbHVkZSAiTmF2aWdhdG9yQ29udGVudFV0aWxzQ2xpZW50RWZsLmgiCiAjZW5kaWYKIAor I2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQorI2luY2x1ZGUgIk5vdGlmaWNhdGlvbkNvbnRyb2xs ZXIuaCIKKyNpbmNsdWRlICJOb3RpZmljYXRpb25QcmVzZW50ZXJDbGllbnRFZmwuaCIKKyNlbmRp ZgorCiBzdGF0aWMgY29uc3QgZmxvYXQgem9vbU1pbmltdW0gPSAwLjA1Owogc3RhdGljIGNvbnN0 IGZsb2F0IHpvb21NYXhpbXVtID0gNC4wOwogCkBAIC03NzUsNiArNzgwLDEwIEBAIHN0YXRpYyBF d2tfVmlld19Qcml2YXRlX0RhdGEqIF9ld2tfdmlld19wcml2X25ldyhFd2tfVmlld19TbWFydF9E YXRhKiBzbWFydERhdGEpCiAgICAgV2ViQ29yZTo6cHJvdmlkZU5hdmlnYXRvckNvbnRlbnRVdGls c1RvKHByaXYtPnBhZ2UuZ2V0KCksIHByaXYtPm5hdmlnYXRvckNvbnRlbnRVdGlsc0NsaWVudC5n ZXQoKSk7CiAjZW5kaWYKIAorI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQorICAgIFdlYkNvcmU6 OnByb3ZpZGVOb3RpZmljYXRpb24ocHJpdi0+cGFnZS5nZXQoKSwgbmV3IFdlYkNvcmU6Ok5vdGlm aWNhdGlvblByZXNlbnRlckNsaWVudEVmbChzbWFydERhdGEtPnNlbGYpKTsKKyNlbmRpZgorCiAg ICAgcHJpdi0+cGFnZVNldHRpbmdzID0gcHJpdi0+cGFnZS0+c2V0dGluZ3MoKTsKIAogICAgIHBy aXYtPnZpZXdwb3J0QXJndW1lbnRzLndpZHRoID0gV2ViQ29yZTo6Vmlld3BvcnRBcmd1bWVudHM6 OlZhbHVlQXV0bzsKQEAgLTQ1NjUsNiArNDU3NCwzNyBAQCB2b2lkIGV3a192aWV3X2N1cnNvcl9z ZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcsIGNvbnN0IFdlYkNvcmU6OkN1cnNvciYgY3Vyc29yKQog ICAgIH0KIH0KIAorRWluYV9Cb29sIGV3a192aWV3X25vdGlmaWNhdGlvbl9wZXJtaXNzaW9uX3N0 b3JlKEV2YXNfT2JqZWN0KiBld2tWaWV3LCBjb25zdCBjaGFyKiBkb21haW4sIEVpbmFfQm9vbCBw ZXJtaXR0ZWQpCit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdfU0Rf R0VUX09SX1JFVFVSTihld2tWaWV3LCBzbWFydERhdGEsIGZhbHNlKTsKKyAgICBFV0tfVklFV19Q UklWX0dFVF9PUl9SRVRVUk4oc21hcnREYXRhLCBwcml2LCBmYWxzZSk7CisgICAgc3RhdGljX2Nh c3Q8V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKj4oV2ViQ29yZTo6Tm90 aWZpY2F0aW9uQ29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2LT5wYWdlLmdldCgpKSktPmFkZFRv UGVybWlzc2lvbkNhY2hlKFN0cmluZzo6ZnJvbVVURjgoZG9tYWluKSwgcGVybWl0dGVkKTsKKyAg ICByZXR1cm4gdHJ1ZTsKKyNlbHNlCisgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCit9CisKK0Vp bmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbnNfc2V0KEV2YXNfT2JqZWN0 KiBld2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4sIEVpbmFfQm9vbCBw ZXJtaXR0ZWQpCit7CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgRVdLX1ZJRVdfU0Rf R0VUX09SX1JFVFVSTihld2tWaWV3LCBzbWFydERhdGEsIGZhbHNlKTsKKyAgICBFV0tfVklFV19Q UklWX0dFVF9PUl9SRVRVUk4oc21hcnREYXRhLCBwcml2LCBmYWxzZSk7CisgICAgc3RhdGljX2Nh c3Q8V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyQ2xpZW50RWZsKj4oV2ViQ29yZTo6Tm90 aWZpY2F0aW9uQ29udHJvbGxlcjo6Y2xpZW50RnJvbShwcml2LT5wYWdlLmdldCgpKSktPnNldFBl cm1pc3Npb24ob3JpZ2luLCBwZXJtaXR0ZWQpOworICAgIHJldHVybiB0cnVlOworI2Vsc2UKKyAg ICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKworI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQor dm9pZCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9yZXF1ZXN0KEV2YXNfT2JqZWN0 KiBld2tWaWV3LCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luKiBvcmlnaW4pCit7CisgICAgZXZh c19vYmplY3Rfc21hcnRfY2FsbGJhY2tfY2FsbChld2tWaWV3LCAibm90aWZpY2F0aW9uLHBlcm1p c3Npb24scmVxdWVzdCIsIGNvbnN0X2Nhc3Q8RXdrX1NlY3VyaXR5X09yaWdpbio+KG9yaWdpbikp OworfQorI2VuZGlmCisKIG5hbWVzcGFjZSBFV0tQcml2YXRlIHsKIAogV2ViQ29yZTo6UGFnZSog Y29yZVBhZ2UoY29uc3QgRXZhc19PYmplY3QqIGV3a1ZpZXcpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmll dy5oCmluZGV4IDJhMjYwZjFkZTg3MzEzZWVmNWM2YzE4MzhmMzA2ZjA0NmM2ZDM1OGEuLjkzZGM3 Y2ZiZjM5ZDI3N2RiMmRhNmM0YjYxNDg4Y2Q5MjhmYjRiYmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tf dmlldy5oCkBAIC03NCw2ICs3NCw3IEBACiAgKiAgLSAibWl4ZWRjb250ZW50LGRpc3BsYXllZCIs IHZvaWQ6IGFueSBvZiB0aGUgY29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgZGlzcGxh eWVkIG1peGVkIGNvbnRlbnQuCiAgKiAgLSAibWl4ZWRjb250ZW50LHJ1biIsIHZvaWQ6IGFueSBv ZiB0aGUgY29udGFpbmluZyBmcmFtZXMgaGFzIGxvYWRlZCBhbmQgcnVuIG1peGVkIGNvbnRlbnQu CiAgKiAgLSAibmF2aWdhdGUsd2l0aCxkYXRhIiwgRXdrX1ZpZXdfTmF2aWdhdGlvbl9EYXRhKjog cmVwb3J0cyB0aGF0IHZpZXcgZGlkIG5hdmlnYXRpb24gYW5kIGdpdmVzIHRoZSBuYXZpZ2F0aW9u IGRldGFpbHMuCisgKiAgLSAibm90aWZpY2F0aW9uLHBlcm1pc3Npb24scmVxdWVzdCIsIGNvbnN0 IEV3a19TZWN1cml0eV9PcmlnaW4qOiByZXF1ZXN0IHRvIGNvbmZpcm0gcGVybWlzc2lvbiBmb3Ig c2VjdXJpdHkgb3JpZ2luIGZyb20gdXNlci4KICAqICAtICJwZXJmb3JtLGNsaWVudCxyZWRpcmVj dCIsIEV3a19WaWV3X1JlZGlyZWN0aW9uX0RhdGEqOiByZXBvcnRzIHRoYXQgdmlldyBwZXJmb3Jt ZWQgYSBjbGllbnQgcmVkaXJlY3QgYW5kIGdpdmVzIHRoZSByZWRpcmVjdGlvbiBkZXRhaWxzLgog ICogIC0gInBlcmZvcm0sc2VydmVyLHJlZGlyZWN0IiwgRXdrX1ZpZXdfUmVkaXJlY3Rpb25fRGF0 YSo6IHJlcG9ydHMgdGhhdCB2aWV3IHBlcmZvcm1lZCBhIHNlcnZlciByZWRpcmVjdCBhbmQgZ2l2 ZXMgdGhlIHJlZGlyZWN0aW9uIGRldGFpbHMuCiAgKiAgLSAicHJvdG9jb2xoYW5kbGVyLHJlZ2lz dHJhdGlvbixyZXF1ZXN0ZWQiLCBFd2tfQ3VzdG9tX0hhbmRsZXJfRGF0YTogYWRkIGEgaGFuZGxl ciB1cmwgZm9yIHRoZSBnaXZlbiBwcm90b2NvbC4KQEAgLTI3NDYsNiArMjc0NywzMyBAQCBFQVBJ IEV2YXNfT2JqZWN0KiBld2tfdmlld193ZWJfaW5zcGVjdG9yX3ZpZXdfZ2V0KGNvbnN0IEV2YXNf T2JqZWN0ICpvKTsKICAqLwogRUFQSSB2b2lkIGV3a192aWV3X3dlYl9pbnNwZWN0b3Jfdmlld19z ZXQoRXZhc19PYmplY3QgKm8sIEV2YXNfT2JqZWN0ICppbnNwZWN0b3Jfdmlldyk7CiAKKy8qKgor ICogQWRkIHBlcm1pdHRlZCBvciBkZW5pZWQgbGlzdCB0byB0aGUgcGVybWlzc2lvbiBjYWNoZSBm b3IgV2ViIE5vdGlmaWNhdGlvbnMuCisgKgorICogSWYgdGhlcmUgYXJlIHN0b3JlZCBwZXJtaXNz aW9uIGxpc3RzIGZvciBXZWIgTm90aWZpY2F0aW9ucywKKyAqIHRoaXMgZnVuY3Rpb24gbmVlZCB0 byBiZSBjYWxsZWQgd2l0aCBwZXJtaXNzaW9uLgorICoKKyAqIEBwYXJhbSBvIHZpZXcgb2JqZWN0 IHRvIHNldCB0aGUgcGVybWlzc2lvbiBjYWNoZSBsaXN0LgorICogQHBhcmFtIGRvbWFpbiBzdHJp bmcgZm9yIGRldGVybWluZSB0aGUgcGVybWlzc2lvbi4KKyAqIEBwYXJhbSBwZXJtaXR0ZWQgQGMg RUlOQV9UUlVFIHRvIHBlcm1pdCwgQGMgRUlOQV9GQUxTRSB0byBkZW55LgorICoKKyAqIEByZXR1 cm4gQGMgRUlOQV9UUlVFIG9uIHN1Y2Nlc3Mgb3IgQGMgRUlOQV9GQUxTRSBvbiBmYWlsdXJlCisg Ki8KK0VpbmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lvbl9zdG9yZShFdmFz X09iamVjdCAqbywgY29uc3QgY2hhciAqZG9tYWluLCBFaW5hX0Jvb2wgcGVybWl0dGVkKTsKKwor LyoqCisgKiBTZXQgcGVybWl0dGVkIG9yIGRlbmllZCBsaXN0cyB0byB0aGUgcGVybWlzc2lvbiBj YWNoZSBmb3IgdGhlIFdlYiBOb3RpZmljYXRpb25zLgorICoKKyAqIEFmdGVyIGNoZWNraW5nIHBl cm1pc3Npb24sIHRoaXMgZnVuY3Rpb24gaGF2ZSB0byBiZSBjYWxsZWQgdG8gc2V0IHBlcm1pc3Np b24uCisgKgorICogQHBhcmFtIG8gdmlldyBvYmplY3QgdG8gc2V0IHRoZSBwZXJtaXNzaW9uLgor ICogQHBhcmFtIG9yaWdpbiBzZWN1cml0eSBvcmlnaW4gb2JqZWN0CisgKiBAcGFyYW0gcGVybWl0 dGVkIEBjIEVJTkFfVFJVRSB0byBwZXJtaXQsIEBjIEVJTkFfRkFMU0UgdG8gZGVueS4KKyAqCisg KiBAcmV0dXJuIEBjIEVJTkFfVFJVRSBvbiBzdWNjZXNzIG9yIEBjIEVJTkFfRkFMU0Ugb24gZmFp bHVyZQorICovCitFQVBJIEVpbmFfQm9vbCBld2tfdmlld19ub3RpZmljYXRpb25fcGVybWlzc2lv bnNfc2V0KEV2YXNfT2JqZWN0ICpvLCBjb25zdCBFd2tfU2VjdXJpdHlfT3JpZ2luICpvcmlnaW4s IEVpbmFfQm9vbCBwZXJtaXR0ZWQpOworCiAjaWZkZWYgX19jcGx1c3BsdXMKIH0KICNlbmRpZgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3X3ByaXZhdGUuaCBiL1Nv dXJjZS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlld19wcml2YXRlLmgKaW5kZXggZGFlZTY3NzM0N2Y3 ZGUyZmYyNjM0YWFjYTMxMGEyMWZiYWZmM2QxNi4uYWYyZjlkNTk5N2YzNWNkMDFiOGI1ZGFmZmU3 N2QxM2E2YjgxYTJmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvZXdrL2V3a192aWV3 X3ByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXdfcHJpdmF0ZS5o CkBAIC0xNTYsNiArMTU2LDEwIEBAIGJvb2wgZXdrX3ZpZXdfYWNjZWxlcmF0ZWRfY29tcG9zaXRp bmdfb2JqZWN0X2NyZWF0ZShFdmFzX09iamVjdCogZXdrVmlldywgRXZhc19OCiBXZWJDb3JlOjpH cmFwaGljc0NvbnRleHQzRCogZXdrX3ZpZXdfYWNjZWxlcmF0ZWRfY29tcG9zaXRpbmdfY29udGV4 dF9nZXQoRXZhc19PYmplY3QqIGV3a1ZpZXcpOwogI2VuZGlmCiAKKyNpZiBFTkFCTEUoTk9USUZJ Q0FUSU9OUykKK3ZvaWQgZXdrX3ZpZXdfbm90aWZpY2F0aW9uX3Blcm1pc3Npb25fcmVxdWVzdChF dmFzX09iamVjdCogZXdrVmlldywgY29uc3QgRXdrX1NlY3VyaXR5X09yaWdpbiogb3JpZ2luKTsK KyNlbmRpZgorCiBuYW1lc3BhY2UgRVdLUHJpdmF0ZSB7CiBXZWJDb3JlOjpQYWdlICpjb3JlUGFn ZShjb25zdCBFdmFzX09iamVjdCAqZXdrVmlldyk7CiBQbGF0Zm9ybVBhZ2VDbGllbnQgY29yZVBh Z2VDbGllbnQoRXZhc19PYmplY3QqIGV3a1ZpZXcpOwo=