109977 2013-02-15 15:26:31 -0800 Add HashMap::isGoodKey and HashSet::isGoodValue 2013-02-15 17:02:39 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 andersca andersca benjamin cmarcelo darin ojan.autocc webkit.review.bot oldest_to_newest 834421 0 andersca 2013-02-15 15:26:31 -0800 Add HashMap::isGoodKey and HashSet::isGoodValue 834427 1 188655 andersca 2013-02-15 15:45:08 -0800 Created attachment 188655 Patch 834447 2 188655 sam 2013-02-15 16:05:39 -0800 Comment on attachment 188655 Patch Nice, I should have done this awhile ago. Do you think we should call it isValidKey(). 834449 3 188655 darin 2013-02-15 16:09:09 -0800 Comment on attachment 188655 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188655&action=review More comments to come, but since Sam just gave you review+ I rushed to get these comments in. > Source/WTF/ChangeLog:14 > + (HashMap): > + (WTF::::isGoodKey): > + (WTF): Yuck, please delete or fix this. > Source/WTF/ChangeLog:18 > + (HashSet): > + (WTF): > + (WTF::::isGoodValue): Yuck, please delete or fix this. > Source/WTF/wtf/HashMap.h:419 > template<typename T, typename U, typename V, typename W, typename X> > + inline bool HashMap<T, U, V, W, X>::isGoodKey(const KeyType& key) > + { > + return key != KeyTraits::emptyValue() && !KeyTraits::isDeletedValue(key); > + } I believe this function is not safe for all types. Our hash tables support types where it is not safe to compare with empty using == or != and the traits identify such types. It’s tricky for a hash map user to know you can’t call this newly added function on all maps. I don’t know whether it will be a compile time failure or runtime failure. I’d prefer a brief comment about this just above the declaration. > Source/WTF/wtf/HashSet.h:218 > + template<typename T, typename U, typename V> > + bool HashSet<T, U, V>::isGoodValue(const ValueType& value) > + { > + return value != ValueTraits::emptyValue() && !ValueTraits::isDeletedValue(value); > + } Did you intentionally choose not to inline this? I ask because you marked the HashMap version inline. Also, same concerns as for the HashMap function. > Source/WebKit2/UIProcess/WebProcessProxy.cpp:75 > - static uint64_t uniquePageID = 1; > - return uniquePageID++; > + static uint64_t uniquePageID; > + return ++uniquePageID; This tweak looks fine, but unrelated to the rest of the patch. You should at least mention it in the change log. > Source/WebKit2/UIProcess/WebProcessProxy.cpp:458 > - return isGoodKey<WebFrameProxyMap>(frameID) ? m_frameMap.get(frameID).get() : 0; > + if (!m_frameMap.isGoodKey(frameID)) > + return 0; > + > + return m_frameMap.get(frameID).get(); I think it would be slightly clearer to use the type of m_frameMap here instead of using m_frameMap itself to call the static member function. Also, is it really that much better to use an if with a return? > Source/WebKit2/UIProcess/WebProcessProxy.cpp:463 > + return m_frameMap.isGoodKey(frameID) && !m_frameMap.contains(frameID); Ditto. > Source/WebKit2/UIProcess/WebProcessProxy.cpp:477 > + ASSERT(m_frameMap.isGoodKey(frameID)); Ditto. 834452 4 188655 darin 2013-02-15 16:12:14 -0800 Comment on attachment 188655 Patch The function that does this same operation when it can safely, as an assertion, is HashTable::checkKey. These new functions will work on some maps and sets and not on others. 834454 5 darin 2013-02-15 16:12:38 -0800 Those are all of my comments. 834457 6 benjamin 2013-02-15 16:16:04 -0800 > > Source/WTF/wtf/HashMap.h:419 > > template<typename T, typename U, typename V, typename W, typename X> > > + inline bool HashMap<T, U, V, W, X>::isGoodKey(const KeyType& key) > > + { > > + return key != KeyTraits::emptyValue() && !KeyTraits::isDeletedValue(key); > > + } > > I believe this function is not safe for all types. Our hash tables support types where it is not safe to compare with empty using == or != and the traits identify such types. It’s tricky for a hash map user to know you can’t call this newly added function on all maps. I don’t know whether it will be a compile time failure or runtime failure. I’d prefer a brief comment about this just above the declaration. This! I am not sure HashMap is the right place because of this. 834461 7 andersca 2013-02-15 16:16:47 -0800 (In reply to comment #3) > (From update of attachment 188655 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188655&action=review > > More comments to come, but since Sam just gave you review+ I rushed to get these comments in. > > > Source/WTF/wtf/HashMap.h:419 > > template<typename T, typename U, typename V, typename W, typename X> > > + inline bool HashMap<T, U, V, W, X>::isGoodKey(const KeyType& key) > > + { > > + return key != KeyTraits::emptyValue() && !KeyTraits::isDeletedValue(key); > > + } > > I believe this function is not safe for all types. Our hash tables support types where it is not safe to compare with empty using == or != and the traits identify such types. It’s tricky for a hash map user to know you can’t call this newly added function on all maps. I don’t know whether it will be a compile time failure or runtime failure. I’d prefer a brief comment about this just above the declaration. Good point. I can add a COMPILE_ASSERT that safeToCompareToEmptyOrDeleted is true. > > > Source/WTF/wtf/HashSet.h:218 > > + template<typename T, typename U, typename V> > > + bool HashSet<T, U, V>::isGoodValue(const ValueType& value) > > + { > > + return value != ValueTraits::emptyValue() && !ValueTraits::isDeletedValue(value); > > + } > > Did you intentionally choose not to inline this? I ask because you marked the HashMap version inline. Nope, that was just an oversight. > > Also, same concerns as for the HashMap function. > > > Source/WebKit2/UIProcess/WebProcessProxy.cpp:75 > > - static uint64_t uniquePageID = 1; > > - return uniquePageID++; > > + static uint64_t uniquePageID; > > + return ++uniquePageID; > > This tweak looks fine, but unrelated to the rest of the patch. You should at least mention it in the change log. > > > Source/WebKit2/UIProcess/WebProcessProxy.cpp:458 > > - return isGoodKey<WebFrameProxyMap>(frameID) ? m_frameMap.get(frameID).get() : 0; > > + if (!m_frameMap.isGoodKey(frameID)) > > + return 0; > > + > > + return m_frameMap.get(frameID).get(); > > I think it would be slightly clearer to use the type of m_frameMap here instead of using m_frameMap itself to call the static member function. I thought it was clever, but I’ll change it since we have a typedef. > > Also, is it really that much better to use an if with a return? I think that it’s easier to read; just my personal opinion though. 834465 8 188655 darin 2013-02-15 16:19:45 -0800 Comment on attachment 188655 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188655&action=review >>> Source/WTF/wtf/HashMap.h:419 >>> + } >> >> I believe this function is not safe for all types. Our hash tables support types where it is not safe to compare with empty using == or != and the traits identify such types. It’s tricky for a hash map user to know you can’t call this newly added function on all maps. I don’t know whether it will be a compile time failure or runtime failure. I’d prefer a brief comment about this just above the declaration. > > Good point. I can add a COMPILE_ASSERT that safeToCompareToEmptyOrDeleted is true. Even when safe I am not 100% sure that you can just call isDeletedValue without involving the translator. I guess that extra complexity is only needed inside the HashTable class, not here in the HashMap and HashSet classes; translators are used to implement HashMap and the special translated add functions but probably not an issue here. 834472 9 andersca 2013-02-15 16:26:26 -0800 (In reply to comment #8) > (From update of attachment 188655 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188655&action=review > > >>> Source/WTF/wtf/HashMap.h:419 > >>> + } > >> > >> I believe this function is not safe for all types. Our hash tables support types where it is not safe to compare with empty using == or != and the traits identify such types. It’s tricky for a hash map user to know you can’t call this newly added function on all maps. I don’t know whether it will be a compile time failure or runtime failure. I’d prefer a brief comment about this just above the declaration. > > > > Good point. I can add a COMPILE_ASSERT that safeToCompareToEmptyOrDeleted is true. > > Even when safe I am not 100% sure that you can just call isDeletedValue without involving the translator. I guess that extra complexity is only needed inside the HashTable class, not here in the HashMap and HashSet classes; translators are used to implement HashMap and the special translated add functions but probably not an issue here. Right, I don’t think it’s an issue. I also though about something like: template<typename T, typename U, typename V, typename W, typename X> inline bool HashMap<T, U, V, W, X>::isValidKey(const KeyType& key) { if (KeyTraits::isDeletedValue(key)) return false; if (HashFunctions::safeToCompareToEmptyOrDeleted) { if (key == KeyTraits::emptyValue()) return false; if (isHashTraitsEmptyValue<KeyTraits>(key)) return false; } return true; } but I’m not sure if it’s better. 834474 10 188655 darin 2013-02-15 16:27:36 -0800 Comment on attachment 188655 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188655&action=review >>>>> Source/WTF/wtf/HashMap.h:419 >>>>> + } >>>> >>>> I believe this function is not safe for all types. Our hash tables support types where it is not safe to compare with empty using == or != and the traits identify such types. It’s tricky for a hash map user to know you can’t call this newly added function on all maps. I don’t know whether it will be a compile time failure or runtime failure. I’d prefer a brief comment about this just above the declaration. >>> >>> Good point. I can add a COMPILE_ASSERT that safeToCompareToEmptyOrDeleted is true. >> >> Even when safe I am not 100% sure that you can just call isDeletedValue without involving the translator. I guess that extra complexity is only needed inside the HashTable class, not here in the HashMap and HashSet classes; translators are used to implement HashMap and the special translated add functions but probably not an issue here. > > Right, I don’t think it’s an issue. I also though about something like: > > template<typename T, typename U, typename V, typename W, typename X> > inline bool HashMap<T, U, V, W, X>::isValidKey(const KeyType& key) > { > if (KeyTraits::isDeletedValue(key)) > return false; > > if (HashFunctions::safeToCompareToEmptyOrDeleted) { > if (key == KeyTraits::emptyValue()) > return false; > if (isHashTraitsEmptyValue<KeyTraits>(key)) > return false; > } > > return true; > } > > but I’m not sure if it’s better. It’s definitely not better. A function that lies to you and returns true when it doesn’t know!!! 834477 11 andersca 2013-02-15 16:28:29 -0800 Err, I meant template<typename T, typename U, typename V, typename W, typename X> inline bool HashMap<T, U, V, W, X>::isValidKey(const KeyType& key) { if (KeyTraits::isDeletedValue(key)) return false; if (HashFunctions::safeToCompareToEmptyOrDeleted) { if (key == KeyTraits::emptyValue()) return false; } else { if (isHashTraitsEmptyValue<KeyTraits>(key)) return false; } return true; } 834479 12 darin 2013-02-15 16:30:12 -0800 Something like that is OK if it would actually make this function work for more key types. I’m not sure it would, though. It’s hard to think these things through in the abstract. 834514 13 andersca 2013-02-15 17:02:39 -0800 Committed r143071: <http://trac.webkit.org/changeset/143071> 188655 2013-02-15 15:45:08 -0800 2013-02-15 16:27:36 -0800 Patch bug-109977-20130215154134.patch text/plain 5583 andersca U3VidmVyc2lvbiBSZXZpc2lvbjogMTQzMDUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDQ2MTllOTdjYzYxMzVkNGRiOTRiOTQw OTRhZWMyYWE2OTIyOTQ0MmIuLmNmMmVmODI2MjQ2MDkzYmM0N2M3YTNjNzcxNTE5YzhjMDI1ZGFh OTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTMtMDItMTUgIEFuZGVycyBDYXJsc3NvbiAgPGFu ZGVyc2NhQGFwcGxlLmNvbT4KKworICAgICAgICBBZGQgSGFzaE1hcDo6aXNHb29kS2V5IGFuZCBI YXNoU2V0Ojppc0dvb2RWYWx1ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTA5OTc3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQWRkIGhlbHBlciBmdW5jdGlvbnMgZm9yIGRldGVybWluaW5nIHdoZXRoZXIg a2V5cyBhcmUgZ29vZCwgaS5lLiBpZgorICAgICAgICB0aGV5IGFyZSBfbm90XyBlbXB0eSBvciBk ZWxldGVkIGFjY29yZGluZyB0byB0aGUgaGFzaCB0cmFpdHMuCisKKyAgICAgICAgKiB3dGYvSGFz aE1hcC5oOgorICAgICAgICAoSGFzaE1hcCk6CisgICAgICAgIChXVEY6Ojo6aXNHb29kS2V5KToK KyAgICAgICAgKFdURik6CisgICAgICAgICogd3RmL0hhc2hTZXQuaDoKKyAgICAgICAgKEhhc2hT ZXQpOgorICAgICAgICAoV1RGKToKKyAgICAgICAgKFdURjo6Ojppc0dvb2RWYWx1ZSk6CisKIDIw MTMtMDItMTUgIENocmlzdG9waGUgRHVtZXogIDxjaC5kdW1lekBzaXNhLnNhbXN1bmcuY29tPgog CiAgICAgICAgIEFkZCBDU3RyaW5nIG9wZXJhdG9ycyBmb3IgY29tcGFyaXNvbiB3aXRoIGNvbnN0 IGNoYXIqCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKaW5kZXggOWMxMzkzNDg1MjYxMGVlYTk0Y2E4MWUwN2NjOTdkZGUyNmJi NGY3ZC4uZmNlZTc0YTM0OTgwYzBmMGJmMTlmOTk2ZDdjZjZjMWZhOGQ3ZjJkMCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxv ZwpAQCAtMSw1ICsxLDIwIEBACiAyMDEzLTAyLTE1ICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNj YUBhcHBsZS5jb20+CiAKKyAgICAgICAgQWRkIEhhc2hNYXA6OmlzR29vZEtleSBhbmQgSGFzaFNl dDo6aXNHb29kVmFsdWUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTEwOTk3NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEp1c3QgY2FsbCBIYXNoTWFwOjppc0dvb2RLZXkgZGlyZWN0bHkuCisKKyAgICAgICAg KiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6Z2VuZXJh dGVQYWdlSUQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzUHJveHk6OndlYkZyYW1lKToK KyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc1Byb3h5OjpjYW5DcmVhdGVGcmFtZSk6CisgICAg ICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQcm94eTo6ZGlkRGVzdHJveUZyYW1lKToKKworMjAxMy0w Mi0xNSAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgorCiAgICAgICAgIE1h a2UgbW9zdCBBcmd1bWVudEVuY29kZXI6OmVuY29kZSBtZW1iZXIgZnVuY3Rpb25zIHByaXZhdGUK ICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwOTk3Mwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoTWFwLmggYi9Tb3VyY2UvV1RGL3d0Zi9I YXNoTWFwLmgKaW5kZXggMTBlZTQyNWRhOTU5NmJhYWRmMzRlNTc4ZWY1YWJlNTcwZjlhZTBkNi4u ZDc3MTFhODQ5MDBjN2ExMzM2YjM3NzEwMGU0Y2MzNzY0Y2EyYTIwYyAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvSGFzaE1hcC5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0hhc2hNYXAuaApAQCAt MTMxLDYgKzEzMSw4IEBAIG5hbWVzcGFjZSBXVEYgewogCiAgICAgICAgIHZvaWQgY2hlY2tDb25z aXN0ZW5jeSgpIGNvbnN0OwogCisgICAgICAgIHN0YXRpYyBib29sIGlzR29vZEtleShjb25zdCBL ZXlUeXBlJik7CisKICAgICBwcml2YXRlOgogICAgICAgICBBZGRSZXN1bHQgaW5saW5lQWRkKGNv bnN0IEtleVR5cGUmLCBNYXBwZWRQYXNzSW5SZWZlcmVuY2VUeXBlKTsKIApAQCAtNDExLDYgKzQx MywxMiBAQCBuYW1lc3BhY2UgV1RGIHsKICAgICB9CiAKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBU LCB0eXBlbmFtZSBVLCB0eXBlbmFtZSBWLCB0eXBlbmFtZSBXLCB0eXBlbmFtZSBYPgorICAgIGlu bGluZSBib29sIEhhc2hNYXA8VCwgVSwgViwgVywgWD46OmlzR29vZEtleShjb25zdCBLZXlUeXBl JiBrZXkpCisgICAgeworICAgICAgICByZXR1cm4ga2V5ICE9IEtleVRyYWl0czo6ZW1wdHlWYWx1 ZSgpICYmICFLZXlUcmFpdHM6OmlzRGVsZXRlZFZhbHVlKGtleSk7CisgICAgfQorCisgICAgdGVt cGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVSwgdHlwZW5hbWUgViwgdHlwZW5hbWUgVywgdHlw ZW5hbWUgWD4KICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgSGFzaE1hcDxULCBVLCBWLCBXLCBY PiYgYSwgY29uc3QgSGFzaE1hcDxULCBVLCBWLCBXLCBYPiYgYikKICAgICB7CiAgICAgICAgIGlm IChhLnNpemUoKSAhPSBiLnNpemUoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0hhc2hT ZXQuaCBiL1NvdXJjZS9XVEYvd3RmL0hhc2hTZXQuaAppbmRleCA0MGJkN2ZlNGM0N2IzYmVkZTFk ZTdjNTkwNWZkYjJiMmZhMDRjMzdiLi4xMGFiOGYzYWM5NGFiZGNmZTgwMmQ5YzkwZWE4MjVhMTVh Y2FlNGM1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9IYXNoU2V0LmgKKysrIGIvU291cmNl L1dURi93dGYvSGFzaFNldC5oCkBAIC05MSw2ICs5MSw4IEBAIG5hbWVzcGFjZSBXVEYgewogICAg ICAgICB2b2lkIHJlbW92ZShpdGVyYXRvcik7CiAgICAgICAgIHZvaWQgY2xlYXIoKTsKIAorICAg ICAgICBzdGF0aWMgYm9vbCBpc0dvb2RWYWx1ZShjb25zdCBWYWx1ZVR5cGUmKTsKKwogICAgIHBy aXZhdGU6CiAgICAgICAgIGZyaWVuZCB2b2lkIGRlbGV0ZUFsbFZhbHVlczw+KGNvbnN0IEhhc2hT ZXQmKTsKIApAQCAtMjA5LDYgKzIxMSwxMiBAQCBuYW1lc3BhY2UgV1RGIHsKICAgICAgICAgbV9p bXBsLmNsZWFyKCk7IAogICAgIH0KIAorICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1l IFUsIHR5cGVuYW1lIFY+CisgICAgYm9vbCBIYXNoU2V0PFQsIFUsIFY+Ojppc0dvb2RWYWx1ZShj b25zdCBWYWx1ZVR5cGUmIHZhbHVlKQorICAgIHsKKyAgICAgICAgcmV0dXJuIHZhbHVlICE9IFZh bHVlVHJhaXRzOjplbXB0eVZhbHVlKCkgJiYgIVZhbHVlVHJhaXRzOjppc0RlbGV0ZWRWYWx1ZSh2 YWx1ZSk7CisgICAgfQorCiAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVmFsdWVUeXBlLCB0eXBlbmFt ZSBIYXNoVGFibGVUeXBlPgogICAgIHZvaWQgZGVsZXRlQWxsVmFsdWVzKEhhc2hUYWJsZVR5cGUm IGNvbGxlY3Rpb24pCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L1dlYlByb2Nlc3NQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vz c1Byb3h5LmNwcAppbmRleCA0ODQxMTlhZmJiODM3MzhkM2Y0MTE5NTlkNThmMDA1N2U5YTUwNzZm Li42ZDJjYWUyN2I3MjgzYzM3ZjhmNjE0YWZjM2EwZGJkZTQ3YzcxMzkwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcApAQCAtNjksMTYgKzY5LDEwIEBA IHVzaW5nIG5hbWVzcGFjZSBzdGQ7CiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCi10ZW1wbGF0ZTx0 eXBlbmFtZSBIYXNoTWFwPgotc3RhdGljIGlubGluZSBib29sIGlzR29vZEtleShjb25zdCB0eXBl bmFtZSBIYXNoTWFwOjpLZXlUeXBlJiBrZXkpCi17Ci0gICAgcmV0dXJuIGtleSAhPSBIYXNoVHJh aXRzPHR5cGVuYW1lIEhhc2hNYXA6OktleVR5cGU+OjplbXB0eVZhbHVlKCkgJiYgIUhhc2hUcmFp dHM8dHlwZW5hbWUgSGFzaE1hcDo6S2V5VHlwZT46OmlzRGVsZXRlZFZhbHVlKGtleSk7Ci19Ci0K IHN0YXRpYyB1aW50NjRfdCBnZW5lcmF0ZVBhZ2VJRCgpCiB7Ci0gICAgc3RhdGljIHVpbnQ2NF90 IHVuaXF1ZVBhZ2VJRCA9IDE7Ci0gICAgcmV0dXJuIHVuaXF1ZVBhZ2VJRCsrOworICAgIHN0YXRp YyB1aW50NjRfdCB1bmlxdWVQYWdlSUQ7CisgICAgcmV0dXJuICsrdW5pcXVlUGFnZUlEOwogfQog CiBzdGF0aWMgV2ViUHJvY2Vzc1Byb3h5OjpXZWJQYWdlUHJveHlNYXAmIGdsb2JhbFBhZ2VNYXAo KQpAQCAtNDU4LDEyICs0NTIsMTUgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OmRpZEZpbmlzaExh dW5jaGluZyhQcm9jZXNzTGF1bmNoZXIqIGxhdW5jaGVyLCBDb3JlSVBDOjpDb24KIAogV2ViRnJh bWVQcm94eSogV2ViUHJvY2Vzc1Byb3h5Ojp3ZWJGcmFtZSh1aW50NjRfdCBmcmFtZUlEKSBjb25z dAogewotICAgIHJldHVybiBpc0dvb2RLZXk8V2ViRnJhbWVQcm94eU1hcD4oZnJhbWVJRCkgPyBt X2ZyYW1lTWFwLmdldChmcmFtZUlEKS5nZXQoKSA6IDA7CisgICAgaWYgKCFtX2ZyYW1lTWFwLmlz R29vZEtleShmcmFtZUlEKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1cm4gbV9mcmFt ZU1hcC5nZXQoZnJhbWVJRCkuZ2V0KCk7CiB9CiAKIGJvb2wgV2ViUHJvY2Vzc1Byb3h5OjpjYW5D cmVhdGVGcmFtZSh1aW50NjRfdCBmcmFtZUlEKSBjb25zdAogewotICAgIHJldHVybiBpc0dvb2RL ZXk8V2ViRnJhbWVQcm94eU1hcD4oZnJhbWVJRCkgJiYgIW1fZnJhbWVNYXAuY29udGFpbnMoZnJh bWVJRCk7CisgICAgcmV0dXJuIG1fZnJhbWVNYXAuaXNHb29kS2V5KGZyYW1lSUQpICYmICFtX2Zy YW1lTWFwLmNvbnRhaW5zKGZyYW1lSUQpOwogfQogCiB2b2lkIFdlYlByb2Nlc3NQcm94eTo6ZnJh bWVDcmVhdGVkKHVpbnQ2NF90IGZyYW1lSUQsIFdlYkZyYW1lUHJveHkqIGZyYW1lUHJveHkpCkBA IC00NzcsNyArNDc0LDcgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OmRpZERlc3Ryb3lGcmFtZSh1 aW50NjRfdCBmcmFtZUlEKQogICAgIC8vIElmIHRoZSBwYWdlIGlzIGNsb3NlZCBiZWZvcmUgaXQg aGFzIGhhZCB0aGUgY2hhbmNlIHRvIHNlbmQgdGhlIERpZENyZWF0ZU1haW5GcmFtZSBtZXNzYWdl CiAgICAgLy8gYmFjayB0byB0aGUgVUlQcm9jZXNzLCB0aGVuIHRoZSBmcmFtZURlc3Ryb3llZCBt ZXNzYWdlIHdpbGwgc3RpbGwgYmUgcmVjZWl2ZWQgYmVjYXVzZSBpdAogICAgIC8vIGdldHMgc2Vu dCBkaXJlY3RseSB0byB0aGUgV2ViUHJvY2Vzc1Byb3h5LgotICAgIEFTU0VSVChpc0dvb2RLZXk8 V2ViRnJhbWVQcm94eU1hcD4oZnJhbWVJRCkpOworICAgIEFTU0VSVChtX2ZyYW1lTWFwLmlzR29v ZEtleShmcmFtZUlEKSk7CiAgICAgbV9mcmFtZU1hcC5yZW1vdmUoZnJhbWVJRCk7CiB9CiAK