88287 2012-06-04 20:54:41 -0700 JSC: need to implement IDBKeyPathBackendImpl to make indexedDB for JSC. 2013-01-04 00:47:50 -0800 1 1 1 Unclassified WebKit WebCore JavaScript 528+ (Nightly build) Unspecified Unspecified RESOLVED DUPLICATE 96614 P2 Normal --- 94023 95409 45110 92828 1 charles.wei charles.wei abarth alecflett cdumez dglazkov donggwan.kim efidler ggaren haraken jiyeon0402.kim jochen jorlow jrogers jsbell leo.yang oliver rwlbuis s.choi staikos tonikitoo webkit.review.bot oldest_to_newest 641157 0 charles.wei 2012-06-04 20:54:41 -0700 Need to implement IDBKeyPathBackendImpl::createIDBKeysFromSerializedValuesAndKeyPath(), IDBKeyPathBackendImpl::injectIDBKeyIntoSerializedValue() for JSC binding. 652240 1 148289 charles.wei 2012-06-19 02:09:50 -0700 Created attachment 148289 Patch 652261 2 148289 webkit.review.bot 2012-06-19 02:33:19 -0700 Comment on attachment 148289 Patch Attachment 148289 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/12974686 652357 3 148289 charles.wei 2012-06-19 06:02:57 -0700 Comment on attachment 148289 Patch Sorry, my local repository is a bit out of date. I will rebase to the latest code and will submit a new patch. 652364 4 148320 charles.wei 2012-06-19 06:15:26 -0700 Created attachment 148320 Patch 652502 5 148320 jsbell 2012-06-19 08:59:13 -0700 Comment on attachment 148320 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=148320&action=review > Source/WebCore/bindings/js/IDBBindingUtilities.cpp:43 > + m_context = JSGlobalContextCreate(0); Just an aside, context creation ended up being expensive in V8 so we recycle a utility context across the IDBKey create/inject calls. Not urgent, but you may want to profile to see if that'll be a performance issue for JSC. > Source/WebCore/bindings/js/IDBBindingUtilities.cpp:74 > +void createIDBKeysFromSerializedScriptValuesAndKeyPath(const Vector<RefPtr<SerializedScriptValue>, 0>& values, const IDBKeyPath& keyPath, Vector<RefPtr<IDBKey>, 0>& keys) You may have noticed the multiple values/multiple keys. I don't think that functionality of the API is being used at the moment, but we may start to. In the Chromium port this is often run in a different process, and for bulk operations (like creating an index with an already populated store) we will want to avoid the IPC overhead when iterating over the entire store, so we could use this to compute the index keys in batches. Basically, there's a lot of cleanup work to do. :) Keep these patches coming, it's awesome. > Source/WebCore/bindings/js/IDBBindingUtilities.cpp:118 > + // FIXME: we might need to support ArrayType The only key type that injectXXX() needs to support is NumberType (as a result of using a key generator and key path). You can safely ASSERT on that; we should be able to simplify the V8 version too. Support for other types in this API probably dates from earlier versions of the spec. 652575 6 148320 oliver 2012-06-19 10:37:15 -0700 Comment on attachment 148320 Patch You shouldn't be using a temporary context -- why are we serializing to one form when we want another? Alternatively why are we deserializing? If it's absolutely critical we should either add logic to deserialize directly to IDB types, or not be serializing to an unrelated format in the first place. 653132 7 charles.wei 2012-06-19 20:26:16 -0700 (In reply to comment #6) > (From update of attachment 148320 [details]) > You shouldn't be using a temporary context -- why are we serializing to one form when we want another? Alternatively why are we deserializing? > > If it's absolutely critical we should either add logic to deserialize directly to IDB types, or not be serializing to an unrelated format in the first place. Oliver: thanks for the comments. Let me explain why this design -- using a temporary context to deserialize the SerializedScriptValue to JSValue. 1. For IndexedDB, we need to access a certain property of an object before putting to the database or after we read from the database. We need to do that again the SerializedScriptValue. If you doubt the justification of this, the existing code in Modules/indexeddb is expecting for that. 2. To do that , there are multiple-ways. 2.1 -- directly parsing and manipulating the SerializedScriptValue, to get property of the object, or to inject a new property and value to the object. Theoratically this is possible, but a) It's a lot of coding; b) we need to invent another data structure to represent the object; c) we are not re-using the JSValue (JSObject) and the serialization/deserialization code between JS <==> SerializedScriptValue. 2.2 -- SerializedScriptValue is just a string representation of an JSObject for cross-boder passing (cross-process, persistence, etc.), it's not good at object property accessing. But it can be easily converted to/from an JSValue/JSObject, which has very easy way to manipulate the object properties. So it's good to deserialize it to a temporary JSValue/JSObject for property manipulation and then convert back to a SerializedScriptValue. To deserialize the SerializedScriptValue to JSValue, we need an Javascript Context. There are 2 ways to get an Javascript Context: 2.2.1 --- Re-using the JavaScriptContext that initialized the indexedDB operation. This not only requires a lot of code change to pass the JavaScript Context from class to class, object to object, function to function ( please have a look at bug: 45110, most of which is trying to do this JavaScript Context passing ), but also not work well because it's shared code between JSC and V8 porting, while V8 porting is not using them at all and the change might break Chromium/V8. 2.2.2 --- Create an temporary JavaScript Context, same as V8, which also creates a temporary JavaScript Context for this. This makes little code change, the code looks cleaner and easier to maintain. 2.2.2 is now the approach this patch is pursuing. Oliver: what negative impacts do you see with a temporary JavaScript Context except potential performance hits pointed out at comment #5, which I am going to make the temporary JavaScript context recyclable among IndexedDB operations? 653255 8 148516 charles.wei 2012-06-20 00:05:30 -0700 Created attachment 148516 Patch 653545 9 oliver 2012-06-20 09:25:13 -0700 (In reply to comment #7) > (In reply to comment #6) > > (From update of attachment 148320 [details] [details]) > > You shouldn't be using a temporary context -- why are we serializing to one form when we want another? Alternatively why are we deserializing? > > > > If it's absolutely critical we should either add logic to deserialize directly to IDB types, or not be serializing to an unrelated format in the first place. > > Oliver: thanks for the comments. > > Let me explain why this design -- using a temporary context to deserialize the SerializedScriptValue to JSValue. > > 1. For IndexedDB, we need to access a certain property of an object before putting to the database or after we read from the database. We need to do that again the SerializedScriptValue. If you doubt the justification of this, the existing code in Modules/indexeddb is expecting for that. > Can you clarify this? What property are you trying to access? Why can't you just access it off of the unserialised object? serialising and then deserialising an entire object just to access a single property could be horrendously painful, so why aren't we just reading off the deserialised object (on read) or the unserialised object (for writes)? That's what is confusing me. I agree whole heartedly that you don't want to try and do individual property reads from the serialised form. 654119 10 charles.wei 2012-06-20 18:41:36 -0700 > > > > 1. For IndexedDB, we need to access a certain property of an object before putting to the database or after we read from the database. We need to do that again the SerializedScriptValue. If you doubt the justification of this, the existing code in Modules/indexeddb is expecting for that. > > > Can you clarify this? What property are you trying to access? Why can't you just access it off of the unserialised object? serialising and then deserialising an entire object just to access a single property could be horrendously painful, so why aren't we just reading off the deserialised object (on read) or the unserialised object (for writes)? > > That's what is confusing me. > > I agree whole heartedly that you don't want to try and do individual property reads from the serialised form. Oliver: The IDBObjectStore.idl definition explains this: interface IDBObjectStore { readonly attribute [TreatReturnedNullStringAs=Null] DOMString keyPath; [CallWith=ScriptExecutionContext] IDBRequest put(in SerializedScriptValue value, in [Optional] IDBKey key) raises (IDBDatabaseException); [CallWith=ScriptExecutionContext] IDBRequest add(in SerializedScriptValue value, in [Optional] IDBKey key) raises (IDBDatabaseException); ...... }; From which you can see, the put() and add() methods ( put or add a record to the indexedDB) are taking SerializedScriptValue as inputs, that means, the JSValue will be automatically converted to the native SerializeScriptValue, and all following operations (putting to the database) are operated against this SerializedScriptValue. Before putting to the database, we might need to get the key from the SerializedScriptValue, the key is the property indicated by the keyPath of the object. That's why we need to access the property of an object in SerializedScriptValue format. Joshua Bell might be able to give a more convincible explanation since they designed the IndexedDB initially for V8. 654197 11 oliver 2012-06-20 20:41:59 -0700 (In reply to comment #10) > > > > > > 1. For IndexedDB, we need to access a certain property of an object before putting to the database or after we read from the database. We need to do that again the SerializedScriptValue. If you doubt the justification of this, the existing code in Modules/indexeddb is expecting for that. > > > > > Can you clarify this? What property are you trying to access? Why can't you just access it off of the unserialised object? serialising and then deserialising an entire object just to access a single property could be horrendously painful, so why aren't we just reading off the deserialised object (on read) or the unserialised object (for writes)? > > > > That's what is confusing me. > > > > I agree whole heartedly that you don't want to try and do individual property reads from the serialised form. > > > Oliver: The IDBObjectStore.idl definition explains this: > > interface IDBObjectStore { > > readonly attribute [TreatReturnedNullStringAs=Null] DOMString keyPath; > > [CallWith=ScriptExecutionContext] IDBRequest put(in SerializedScriptValue value, in [Optional] IDBKey key) raises (IDBDatabaseException); > [CallWith=ScriptExecutionContext] IDBRequest add(in SerializedScriptValue value, in [Optional] IDBKey key) raises (IDBDatabaseException); > ...... > }; > > From which you can see, the put() and add() methods ( put or add a record to the indexedDB) are taking SerializedScriptValue as inputs, that means, the JSValue will be automatically converted to the native SerializeScriptValue, and all following operations (putting to the database) are operated against this SerializedScriptValue. Before putting to the database, we might need to get the key from the SerializedScriptValue, the key is the property indicated by the keyPath of the object. That's why we need to access the property of an object in SerializedScriptValue format. > > Joshua Bell might be able to give a more convincible explanation since they designed the IndexedDB initially for V8. I think a better interface would be to take any rather than serialized value. IIRC that should give you a ScriptValue. You can then introspect the ScriptValue (ask for properties, etc) without the need for the [de]serialise shenanigans, and only serialise once you go to store the value. 654206 12 charles.wei 2012-06-20 21:01:29 -0700 . > > I think a better interface would be to take any rather than serialized value. > > IIRC that should give you a ScriptValue. > > You can then introspect the ScriptValue (ask for properties, etc) without the need for the [de]serialise shenanigans, and only serialise once you go to store the value. That seems a fundamental Change,and requires almost re-write of Modules/indexeddb, which is centered around SerializedScriptValue instead of ScriptValue. Further, will replace SerialiedScriptValue with ScriptValue will make things better ? Can we easily access attributes of a ScriptValue object without converting to/from JSValue ? I am looking at Chromium guys who initially implemented indexeddb for v8 binding. We need a consensus on this. 654209 13 oliver 2012-06-20 21:09:40 -0700 (In reply to comment #12) > . > > > > I think a better interface would be to take any rather than serialized value. > > > > IIRC that should give you a ScriptValue. > > > > You can then introspect the ScriptValue (ask for properties, etc) without the need for the [de]serialise shenanigans, and only serialise once you go to store the value. > > That seems a fundamental Change,and requires almost re-write of Modules/indexeddb, which is centered around SerializedScriptValue instead of ScriptValue. Further, will replace SerialiedScriptValue with ScriptValue will make things better ? Can we easily access attributes of a ScriptValue object without converting to/from JSValue ? > > I am looking at Chromium guys who initially implemented indexeddb for v8 binding. We need a consensus on this. ScriptValue (and ScriptObject) are WebCore's abstraction over the JS engine's value types. There is no conversion cost. 654211 14 charles.wei 2012-06-20 21:12:10 -0700 (In reply to comment #13) > (In reply to comment #12) > > . > > > > > > I think a better interface would be to take any rather than serialized value. > > > > > > IIRC that should give you a ScriptValue. > > > > > > You can then introspect the ScriptValue (ask for properties, etc) without the need for the [de]serialise shenanigans, and only serialise once you go to store the value. > > > > That seems a fundamental Change,and requires almost re-write of Modules/indexeddb, which is centered around SerializedScriptValue instead of ScriptValue. Further, will replace SerialiedScriptValue with ScriptValue will make things better ? Can we easily access attributes of a ScriptValue object without converting to/from JSValue ? > > > > I am looking at Chromium guys who initially implemented indexeddb for v8 binding. We need a consensus on this. > > ScriptValue (and ScriptObject) are WebCore's abstraction over the JS engine's value types. There is no conversion cost. Ok, but does that justify re-write the whole indexedDB code? 654214 15 oliver 2012-06-20 21:16:54 -0700 (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > > > . > > > > > > > > I think a better interface would be to take any rather than serialized value. > > > > > > > > IIRC that should give you a ScriptValue. > > > > > > > > You can then introspect the ScriptValue (ask for properties, etc) without the need for the [de]serialise shenanigans, and only serialise once you go to store the value. > > > > > > That seems a fundamental Change,and requires almost re-write of Modules/indexeddb, which is centered around SerializedScriptValue instead of ScriptValue. Further, will replace SerialiedScriptValue with ScriptValue will make things better ? Can we easily access attributes of a ScriptValue object without converting to/from JSValue ? > > > > > > I am looking at Chromium guys who initially implemented indexeddb for v8 binding. We need a consensus on this. > > > > ScriptValue (and ScriptObject) are WebCore's abstraction over the JS engine's value types. There is no conversion cost. > > Ok, but does that justify re-write the whole indexedDB code? 1) If a feature has been implemented with a bad design, we should not be worrying about the annoyance of re-implementing it. 2) You keep saying that IDB is built entirely around SerializedScriptValue, but I don't understand how that can be the case -- serializedscriptvalue is not a queryable type. It's intended for serialisation (hence the name), so should only be being used for actual storage and nothing else. What is the usage that makes IDB fundamentally tied to serializedscriptvalue being the in memory object representation? 654221 16 charles.wei 2012-06-20 21:30:52 -0700 > > (In reply to comment #13) > > > (In reply to comment #12) > > > > . > > > > > > > > > > I think a better interface would be to take any rather than serialized value. > > > > > > > > > > IIRC that should give you a ScriptValue. > > > > > > > > > > You can then introspect the ScriptValue (ask for properties, etc) without the need for the [de]serialise shenanigans, and only serialise once you go to store the value. > > > > > > > > That seems a fundamental Change,and requires almost re-write of Modules/indexeddb, which is centered around SerializedScriptValue instead of ScriptValue. Further, will replace SerialiedScriptValue with ScriptValue will make things better ? Can we easily access attributes of a ScriptValue object without converting to/from JSValue ? > > > > > > > > I am looking at Chromium guys who initially implemented indexeddb for v8 binding. We need a consensus on this. > > > > > > ScriptValue (and ScriptObject) are WebCore's abstraction over the JS engine's value types. There is no conversion cost. > > > > Ok, but does that justify re-write the whole indexedDB code? > > 1) If a feature has been implemented with a bad design, we should not be worrying about the annoyance of re-implementing it. > 2) You keep saying that IDB is built entirely around SerializedScriptValue, but I don't understand how that can be the case -- serializedscriptvalue is not a queryable type. It's intended for serialisation (hence the name), so should only be being used for actual storage and nothing else. What is the usage that makes IDB fundamentally tied to serializedscriptvalue being the in memory object representation? For 1), I agree that a bad-designed feature should not worry about re-implementing. I would like to leave that to the original author to comment about the design for using SerializedScriptValue as the input parameter and in-memory representation of the object, instead of ScriptValue. For 2), I am talking about the fact that now idb implementation is build around SerializedScriptValue instead of ScriptValue, I am not saying that idb SHOULD be bond to SerializedScriptValue instead of the other one. This patch tries to adapt to the current design and makes it work for JSC, it's not trying to re-write the design and implementation already there. 654582 17 jsbell 2012-06-21 09:10:57 -0700 (In reply to comment #16) > > For 1), I agree that a bad-designed feature should not worry about re-implementing. I would like to leave that to the original author to comment about the design for using SerializedScriptValue as the input parameter and in-memory representation of the object, instead of ScriptValue. Unfortunately, the original authors are no longer active on the project. I'll try to fill in rationale as I understand it. The original implementation - which was based on very early iterations of the spec - needed to support the multi-process model. This was done by using sqlite as the backing store, and giving each process a handle to the store. This was deemed undesirable for security, performance, and maintainability reasons. So the implementation changed to use leveldb as a backing store, but only one process can speak to leveldb at a time. So the implementation was effectively split into "front end" objects that (in Chromium) live in the renderer processes and "back end" objects that (in Chromium) live in the browser process. The "front end" objects had very little intelligence, and most of the logic implementing the spec was present in the "back end". This meant that as soon as an API call was made from script the object would immediately be serialized for transmission across an IPC boundary to the back end. In some cases, the back end object would need to reason about the object (e.g. "extract a key" given the object and a key path, or "inject a key" given the object and a key path); in the Chromium port this requires other IPC hops. As an aside, the data stored in the backing store is a serialization of the script object. The IDB spec requires support for storing objects following the rules of the HTML5 "structured clone algorithm"; handily, these match (although Blobs are extra work and as yet unsupported in WebKit IDB) These "key" objects are a dramatic subset of what is permitted by script (number, string, date, or array-of key), and are stored and used independently of script objects (e.g. when walking over indexes to analyze keys, even without extracting the objects they refer to). Keys arise in two main places - explicitly passed from script, e.g. IDBObjectStore.get(key), where the WebIDL does indeed specify "any", and implicitly e.g. IDBObjectStore.put(object) where the object store has a "key path". The evaluation of the key path with the script object may occur directly during the API call, or may occur later and asynchronously - e.g. if the IDBObjectStore has an IDBIndex with a key path, then the key path is evaluated when the put() task is executed by the transaction to determine the index key. The cases where keys are explicitly passed in is currently handled by the binding layer, with WebKit IDL specifying IDBKey (a construct that does not exist in the spec). Custom binding logic is used to do the V8Value->IDBKey conversion. Although I'm not familiar with ScriptValue/ScriptObject, it sounds like this could be changed so that the IDL/binding layer specifies "any" and the value->IDBKey conversion is done at in the method instead. I'm agnostic to that change. However, it wouldn't change the need for the conversion functions, or obviate the use of SerializedScriptValue elsewhere in the current implementation. > For 2), I am talking about the fact that now idb implementation is build around SerializedScriptValue instead of ScriptValue, I am not saying that idb SHOULD be bond to SerializedScriptValue instead of the other one. > > This patch tries to adapt to the current design and makes it work for JSC, it's not trying to re-write the design and implementation already there. IMHO that's the right way to go. Those of us working on IDB with an eye towards the Chromium port are working on two fronts at the moment: highest priority is to get the implementation up to match the spec (our implementation was first, so has many old crufty bits that changed in the spec) so we're not introducing incompatibility to the Web; second priority is to untangle the "front end" / "back end" design specified above. It turns out that with an IPC jump in the middle that making changes to the code is incredibly time consuming (multi-sided patches) and performance is poor. We hope to get the WebKit implementation to the point where nearly all spec-specific logic resides in the "front end" and the "back end" is merely an async caching/write-batch system for arbitrary binary key/value pairs. This is a huge refactor - and especially exciting while other ports are attempting to implement the code, so we can't break them. It sounds like a move from SSV to SV would be most feasible once we're further along in this refactor, when the IDB spec logic isn't straddling an IPC barrier that requires SSVs in the middle. 657062 18 charles.wei 2012-06-25 17:33:21 -0700 (In reply to comment #17) > (In reply to comment #16) > > > > For 1), I agree that a bad-designed feature should not worry about re-implementing. I would like to leave that to the original author to comment about the design for using SerializedScriptValue as the input parameter and in-memory representation of the object, instead of ScriptValue. > > Unfortunately, the original authors are no longer active on the project. I'll try to fill in rationale as I understand it. > > The original implementation - which was based on very early iterations of the spec - needed to support the multi-process model. This was done by using sqlite as the backing store, and giving each process a handle to the store. This was deemed undesirable for security, performance, and maintainability reasons. So the implementation changed to use leveldb as a backing store, but only one process can speak to leveldb at a time. So the implementation was effectively split into "front end" objects that (in Chromium) live in the renderer processes and "back end" objects that (in Chromium) live in the browser process. The "front end" objects had very little intelligence, and most of the logic implementing the spec was present in the "back end". > > This meant that as soon as an API call was made from script the object would immediately be serialized for transmission across an IPC boundary to the back end. In some cases, the back end object would need to reason about the object (e.g. "extract a key" given the object and a key path, or "inject a key" given the object and a key path); in the Chromium port this requires other IPC hops. > > As an aside, the data stored in the backing store is a serialization of the script object. The IDB spec requires support for storing objects following the rules of the HTML5 "structured clone algorithm"; handily, these match (although Blobs are extra work and as yet unsupported in WebKit IDB) > > These "key" objects are a dramatic subset of what is permitted by script (number, string, date, or array-of key), and are stored and used independently of script objects (e.g. when walking over indexes to analyze keys, even without extracting the objects they refer to). > > Keys arise in two main places - explicitly passed from script, e.g. IDBObjectStore.get(key), where the WebIDL does indeed specify "any", and implicitly e.g. IDBObjectStore.put(object) where the object store has a "key path". The evaluation of the key path with the script object may occur directly during the API call, or may occur later and asynchronously - e.g. if the IDBObjectStore has an IDBIndex with a key path, then the key path is evaluated when the put() task is executed by the transaction to determine the index key. > > The cases where keys are explicitly passed in is currently handled by the binding layer, with WebKit IDL specifying IDBKey (a construct that does not exist in the spec). Custom binding logic is used to do the V8Value->IDBKey conversion. > > Although I'm not familiar with ScriptValue/ScriptObject, it sounds like this could be changed so that the IDL/binding layer specifies "any" and the value->IDBKey conversion is done at in the method instead. I'm agnostic to that change. However, it wouldn't change the need for the conversion functions, or obviate the use of SerializedScriptValue elsewhere in the current implementation. > > > For 2), I am talking about the fact that now idb implementation is build around SerializedScriptValue instead of ScriptValue, I am not saying that idb SHOULD be bond to SerializedScriptValue instead of the other one. > > > > This patch tries to adapt to the current design and makes it work for JSC, it's not trying to re-write the design and implementation already there. > > IMHO that's the right way to go. > > Those of us working on IDB with an eye towards the Chromium port are working on two fronts at the moment: highest priority is to get the implementation up to match the spec (our implementation was first, so has many old crufty bits that changed in the spec) so we're not introducing incompatibility to the Web; second priority is to untangle the "front end" / "back end" design specified above. > > It turns out that with an IPC jump in the middle that making changes to the code is incredibly time consuming (multi-sided patches) and performance is poor. We hope to get the WebKit implementation to the point where nearly all spec-specific logic resides in the "front end" and the "back end" is merely an async caching/write-batch system for arbitrary binary key/value pairs. This is a huge refactor - and especially exciting while other ports are attempting to implement the code, so we can't break them. It sounds like a move from SSV to SV would be most feasible once we're further along in this refactor, when the IDB spec logic isn't straddling an IPC barrier that requires SSVs in the middle. Joshua, thanks for the detailed explanation of the design and implementation background of IDB. Oliver: Any comments on this ? 661245 19 charles.wei 2012-07-01 21:13:05 -0700 Anyone can comment how to proceed ? 696232 20 jsbell 2012-08-15 11:59:26 -0700 FYI, added https://bugs.webkit.org/show_bug.cgi?id=94023 to track moving the IDB code from using SerializedScriptValue everywhere to using ScriptValue (etc) where possible, marked it as blocking this issue. I still think it would be okay to land this as-is then do the rework in 94023, even though it will likely obsolete much of this patch. 696606 21 charles.wei 2012-08-15 18:41:05 -0700 (In reply to comment #20) > FYI, added https://bugs.webkit.org/show_bug.cgi?id=94023 to track moving the IDB code from using SerializedScriptValue everywhere to using ScriptValue (etc) where possible, marked it as blocking this issue. > > I still think it would be okay to land this as-is then do the rework in 94023, even though it will likely obsolete much of this patch. Thanks for pushing for this, Joshua, and good to see that you filed 94023 to move SSV to SV as the data in the IDB code. I agree we can push this for now while 94023 will try to overwrite some of the code. 718863 22 alecflett 2012-09-12 16:22:56 -0700 we're almost ready for this - plus there is no more IDBKeyPathBackendImpl. The only thing left is some of the IDBBindingUtilities stuff. hold off any work there until that is implemented in bug 95409 722152 23 alecflett 2012-09-17 12:12:56 -0700 Charles, we are ready to go on this - IDB has been totally converted over. Some of the test cases that came out of this were interesting though - in particular your port has to make sure that you use a consistent serialization format. JSC has one, but I don't know if it's an issue that it's likely not (currently) compatible with the V8 one. 724058 24 jiyeon0402.kim 2012-09-19 18:43:11 -0700 After Bug 88287 fix, I'll continue. 724571 25 alecflett 2012-09-20 09:33:55 -0700 jiyeon: this bug, as it is described, isn't quite what you need to implement now. Instead, you need to implement JSC versions of the methods described in Source/WebCore/bindings/v8/IDBBindingUtilities.h 724960 26 jiyeon0402.kim 2012-09-20 16:17:33 -0700 (In reply to comment #25) > jiyeon: this bug, as it is described, isn't quite what you need to implement now. > Instead, you need to implement JSC versions of the methods described in Source/WebCore/bindings/v8/IDBBindingUtilities.h Sorry Alec for confusing. I have to write #24 comment in 92832 bugs. I just waiting finish this patch. After this patch finish, I'll continue 92828, 92832 bugs. You can ignore my comment #24. 783841 27 alecflett 2012-12-05 09:38:26 -0800 I think this bug is now invalid - all the other stuff mentioned here was implemented in bug 103484, and sounds like details are being worked out in bug 96614 *** This bug has been marked as a duplicate of bug 96614 *** 799993 28 148516 eric 2013-01-04 00:47:50 -0800 Comment on attachment 148516 Patch Cleared review? from attachment 148516 so that this bug does not appear in http://webkit.org/pending-review. If you would like this patch reviewed, please attach it to a new bug (or re-open this bug before marking it for review again). 148289 2012-06-19 02:09:50 -0700 2012-06-19 06:15:16 -0700 Patch bug-88287-20120619170949.patch text/plain 9101 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwNjY3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDliYWQ5OTMwNzZkZTFh OWViY2U2Y2FjZGFjMjNjMWU0MDJhNDRiYS4uNTkzNjA2Yzk2YmI1NDI5YzhkNTQxMjZhNTdlMWU3 NTcxNmQ0YzM4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTA2LTE5ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBKU0M6 IG5lZWQgdG8gaW1wbGVtZW50IElEQktleVBhdGhCYWNrZW5kSW1wbCB0byBtYWtlIGluZGV4ZWRE QiBmb3IgSlNDLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9ODgyODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBXZSBuZWVkIHRvIGltcGxlbWVudCB0aGVzZSB0d28gZnVuY3Rpb25zIGZvciBKU0MgYmluZGlu ZyB0byBtYWtlIGluZGV4ZWREQiB3b3JraW5nLgorCisgICAgICAgICogTW9kdWxlcy9pbmRleGVk ZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQktleVBh dGhCYWNrZW5kSW1wbDo6Y3JlYXRlSURCS2V5c0Zyb21TZXJpYWxpemVkVmFsdWVzQW5kS2V5UGF0 aCk6CisgICAgICAgIChXZWJDb3JlOjpJREJLZXlQYXRoQmFja2VuZEltcGw6OmluamVjdElEQktl eUludG9TZXJpYWxpemVkVmFsdWUpOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhlZGRiL0lEQktl eVBhdGhCYWNrZW5kSW1wbC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChJREJLZXlQ YXRoQmFja2VuZEltcGwpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRp ZXMuY3BwOgorICAgICAgICAoVGVtcG9yYXJ5SlNDb250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6 OlRlbXBvcmFyeUpTQ29udGV4dDo6VGVtcG9yYXJ5SlNDb250ZXh0KToKKyAgICAgICAgKFdlYkNv cmU6OlRlbXBvcmFyeUpTQ29udGV4dDo6flRlbXBvcmFyeUpTQ29udGV4dCk6CisgICAgICAgIChX ZWJDb3JlOjpUZW1wb3JhcnlKU0NvbnRleHQ6OmV4ZWMpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgIChXZWJDb3JlOjpjcmVhdGVJREJLZXlGcm9tVmFsdWUpOgorICAgICAgICAoV2ViQ29y ZTo6Y3JlYXRlSURCS2V5c0Zyb21TZXJpYWxpemVkU2NyaXB0VmFsdWVzQW5kS2V5UGF0aCk6Cisg ICAgICAgIChXZWJDb3JlOjppbmplY3RJREJLZXlJbnRvU2VyaWFsaXplZFNjcmlwdFZhbHVlKToK KyAgICAgICAgKiBiaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmg6CisgICAgICAgIChX ZWJDb3JlKToKKwogMjAxMi0wNi0xMiAgS2ludWtvIFlhc3VkYSAgPGtpbnVrb0BjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgU3VwcG9ydCBGaWxlL0RpcmVjdG9yeUVudHJ5IGFjY2VzcyBmb3IgPGlu cHV0IHR5cGU9ZmlsZT4gaWYgRmlsZVN5c3RlbSBBUEkgaXMgZW5hYmxlZApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmNw cCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQktleVBhdGhCYWNrZW5kSW1w bC5jcHAKaW5kZXggNjRhMWZiYzViZWQ3MGFjOTA4NWY1MzYzYjhhNmVkOTNjMmEyODAxOC4uNTM0 NmVhYjBiODVlYjk5OGQ3MzRmZGY4ZWZlODg1YTAzOWM4MWMyNCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlQYXRoQmFja2VuZEltcGwu Y3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiSURC S2V5UGF0aEJhY2tlbmRJbXBsLmgiCiAKKyNpbmNsdWRlICJJREJCaW5kaW5nVXRpbGl0aWVzLmgi CiAjaW5jbHVkZSAiSURCS2V5LmgiCiAjaW5jbHVkZSAiU2VyaWFsaXplZFNjcmlwdFZhbHVlLmgi CiAKQEAgLTM4LDE1ICszOSwxNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLXZvaWQgSURC S2V5UGF0aEJhY2tlbmRJbXBsOjpjcmVhdGVJREJLZXlzRnJvbVNlcmlhbGl6ZWRWYWx1ZXNBbmRL ZXlQYXRoKGNvbnN0IFZlY3RvcjxSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiwgMD4mLCBj b25zdCBJREJLZXlQYXRoJiwgVmVjdG9yPFJlZlB0cjxJREJLZXk+LCAwPiYpCit2b2lkIElEQktl eVBhdGhCYWNrZW5kSW1wbDo6Y3JlYXRlSURCS2V5c0Zyb21TZXJpYWxpemVkVmFsdWVzQW5kS2V5 UGF0aChjb25zdCBWZWN0b3I8UmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIDA+JiB2YWx1 ZXMsIGNvbnN0IFN0cmluZyYga2V5UGF0aCwgVmVjdG9yPFJlZlB0cjxJREJLZXk+LCAwPiYga2V5 cykKIHsKLSAgICAvLyBGSVhNRTogSW1wbGVtZW50IHRoaXMgbWV0aG9kIG9uY2UgSlNDIHN1cHBv cnRzIFdpcmVGb3JtYXQgZm9yIFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS4KKyAgICAvLyBKU0Mtc3Bl Y2lmaWMgYmluZGluZywgaW1wbGVtZW50YXRpb24gaW4gYmluZGluZy9qcy9JREJCaW5kaW5nVXRp bGl0aWVzLntoLGNwcH0KKyAgICBXZWJDb3JlOjpjcmVhdGVJREJLZXlzRnJvbVNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZXNBbmRLZXlQYXRoKHZhbHVlcywga2V5UGF0aCwga2V5cyk7CiB9CiAKLVBhc3NS ZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBJREJLZXlQYXRoQmFja2VuZEltcGw6OmluamVj dElEQktleUludG9TZXJpYWxpemVkVmFsdWUoUGFzc1JlZlB0cjxJREJLZXk+LCBQYXNzUmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIGNvbnN0IElEQktleVBhdGgmKQorUGFzc1JlZlB0cjxT ZXJpYWxpemVkU2NyaXB0VmFsdWU+IElEQktleVBhdGhCYWNrZW5kSW1wbDo6aW5qZWN0SURCS2V5 SW50b1NlcmlhbGl6ZWRWYWx1ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIGNvbnN0IFN0cmluZyYga2V5UGF0aCkKIHsKLSAg ICAvLyBGSVhNRTogSW1wbGVtZW50IHRoaXMgbWV0aG9kIG9uY2UgSlNDIHN1cHBvcnRzIFdpcmVG b3JtYXQgZm9yIFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS4KLSAgICByZXR1cm4gUGFzc1JlZlB0cjxT ZXJpYWxpemVkU2NyaXB0VmFsdWU+KCk7CisgICAgLy8gSlNDLXNwZWNpZmljIGJpbmRpbmcsIGlt cGxlbWVudGF0aW9uIGluIGJpbmRpbmcvanMvSURCQmluZGluZ1V0aWxpdGllcy57aCxjcHB9Cisg ICAgcmV0dXJuIFdlYkNvcmU6OmluamVjdElEQktleUludG9TZXJpYWxpemVkU2NyaXB0VmFsdWUo a2V5LCB2YWx1ZSwga2V5UGF0aCk7CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvaW5kZXhlZGRiL0lEQktleVBhdGhCYWNrZW5kSW1wbC5oIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmgKaW5kZXggMGYwNTdl YjJiYzczMjUxZjdhZDVmMWYwNTA5OTAxZWRjZTUxODkxNS4uMWM3NjIzMjIxN2ZmNTBlNGYwZDk3 OThmNTdjZjQyNGNkZDNjMTFmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9p bmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy9pbmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmgKQEAgLTMzLDEzICszMywxMiBA QAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBJREJLZXk7Ci1jbGFzcyBJREJLZXlQYXRo OwogY2xhc3MgU2VyaWFsaXplZFNjcmlwdFZhbHVlOwogCiBjbGFzcyBJREJLZXlQYXRoQmFja2Vu ZEltcGwgewogcHVibGljOgotICAgIHN0YXRpYyB2b2lkIGNyZWF0ZUlEQktleXNGcm9tU2VyaWFs aXplZFZhbHVlc0FuZEtleVBhdGgoY29uc3QgVmVjdG9yPFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0 VmFsdWU+LCAwPiYgdmFsdWVzLCBjb25zdCBJREJLZXlQYXRoJiwgVmVjdG9yPFJlZlB0cjxJREJL ZXk+LCAwPiYga2V5cyk7Ci0gICAgc3RhdGljIFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZh bHVlPiBpbmplY3RJREJLZXlJbnRvU2VyaWFsaXplZFZhbHVlKFBhc3NSZWZQdHI8SURCS2V5Piwg UGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+LCBjb25zdCBJREJLZXlQYXRoJik7Cisg ICAgc3RhdGljIHZvaWQgY3JlYXRlSURCS2V5c0Zyb21TZXJpYWxpemVkVmFsdWVzQW5kS2V5UGF0 aChjb25zdCBWZWN0b3I8UmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIDA+JiB2YWx1ZXMs IGNvbnN0IFN0cmluZyYga2V5UGF0aCwgVmVjdG9yPFJlZlB0cjxJREJLZXk+LCAwPiYga2V5cyk7 CisgICAgc3RhdGljIFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBpbmplY3RJREJL ZXlJbnRvU2VyaWFsaXplZFZhbHVlKFBhc3NSZWZQdHI8SURCS2V5PiwgUGFzc1JlZlB0cjxTZXJp YWxpemVkU2NyaXB0VmFsdWU+LCBjb25zdCBTdHJpbmcmIGtleVBhdGgpOwogfTsKIAogfQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmNwcApp bmRleCBjZGMwYzQ4ODQxNWNhMjMzNDJiNDFmNGRlNTUzMTllYTdjYzk0NDhjLi5jNDlkNTNhNDg5 ZDYyNjE2ZTMwN2FmNDE4OThiNDk0NDdiYmRkODRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmNwcApAQCAtMzAsMjAgKzMwLDEwMCBA QAogCiAjaW5jbHVkZSAiSURCS2V5LmgiCiAKKyNpbmNsdWRlIDxBUElDYXN0Lmg+CisjaW5jbHVk ZSA8RGF0ZUluc3RhbmNlLmg+CisjaW5jbHVkZSA8SlNDb250ZXh0UmVmLmg+CisKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAorY2xhc3MgVGVtcG9yYXJ5SlNDb250ZXh0IHsKK3B1YmxpYzoKKyAgICBU ZW1wb3JhcnlKU0NvbnRleHQoKQorICAgIHsKKyAgICAgICAgbV9jb250ZXh0ID0gSlNHbG9iYWxD b250ZXh0Q3JlYXRlKDApOworICAgICAgICBKU0dsb2JhbENvbnRleHRSZXRhaW4obV9jb250ZXh0 KTsKKyAgICB9CisKKyAgICB+VGVtcG9yYXJ5SlNDb250ZXh0KCkKKyAgICB7CisgICAgICAgIEpT R2xvYmFsQ29udGV4dFJlbGVhc2UobV9jb250ZXh0KTsKKyAgICB9CisKKyAgICBKU0M6OkV4ZWNT dGF0ZSogZXhlYygpCisgICAgeworICAgICAgICByZXR1cm4gdG9KUyhtX2NvbnRleHQpOworICAg IH0KKworcHJpdmF0ZToKKyAgICBKU0dsb2JhbENvbnRleHRSZWYgbV9jb250ZXh0OworfTsKKwog UGFzc1JlZlB0cjxJREJLZXk+IGNyZWF0ZUlEQktleUZyb21WYWx1ZShKU0M6OkV4ZWNTdGF0ZSog ZXhlYywgSlNDOjpKU1ZhbHVlIHZhbHVlKQogewogICAgIGlmICh2YWx1ZS5pc051bGwoKSkKICAg ICAgICAgcmV0dXJuIElEQktleTo6Y3JlYXRlSW52YWxpZCgpOwotICAgIGlmICh2YWx1ZS5pc0lu dDMyKCkpCisgICAgaWYgKHZhbHVlLmlzTnVtYmVyKCkpCiAgICAgICAgIHJldHVybiBJREJLZXk6 OmNyZWF0ZU51bWJlcih2YWx1ZS50b051bWJlcihleGVjKSk7CiAgICAgaWYgKHZhbHVlLmlzU3Ry aW5nKCkpCiAgICAgICAgIHJldHVybiBJREJLZXk6OmNyZWF0ZVN0cmluZyh1c3RyaW5nVG9TdHJp bmcodmFsdWUudG9TdHJpbmcoZXhlYyktPnZhbHVlKGV4ZWMpKSk7Ci0gICAgLy8gRklYTUU6IElt cGxlbWVudCBkYXRlcy4KKyAgICBpZiAodmFsdWUuaW5oZXJpdHMoJkpTQzo6RGF0ZUluc3RhbmNl OjpzX2luZm8pKQorICAgICAgICByZXR1cm4gSURCS2V5OjpjcmVhdGVEYXRlKHZhbHVlVG9EYXRl KGV4ZWMsIHZhbHVlKSk7CiAgICAgcmV0dXJuIDA7CiB9CiAKK3ZvaWQgY3JlYXRlSURCS2V5c0Zy b21TZXJpYWxpemVkU2NyaXB0VmFsdWVzQW5kS2V5UGF0aChjb25zdCBWZWN0b3I8UmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIDA+JiB2YWx1ZXMsIGNvbnN0IFN0cmluZyYga2V5UGF0aCwg VmVjdG9yPFJlZlB0cjxJREJLZXk+LCAwPiYga2V5cykKK3sKKyAgICBUZW1wb3JhcnlKU0NvbnRl eHQgY29udGV4dDsKKyAgICBKU0M6OkV4ZWNTdGF0ZSogZXhlYyA9IGNvbnRleHQuZXhlYygpOwor ICAgIEpTQzo6SlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCA9IGV4ZWMtPmR5bmFtaWNHbG9i YWxPYmplY3QoKTsKKworICAgIGZvciAoVmVjdG9yPFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFs dWU+LCAwPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSB2YWx1ZXMuYmVnaW4oKTsgaXQgIT0gdmFsdWVz LmVuZCgpOyBpdCsrKSB7CisgICAgICAgIEpTQzo6SlNWYWx1ZSBqc1ZhbHVlID0gKCppdCktPmRl c2VyaWFsaXplKGV4ZWMsIGdsb2JhbE9iamVjdCk7CisKKyAgICAgICAgSlNDOjpJZGVudGlmaWVy IGlkZW50aWZpZXIoJmV4ZWMtPmdsb2JhbERhdGEoKSwga2V5UGF0aC51dGY4KCkuZGF0YSgpKTsK KyAgICAgICAgSlNDOjpKU1ZhbHVlIGtleVZhbHVlID0gYXNPYmplY3QoanNWYWx1ZSktPmdldChl eGVjLCBpZGVudGlmaWVyKTsKKworICAgICAgICBSZWZQdHI8SURCS2V5PiBrZXkgPSBjcmVhdGVJ REJLZXlGcm9tVmFsdWUoZXhlYywga2V5VmFsdWUpOworICAgICAgICBrZXlzLmFwcGVuZChrZXkp OworICAgIH0KK30KKworUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IGluamVjdElE QktleUludG9TZXJpYWxpemVkU2NyaXB0VmFsdWUoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFz c1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBjb25zdCBTdHJpbmcmIGtleVBh dGgpCit7CisgICAgaWYgKCFrZXktPnZhbGlkKCkpCisgICAgICAgIHJldHVybiB2YWx1ZTsKKwor ICAgIFRlbXBvcmFyeUpTQ29udGV4dCBjb250ZXh0OworICAgIEpTQzo6RXhlY1N0YXRlKiBleGVj ID0gY29udGV4dC5leGVjKCk7CisgICAgSlNDOjpKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0 ID0gZXhlYy0+ZHluYW1pY0dsb2JhbE9iamVjdCgpOworCisgICAgSlNDOjpKU1ZhbHVlIGpzVmFs dWUgPSB2YWx1ZS0+ZGVzZXJpYWxpemUoZXhlYywgZ2xvYmFsT2JqZWN0KTsKKyAgICBKU0M6Oklk ZW50aWZpZXIgcHJvcGVydHlOYW1lKCZleGVjLT5nbG9iYWxEYXRhKCksIGtleVBhdGgudXRmOCgp LmRhdGEoKSk7CisKKyAgICBzd2l0Y2ggKGtleS0+dHlwZSgpKSB7CisgICAgY2FzZSBJREJLZXk6 Ok51bWJlclR5cGU6CisgICAgICAgIGFzT2JqZWN0KGpzVmFsdWUpLT5wdXREaXJlY3QoZXhlYy0+ Z2xvYmFsRGF0YSgpLCBwcm9wZXJ0eU5hbWUsIEpTQzo6SlNWYWx1ZShrZXktPm51bWJlcigpKSk7 CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBJREJLZXk6OlN0cmluZ1R5cGU6CisgICAgICAg IGFzT2JqZWN0KGpzVmFsdWUpLT5wdXREaXJlY3QoZXhlYy0+Z2xvYmFsRGF0YSgpLCBwcm9wZXJ0 eU5hbWUsIEpTQzo6anNTdHJpbmcoZXhlYywga2V5LT5zdHJpbmcoKS5pbXBsKCkpKTsKKyAgICAg ICAgYnJlYWs7CisKKyAgICBjYXNlIElEQktleTo6RGF0ZVR5cGU6CisgICAgICAgIGFzT2JqZWN0 KGpzVmFsdWUpLT5wdXREaXJlY3QoZXhlYy0+Z2xvYmFsRGF0YSgpLCBwcm9wZXJ0eU5hbWUsIEpT Qzo6RGF0ZUluc3RhbmNlOjpjcmVhdGUoZXhlYywgZ2xvYmFsT2JqZWN0LT5kYXRlU3RydWN0dXJl KCksIGtleS0+ZGF0ZSgpKSk7CisKKyAgICBjYXNlIElEQktleTo6SW52YWxpZFR5cGU6CisgICAg Y2FzZSBJREJLZXk6OkFycmF5VHlwZToKKyAgICBjYXNlIElEQktleTo6TWluVHlwZToKKyAgICAg ICAgLy8gRklYTUU6IHdlIG1pZ2h0IG5lZWQgdG8gc3VwcG9ydCBBcnJheVR5cGUKKyAgICAgICAg YnJlYWs7CisKKyAgICBkZWZhdWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAg ICB9CisKKyAgICByZXR1cm4gU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGUoZXhlYywganNW YWx1ZSk7Cit9CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoSU5E RVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lE QkJpbmRpbmdVdGlsaXRpZXMuaCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRp bmdVdGlsaXRpZXMuaAppbmRleCA4ZTBjOWM1Y2QwNDZhODQwMjczYWNmYjZiNDAxYzAxNTE1NDM5 MzMwLi40NDcyNThhZDJmZGFkZjdmZGQxMTg0ODA0NDEyODRjOGQ2YjE1YmVkIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmgKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oCkBAIC0zMCw2 ICszMCw3IEBACiAKICNpbmNsdWRlICJEaWN0aW9uYXJ5LmgiCiAjaW5jbHVkZSAiU2NyaXB0VmFs dWUuaCIgCisKICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CkBAIC0zNyw3ICszOCw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIElEQktleTsKIAog UGFzc1JlZlB0cjxJREJLZXk+IGNyZWF0ZUlEQktleUZyb21WYWx1ZShKU0M6OkV4ZWNTdGF0ZSos IEpTQzo6SlNWYWx1ZSk7Ci0KK3ZvaWQgY3JlYXRlSURCS2V5c0Zyb21TZXJpYWxpemVkU2NyaXB0 VmFsdWVzQW5kS2V5UGF0aChjb25zdCBWZWN0b3I8UmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1 ZT4sIDA+JiB2YWx1ZXMsIGNvbnN0IFN0cmluZyYga2V5UGF0aCwgVmVjdG9yPFJlZlB0cjxJREJL ZXk+LCAwPiYga2V5cyk7CitQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gaW5qZWN0 SURCS2V5SW50b1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZShQYXNzUmVmUHRyPElEQktleT4sIFBhc3NS ZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiwgY29uc3QgU3RyaW5nJiBrZXlQYXRoKTsKIH0K IAogI2VuZGlmIC8vIEVOQUJMRShJTkRFWEVEX0RBVEFCQVNFKQo= 148320 2012-06-19 06:15:26 -0700 2012-06-20 00:05:08 -0700 Patch bug-88287-20120619211524.patch text/plain 7945 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwNzA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjMwYWYxYzlmNGQ5NjI3 ZmIxMmNhOWMxN2U0M2JlMDhkYTcxZjE5NS4uMDYwYjgxOTFhZjljOTIxYzFjMmI2N2M0MzJkM2Vk NDZiZGJlZjNhZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDEyLTA2LTE5ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBKU0M6 IG5lZWQgdG8gaW1wbGVtZW50IElEQktleVBhdGhCYWNrZW5kSW1wbCB0byBtYWtlIGluZGV4ZWRE QiBmb3IgSlNDLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9ODgyODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBXZSBuZWVkIHRvIGltcGxlbWVudCBJREJLZXlQYXRoQmFja2VuZEltcGwgdG8gbWFrZSBpbmRl eGVkREIgd29ya2luZyBmb3IgSlNDLgorCisgICAgICAgIFRlc3RlZCB3aXRoIExheW91dFRlc3Rz L3N0b3JhZ2UvaW5kZXhlZGRiL3R1dG9yaWFsLmh0bWwKKworICAgICAgICAqIE1vZHVsZXMvaW5k ZXhlZGRiL0lEQktleVBhdGhCYWNrZW5kSW1wbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJREJL ZXlQYXRoQmFja2VuZEltcGw6OmNyZWF0ZUlEQktleXNGcm9tU2VyaWFsaXplZFZhbHVlc0FuZEtl eVBhdGgpOgorICAgICAgICAoV2ViQ29yZTo6SURCS2V5UGF0aEJhY2tlbmRJbXBsOjppbmplY3RJ REJLZXlJbnRvU2VyaWFsaXplZFZhbHVlKToKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9JREJCaW5k aW5nVXRpbGl0aWVzLmNwcDoKKyAgICAgICAgKFRlbXBvcmFyeUpTQ29udGV4dCk6CisgICAgICAg IChXZWJDb3JlOjpUZW1wb3JhcnlKU0NvbnRleHQ6OlRlbXBvcmFyeUpTQ29udGV4dCk6CisgICAg ICAgIChXZWJDb3JlOjpUZW1wb3JhcnlKU0NvbnRleHQ6On5UZW1wb3JhcnlKU0NvbnRleHQpOgor ICAgICAgICAoV2ViQ29yZTo6VGVtcG9yYXJ5SlNDb250ZXh0OjpleGVjKToKKyAgICAgICAgKFdl YkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlSURCS2V5RnJvbVZhbHVlKToKKyAgICAg ICAgKFdlYkNvcmU6OmNyZWF0ZUlEQktleXNGcm9tU2VyaWFsaXplZFNjcmlwdFZhbHVlc0FuZEtl eVBhdGgpOgorICAgICAgICAoV2ViQ29yZTo6aW5qZWN0SURCS2V5SW50b1NlcmlhbGl6ZWRTY3Jp cHRWYWx1ZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oOgor ICAgICAgICAoV2ViQ29yZSk6CisKIDIwMTItMDYtMTkgIERvbWluaWsgUsO2dHRzY2hlcyAgPGRv bWluaWsucm90dHNjaGVzQGludGVsLmNvbT4KIAogICAgICAgICBbR1RLXSBBc3NlcnQgZmFpbHVy ZSBpbiBzdmcvYmF0aWsvdGV4dC90ZXh0RGVjb3JhdGlvbi5zdmcsdGV4dEVmZmVjdDMuc3ZnIGZv ciA2NGJpdCBEZWJ1ZyBib3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5k ZXhlZGRiL0lEQktleVBhdGhCYWNrZW5kSW1wbC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L2luZGV4ZWRkYi9JREJLZXlQYXRoQmFja2VuZEltcGwuY3BwCmluZGV4IDY0YTFmYmM1YmVkNzBh YzkwODVmNTM2M2I4YTZlZDkzYzJhMjgwMTguLjFmZmJjNDAwOTUyY2IyNTUxMWE3YTAwZTA3Yzlk N2U5MWRmZjJhYzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQktleVBhdGhCYWNrZW5kSW1wbC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9p bmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIklEQktleVBhdGhCYWNrZW5kSW1wbC5oIgogCisj aW5jbHVkZSAiSURCQmluZGluZ1V0aWxpdGllcy5oIgogI2luY2x1ZGUgIklEQktleS5oIgogI2lu Y2x1ZGUgIlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgogCkBAIC0zOCwxNSArMzksMTYgQEAKIAog bmFtZXNwYWNlIFdlYkNvcmUgewogCi12b2lkIElEQktleVBhdGhCYWNrZW5kSW1wbDo6Y3JlYXRl SURCS2V5c0Zyb21TZXJpYWxpemVkVmFsdWVzQW5kS2V5UGF0aChjb25zdCBWZWN0b3I8UmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIDA+JiwgY29uc3QgSURCS2V5UGF0aCYsIFZlY3RvcjxS ZWZQdHI8SURCS2V5PiwgMD4mKQordm9pZCBJREJLZXlQYXRoQmFja2VuZEltcGw6OmNyZWF0ZUlE QktleXNGcm9tU2VyaWFsaXplZFZhbHVlc0FuZEtleVBhdGgoY29uc3QgVmVjdG9yPFJlZlB0cjxT ZXJpYWxpemVkU2NyaXB0VmFsdWU+LCAwPiYgdmFsdWVzLCBjb25zdCBJREJLZXlQYXRoJiBrZXlQ YXRoLCBWZWN0b3I8UmVmUHRyPElEQktleT4sIDA+JiBrZXlzKQogewotICAgIC8vIEZJWE1FOiBJ bXBsZW1lbnQgdGhpcyBtZXRob2Qgb25jZSBKU0Mgc3VwcG9ydHMgV2lyZUZvcm1hdCBmb3IgU2Vy aWFsaXplZFNjcmlwdFZhbHVlLgorICAgIC8vIEpTQy1zcGVjaWZpYyBiaW5kaW5nLCBpbXBsZW1l bnRhdGlvbiBpbiBiaW5kaW5nL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMue2gsY3BwfQorICAgIFdl YkNvcmU6OmNyZWF0ZUlEQktleXNGcm9tU2VyaWFsaXplZFNjcmlwdFZhbHVlc0FuZEtleVBhdGgo dmFsdWVzLCBrZXlQYXRoLCBrZXlzKTsKIH0KIAotUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0 VmFsdWU+IElEQktleVBhdGhCYWNrZW5kSW1wbDo6aW5qZWN0SURCS2V5SW50b1NlcmlhbGl6ZWRW YWx1ZShQYXNzUmVmUHRyPElEQktleT4sIFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVl PiwgY29uc3QgSURCS2V5UGF0aCYpCitQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4g SURCS2V5UGF0aEJhY2tlbmRJbXBsOjppbmplY3RJREJLZXlJbnRvU2VyaWFsaXplZFZhbHVlKFBh c3NSZWZQdHI8SURCS2V5PiBrZXksIFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiB2 YWx1ZSwgY29uc3QgSURCS2V5UGF0aCYga2V5UGF0aCkKIHsKLSAgICAvLyBGSVhNRTogSW1wbGVt ZW50IHRoaXMgbWV0aG9kIG9uY2UgSlNDIHN1cHBvcnRzIFdpcmVGb3JtYXQgZm9yIFNlcmlhbGl6 ZWRTY3JpcHRWYWx1ZS4KLSAgICByZXR1cm4gUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFs dWU+KCk7CisgICAgLy8gSlNDLXNwZWNpZmljIGJpbmRpbmcsIGltcGxlbWVudGF0aW9uIGluIGJp bmRpbmcvanMvSURCQmluZGluZ1V0aWxpdGllcy57aCxjcHB9CisgICAgcmV0dXJuIFdlYkNvcmU6 OmluamVjdElEQktleUludG9TZXJpYWxpemVkU2NyaXB0VmFsdWUoa2V5LCB2YWx1ZSwga2V5UGF0 aCk7CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJp bmRpbmdVdGlsaXRpZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGlu Z1V0aWxpdGllcy5jcHAKaW5kZXggY2RjMGM0ODg0MTVjYTIzMzQyYjQxZjRkZTU1MzE5ZWE3Y2M5 NDQ4Yy4uYWYwMGUxZDRkNzY5OTRjNmI1NTBlNDlmOTcyYWQ3YmQwZGRmMWQyYyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5jcHAKQEAg LTMwLDIwICszMCwxMDAgQEAKIAogI2luY2x1ZGUgIklEQktleS5oIgogCisjaW5jbHVkZSA8QVBJ Q2FzdC5oPgorI2luY2x1ZGUgPERhdGVJbnN0YW5jZS5oPgorI2luY2x1ZGUgPEpTQ29udGV4dFJl Zi5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK2NsYXNzIFRlbXBvcmFyeUpTQ29udGV4dCB7 CitwdWJsaWM6CisgICAgVGVtcG9yYXJ5SlNDb250ZXh0KCkKKyAgICB7CisgICAgICAgIG1fY29u dGV4dCA9IEpTR2xvYmFsQ29udGV4dENyZWF0ZSgwKTsKKyAgICAgICAgSlNHbG9iYWxDb250ZXh0 UmV0YWluKG1fY29udGV4dCk7CisgICAgfQorCisgICAgflRlbXBvcmFyeUpTQ29udGV4dCgpCisg ICAgeworICAgICAgICBKU0dsb2JhbENvbnRleHRSZWxlYXNlKG1fY29udGV4dCk7CisgICAgfQor CisgICAgSlNDOjpFeGVjU3RhdGUqIGV4ZWMoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIHRvSlMo bV9jb250ZXh0KTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgSlNHbG9iYWxDb250ZXh0UmVmIG1f Y29udGV4dDsKK307CisKIFBhc3NSZWZQdHI8SURCS2V5PiBjcmVhdGVJREJLZXlGcm9tVmFsdWUo SlNDOjpFeGVjU3RhdGUqIGV4ZWMsIEpTQzo6SlNWYWx1ZSB2YWx1ZSkKIHsKICAgICBpZiAodmFs dWUuaXNOdWxsKCkpCiAgICAgICAgIHJldHVybiBJREJLZXk6OmNyZWF0ZUludmFsaWQoKTsKLSAg ICBpZiAodmFsdWUuaXNJbnQzMigpKQorICAgIGlmICh2YWx1ZS5pc051bWJlcigpKQogICAgICAg ICByZXR1cm4gSURCS2V5OjpjcmVhdGVOdW1iZXIodmFsdWUudG9OdW1iZXIoZXhlYykpOwogICAg IGlmICh2YWx1ZS5pc1N0cmluZygpKQogICAgICAgICByZXR1cm4gSURCS2V5OjpjcmVhdGVTdHJp bmcodXN0cmluZ1RvU3RyaW5nKHZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKSkpOwot ICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgZGF0ZXMuCisgICAgaWYgKHZhbHVlLmluaGVyaXRzKCZK U0M6OkRhdGVJbnN0YW5jZTo6c19pbmZvKSkKKyAgICAgICAgcmV0dXJuIElEQktleTo6Y3JlYXRl RGF0ZSh2YWx1ZVRvRGF0ZShleGVjLCB2YWx1ZSkpOwogICAgIHJldHVybiAwOwogfQogCit2b2lk IGNyZWF0ZUlEQktleXNGcm9tU2VyaWFsaXplZFNjcmlwdFZhbHVlc0FuZEtleVBhdGgoY29uc3Qg VmVjdG9yPFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+LCAwPiYgdmFsdWVzLCBjb25zdCBJ REJLZXlQYXRoJiBrZXlQYXRoLCBWZWN0b3I8UmVmUHRyPElEQktleT4sIDA+JiBrZXlzKQorewor ICAgIFRlbXBvcmFyeUpTQ29udGV4dCBjb250ZXh0OworICAgIEpTQzo6RXhlY1N0YXRlKiBleGVj ID0gY29udGV4dC5leGVjKCk7CisgICAgSlNDOjpKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0 ID0gZXhlYy0+ZHluYW1pY0dsb2JhbE9iamVjdCgpOworCisgICAgZm9yIChWZWN0b3I8UmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIDA+Ojpjb25zdF9pdGVyYXRvciBpdCA9IHZhbHVlcy5i ZWdpbigpOyBpdCAhPSB2YWx1ZXMuZW5kKCk7IGl0KyspIHsKKyAgICAgICAgSlNDOjpKU1ZhbHVl IGpzVmFsdWUgPSAoKml0KS0+ZGVzZXJpYWxpemUoZXhlYywgZ2xvYmFsT2JqZWN0KTsKKworICAg ICAgICBKU0M6OklkZW50aWZpZXIgaWRlbnRpZmllcigmZXhlYy0+Z2xvYmFsRGF0YSgpLCBrZXlQ YXRoLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgICAgICBKU0M6OkpTVmFsdWUga2V5VmFs dWUgPSBhc09iamVjdChqc1ZhbHVlKS0+Z2V0KGV4ZWMsIGlkZW50aWZpZXIpOworCisgICAgICAg IFJlZlB0cjxJREJLZXk+IGtleSA9IGNyZWF0ZUlEQktleUZyb21WYWx1ZShleGVjLCBrZXlWYWx1 ZSk7CisgICAgICAgIGtleXMuYXBwZW5kKGtleSk7CisgICAgfQorfQorCitQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gaW5qZWN0SURCS2V5SW50b1NlcmlhbGl6ZWRTY3JpcHRWYWx1 ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1 ZT4gdmFsdWUsIGNvbnN0IElEQktleVBhdGgmIGtleVBhdGgpCit7CisgICAgaWYgKCFrZXktPnZh bGlkKCkpCisgICAgICAgIHJldHVybiB2YWx1ZTsKKworICAgIFRlbXBvcmFyeUpTQ29udGV4dCBj b250ZXh0OworICAgIEpTQzo6RXhlY1N0YXRlKiBleGVjID0gY29udGV4dC5leGVjKCk7CisgICAg SlNDOjpKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0ID0gZXhlYy0+ZHluYW1pY0dsb2JhbE9i amVjdCgpOworCisgICAgSlNDOjpKU1ZhbHVlIGpzVmFsdWUgPSB2YWx1ZS0+ZGVzZXJpYWxpemUo ZXhlYywgZ2xvYmFsT2JqZWN0KTsKKyAgICBKU0M6OklkZW50aWZpZXIgcHJvcGVydHlOYW1lKCZl eGVjLT5nbG9iYWxEYXRhKCksIGtleVBhdGguc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisKKyAg ICBzd2l0Y2ggKGtleS0+dHlwZSgpKSB7CisgICAgY2FzZSBJREJLZXk6Ok51bWJlclR5cGU6Cisg ICAgICAgIGFzT2JqZWN0KGpzVmFsdWUpLT5wdXREaXJlY3QoZXhlYy0+Z2xvYmFsRGF0YSgpLCBw cm9wZXJ0eU5hbWUsIEpTQzo6SlNWYWx1ZShrZXktPm51bWJlcigpKSk7CisgICAgICAgIGJyZWFr OworCisgICAgY2FzZSBJREJLZXk6OlN0cmluZ1R5cGU6CisgICAgICAgIGFzT2JqZWN0KGpzVmFs dWUpLT5wdXREaXJlY3QoZXhlYy0+Z2xvYmFsRGF0YSgpLCBwcm9wZXJ0eU5hbWUsIEpTQzo6anNT dHJpbmcoZXhlYywga2V5LT5zdHJpbmcoKS5pbXBsKCkpKTsKKyAgICAgICAgYnJlYWs7CisKKyAg ICBjYXNlIElEQktleTo6RGF0ZVR5cGU6CisgICAgICAgIGFzT2JqZWN0KGpzVmFsdWUpLT5wdXRE aXJlY3QoZXhlYy0+Z2xvYmFsRGF0YSgpLCBwcm9wZXJ0eU5hbWUsIEpTQzo6RGF0ZUluc3RhbmNl OjpjcmVhdGUoZXhlYywgZ2xvYmFsT2JqZWN0LT5kYXRlU3RydWN0dXJlKCksIGtleS0+ZGF0ZSgp KSk7CisKKyAgICBjYXNlIElEQktleTo6SW52YWxpZFR5cGU6CisgICAgY2FzZSBJREJLZXk6OkFy cmF5VHlwZToKKyAgICBjYXNlIElEQktleTo6TWluVHlwZToKKyAgICAgICAgLy8gRklYTUU6IHdl IG1pZ2h0IG5lZWQgdG8gc3VwcG9ydCBBcnJheVR5cGUKKyAgICAgICAgYnJlYWs7CisKKyAgICBk ZWZhdWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICByZXR1 cm4gU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGUoZXhlYywganNWYWx1ZSk7Cit9CiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRp ZXMuaCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuaApp bmRleCA4ZTBjOWM1Y2QwNDZhODQwMjczYWNmYjZiNDAxYzAxNTE1NDM5MzMwLi4yMGU0OWVmZDM0 MzhjNjA1NTNhODZkNDc1ODY3M2I1MGVhZTgzNWZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oCkBAIC0yOSw3ICsyOSw5IEBACiAjaWYg RU5BQkxFKElOREVYRURfREFUQUJBU0UpCiAKICNpbmNsdWRlICJEaWN0aW9uYXJ5LmgiCisjaW5j bHVkZSAiSURCS2V5UGF0aC5oIgogI2luY2x1ZGUgIlNjcmlwdFZhbHVlLmgiIAorCiAjaW5jbHVk ZSA8d3RmL0ZvcndhcmQuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzcsNiArMzksOCBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBjbGFzcyBJREJLZXk7CiAKIFBhc3NSZWZQdHI8SURCS2V5 PiBjcmVhdGVJREJLZXlGcm9tVmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUpOwor dm9pZCBjcmVhdGVJREJLZXlzRnJvbVNlcmlhbGl6ZWRTY3JpcHRWYWx1ZXNBbmRLZXlQYXRoKGNv bnN0IFZlY3RvcjxSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiwgMD4mLCBjb25zdCBJREJL ZXlQYXRoJiwgVmVjdG9yPFJlZlB0cjxJREJLZXk+LCAwPiYpOworUGFzc1JlZlB0cjxTZXJpYWxp emVkU2NyaXB0VmFsdWU+IGluamVjdElEQktleUludG9TZXJpYWxpemVkU2NyaXB0VmFsdWUoUGFz c1JlZlB0cjxJREJLZXk+LCBQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIGNvbnN0 IElEQktleVBhdGgmKTsKIAogfQogCg== 148516 2012-06-20 00:05:30 -0700 2013-01-04 00:47:50 -0800 Patch bug-88287-20120620150525.patch text/plain 8269 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwODA5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWRkMGVmODI3Mzc5N2Qz ZTIxODVkYmQ3ZDkyYjNiNTgzMzhlZTQ2Yy4uNGY5Y2QzYzI5NjBiMzAxMjA2NWU5NWUxZWY0M2Ew ODYxODY0ZWZkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTA2LTIwICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBKU0M6 IG5lZWQgdG8gaW1wbGVtZW50IElEQktleVBhdGhCYWNrZW5kSW1wbCB0byBtYWtlIGluZGV4ZWRE QiBmb3IgSlNDLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9ODgyODcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBXZSBuZWVkIHRvIGltcGxlbWVudCBJREJLZXlQYXRoQmFja2VuZEltcGwuY3BwIHRvIG1ha2Ug aW5kZXhlZERCIHdvcmtpbmcgZm9yIEpTQy4KKworICAgICAgICBUZXN0ZWQgd2l0aCBMYXlvdXRU ZXN0cy9zdG9yYWdlL2luZGV4ZWRkYi90dXRvcmlhbC5odG1sCisKKyAgICAgICAgKiBNb2R1bGVz L2luZGV4ZWRkYi9JREJLZXlQYXRoQmFja2VuZEltcGwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SURCS2V5UGF0aEJhY2tlbmRJbXBsOjpjcmVhdGVJREJLZXlzRnJvbVNlcmlhbGl6ZWRWYWx1ZXNB bmRLZXlQYXRoKToKKyAgICAgICAgKFdlYkNvcmU6OklEQktleVBhdGhCYWNrZW5kSW1wbDo6aW5q ZWN0SURCS2V5SW50b1NlcmlhbGl6ZWRWYWx1ZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSURC QmluZGluZ1V0aWxpdGllcy5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKElEQlRl bXBvcmFyeUpTQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUZW1wb3JhcnlKU0NvbnRl eHQ6Omluc3RhbmNlKToKKyAgICAgICAgKFdlYkNvcmU6OklEQlRlbXBvcmFyeUpTQ29udGV4dDo6 ZXhlYyk6CisgICAgICAgIChXZWJDb3JlOjpJREJUZW1wb3JhcnlKU0NvbnRleHQ6OklEQlRlbXBv cmFyeUpTQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpJREJUZW1wb3JhcnlKU0NvbnRleHQ6 On5JREJUZW1wb3JhcnlKU0NvbnRleHQpOgorICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlSURCS2V5 RnJvbVZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZUlEQktleXNGcm9tU2VyaWFsaXpl ZFNjcmlwdFZhbHVlc0FuZEtleVBhdGgpOgorICAgICAgICAoV2ViQ29yZTo6aW5qZWN0SURCS2V5 SW50b1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSURCQmlu ZGluZ1V0aWxpdGllcy5oOgorICAgICAgICAoV2ViQ29yZSk6CisKIDIwMTItMDYtMTkgIFZpdmVr IEdhbGF0YWdlICA8dml2ZWtnYWxhdGFnZUBnbWFpbC5jb20+CiAKICAgICAgICAgV2ViIEluc3Bl Y3RvcjogQ2xpY2tpbmcgIkNsZWFyIGFsbCBwcm9maWxlcyIgd2hpbGUgb25nb2luZyByZWNvcmRp bmcgc2hvdWxkIHJlc2V0IHRoZSBQcm9maWxlTGF1bmNoZXJWaWV3CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlQYXRoQmFja2VuZEltcGwuY3BwIGIv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCS2V5UGF0aEJhY2tlbmRJbXBsLmNw cAppbmRleCA2NGExZmJjNWJlZDcwYWM5MDg1ZjUzNjNiOGE2ZWQ5M2MyYTI4MDE4Li4xZmZiYzQw MDk1MmNiMjU1MTFhN2EwMGUwN2M5ZDdlOTFkZmYyYWMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJLZXlQYXRoQmFja2VuZEltcGwuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQktleVBhdGhCYWNrZW5kSW1wbC5jcHAK QEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJREJLZXlQ YXRoQmFja2VuZEltcGwuaCIKIAorI2luY2x1ZGUgIklEQkJpbmRpbmdVdGlsaXRpZXMuaCIKICNp bmNsdWRlICJJREJLZXkuaCIKICNpbmNsdWRlICJTZXJpYWxpemVkU2NyaXB0VmFsdWUuaCIKIApA QCAtMzgsMTUgKzM5LDE2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotdm9pZCBJREJLZXlQ YXRoQmFja2VuZEltcGw6OmNyZWF0ZUlEQktleXNGcm9tU2VyaWFsaXplZFZhbHVlc0FuZEtleVBh dGgoY29uc3QgVmVjdG9yPFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+LCAwPiYsIGNvbnN0 IElEQktleVBhdGgmLCBWZWN0b3I8UmVmUHRyPElEQktleT4sIDA+JikKK3ZvaWQgSURCS2V5UGF0 aEJhY2tlbmRJbXBsOjpjcmVhdGVJREJLZXlzRnJvbVNlcmlhbGl6ZWRWYWx1ZXNBbmRLZXlQYXRo KGNvbnN0IFZlY3RvcjxSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiwgMD4mIHZhbHVlcywg Y29uc3QgSURCS2V5UGF0aCYga2V5UGF0aCwgVmVjdG9yPFJlZlB0cjxJREJLZXk+LCAwPiYga2V5 cykKIHsKLSAgICAvLyBGSVhNRTogSW1wbGVtZW50IHRoaXMgbWV0aG9kIG9uY2UgSlNDIHN1cHBv cnRzIFdpcmVGb3JtYXQgZm9yIFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS4KKyAgICAvLyBKU0Mtc3Bl Y2lmaWMgYmluZGluZywgaW1wbGVtZW50YXRpb24gaW4gYmluZGluZy9qcy9JREJCaW5kaW5nVXRp bGl0aWVzLntoLGNwcH0KKyAgICBXZWJDb3JlOjpjcmVhdGVJREJLZXlzRnJvbVNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZXNBbmRLZXlQYXRoKHZhbHVlcywga2V5UGF0aCwga2V5cyk7CiB9CiAKLVBhc3NS ZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBJREJLZXlQYXRoQmFja2VuZEltcGw6OmluamVj dElEQktleUludG9TZXJpYWxpemVkVmFsdWUoUGFzc1JlZlB0cjxJREJLZXk+LCBQYXNzUmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIGNvbnN0IElEQktleVBhdGgmKQorUGFzc1JlZlB0cjxT ZXJpYWxpemVkU2NyaXB0VmFsdWU+IElEQktleVBhdGhCYWNrZW5kSW1wbDo6aW5qZWN0SURCS2V5 SW50b1NlcmlhbGl6ZWRWYWx1ZShQYXNzUmVmUHRyPElEQktleT4ga2V5LCBQYXNzUmVmUHRyPFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZT4gdmFsdWUsIGNvbnN0IElEQktleVBhdGgmIGtleVBhdGgpCiB7 Ci0gICAgLy8gRklYTUU6IEltcGxlbWVudCB0aGlzIG1ldGhvZCBvbmNlIEpTQyBzdXBwb3J0cyBX aXJlRm9ybWF0IGZvciBTZXJpYWxpemVkU2NyaXB0VmFsdWUuCi0gICAgcmV0dXJuIFBhc3NSZWZQ dHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPigpOworICAgIC8vIEpTQy1zcGVjaWZpYyBiaW5kaW5n LCBpbXBsZW1lbnRhdGlvbiBpbiBiaW5kaW5nL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMue2gsY3Bw fQorICAgIHJldHVybiBXZWJDb3JlOjppbmplY3RJREJLZXlJbnRvU2VyaWFsaXplZFNjcmlwdFZh bHVlKGtleSwgdmFsdWUsIGtleVBhdGgpOwogfQogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0aWVzLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCmluZGV4IGNkYzBjNDg4NDE1Y2Ey MzM0MmI0MWY0ZGU1NTMxOWVhN2NjOTQ0OGMuLmRmZGJkYzFkMzU1MTE4YmFjNWZhMzhhZThiNDcz NTU1M2VhN2VjOTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJp bmRpbmdVdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJp bmRpbmdVdGlsaXRpZXMuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykg MjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAy MDEyIFJlc2VhcmNoIEluIE1vdGlvbiBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMwLDIwICszMSwxMDMgQEAKIAogI2luY2x1ZGUg IklEQktleS5oIgogCisjaW5jbHVkZSA8QVBJQ2FzdC5oPgorI2luY2x1ZGUgPERhdGVJbnN0YW5j ZS5oPgorI2luY2x1ZGUgPEpTQ29udGV4dFJlZi5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK K2NsYXNzIElEQlRlbXBvcmFyeUpTQ29udGV4dDsKKworc3RhdGljIElEQlRlbXBvcmFyeUpTQ29u dGV4dCogc19pbnN0YW5jZSA9IDA7CisKK2NsYXNzIElEQlRlbXBvcmFyeUpTQ29udGV4dCB7Citw dWJsaWM6CisgICAgc3RhdGljIElEQlRlbXBvcmFyeUpTQ29udGV4dCogaW5zdGFuY2UoKQorICAg IHsKKyAgICAgICAgaWYgKCFzX2luc3RhbmNlKQorICAgICAgICAgICAgc19pbnN0YW5jZSA9IG5l dyBJREJUZW1wb3JhcnlKU0NvbnRleHQoKTsKKworICAgICAgICByZXR1cm4gc19pbnN0YW5jZTsK KyAgICB9CisKKyAgICBKU0M6OkV4ZWNTdGF0ZSogZXhlYygpCisgICAgeworICAgICAgICByZXR1 cm4gdG9KUyhtX2NvbnRleHQpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBJREJUZW1wb3JhcnlK U0NvbnRleHQoKQorICAgIHsKKyAgICAgICAgbV9jb250ZXh0ID0gSlNHbG9iYWxDb250ZXh0Q3Jl YXRlKDApOworICAgICAgICBKU0dsb2JhbENvbnRleHRSZXRhaW4obV9jb250ZXh0KTsKKyAgICB9 CisKKyAgICB+SURCVGVtcG9yYXJ5SlNDb250ZXh0KCkKKyAgICB7CisgICAgICAgIEpTR2xvYmFs Q29udGV4dFJlbGVhc2UobV9jb250ZXh0KTsKKyAgICB9CisKKyAgICBKU0dsb2JhbENvbnRleHRS ZWYgbV9jb250ZXh0OworfTsKKwogUGFzc1JlZlB0cjxJREJLZXk+IGNyZWF0ZUlEQktleUZyb21W YWx1ZShKU0M6OkV4ZWNTdGF0ZSogZXhlYywgSlNDOjpKU1ZhbHVlIHZhbHVlKQogewogICAgIGlm ICh2YWx1ZS5pc051bGwoKSkKICAgICAgICAgcmV0dXJuIElEQktleTo6Y3JlYXRlSW52YWxpZCgp OwotICAgIGlmICh2YWx1ZS5pc0ludDMyKCkpCisgICAgaWYgKHZhbHVlLmlzTnVtYmVyKCkpCiAg ICAgICAgIHJldHVybiBJREJLZXk6OmNyZWF0ZU51bWJlcih2YWx1ZS50b051bWJlcihleGVjKSk7 CiAgICAgaWYgKHZhbHVlLmlzU3RyaW5nKCkpCiAgICAgICAgIHJldHVybiBJREJLZXk6OmNyZWF0 ZVN0cmluZyh1c3RyaW5nVG9TdHJpbmcodmFsdWUudG9TdHJpbmcoZXhlYyktPnZhbHVlKGV4ZWMp KSk7Ci0gICAgLy8gRklYTUU6IEltcGxlbWVudCBkYXRlcy4KKyAgICBpZiAodmFsdWUuaW5oZXJp dHMoJkpTQzo6RGF0ZUluc3RhbmNlOjpzX2luZm8pKQorICAgICAgICByZXR1cm4gSURCS2V5Ojpj cmVhdGVEYXRlKHZhbHVlVG9EYXRlKGV4ZWMsIHZhbHVlKSk7CiAgICAgcmV0dXJuIDA7CiB9CiAK K3ZvaWQgY3JlYXRlSURCS2V5c0Zyb21TZXJpYWxpemVkU2NyaXB0VmFsdWVzQW5kS2V5UGF0aChj b25zdCBWZWN0b3I8UmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIDA+JiB2YWx1ZXMsIGNv bnN0IElEQktleVBhdGgmIGtleVBhdGgsIFZlY3RvcjxSZWZQdHI8SURCS2V5PiwgMD4mIGtleXMp Cit7CisgICAgSlNDOjpFeGVjU3RhdGUqIGV4ZWMgPSBJREJUZW1wb3JhcnlKU0NvbnRleHQ6Omlu c3RhbmNlKCktPmV4ZWMoKTsKKyAgICBKU0M6OkpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3Qg PSBleGVjLT5keW5hbWljR2xvYmFsT2JqZWN0KCk7CisKKyAgICBmb3IgKFZlY3RvcjxSZWZQdHI8 U2VyaWFsaXplZFNjcmlwdFZhbHVlPiwgMD46OmNvbnN0X2l0ZXJhdG9yIGl0ID0gdmFsdWVzLmJl Z2luKCk7IGl0ICE9IHZhbHVlcy5lbmQoKTsgaXQrKykgeworICAgICAgICBKU0M6OkpTVmFsdWUg anNWYWx1ZSA9ICgqaXQpLT5kZXNlcmlhbGl6ZShleGVjLCBnbG9iYWxPYmplY3QpOworCisgICAg ICAgIC8vIEZJWE1FOiBtaWdodCBuZWVkIHRvIHN1cHBvcnQga2V5UGF0aCBhcyBTdHJpbmdBcnJh eSBzb21ldGltZS4KKyAgICAgICAgSlNDOjpJZGVudGlmaWVyIGlkZW50aWZpZXIoJmV4ZWMtPmds b2JhbERhdGEoKSwga2V5UGF0aC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICAgICAgSlND OjpKU1ZhbHVlIGtleVZhbHVlID0gYXNPYmplY3QoanNWYWx1ZSktPmdldChleGVjLCBpZGVudGlm aWVyKTsKKworICAgICAgICBSZWZQdHI8SURCS2V5PiBrZXkgPSBjcmVhdGVJREJLZXlGcm9tVmFs dWUoZXhlYywga2V5VmFsdWUpOworICAgICAgICBrZXlzLmFwcGVuZChrZXkpOworICAgIH0KK30K KworUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IGluamVjdElEQktleUludG9TZXJp YWxpemVkU2NyaXB0VmFsdWUoUGFzc1JlZlB0cjxJREJLZXk+IGtleSwgUGFzc1JlZlB0cjxTZXJp YWxpemVkU2NyaXB0VmFsdWU+IHZhbHVlLCBjb25zdCBJREJLZXlQYXRoJiBrZXlQYXRoKQorewor ICAgIGlmICgha2V5LT52YWxpZCgpKQorICAgICAgICByZXR1cm4gdmFsdWU7CisKKyAgICBKU0M6 OkV4ZWNTdGF0ZSogZXhlYyA9IElEQlRlbXBvcmFyeUpTQ29udGV4dDo6aW5zdGFuY2UoKS0+ZXhl YygpOworICAgIEpTQzo6SlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCA9IGV4ZWMtPmR5bmFt aWNHbG9iYWxPYmplY3QoKTsKKworICAgIEpTQzo6SlNWYWx1ZSBqc1ZhbHVlID0gdmFsdWUtPmRl c2VyaWFsaXplKGV4ZWMsIGdsb2JhbE9iamVjdCk7CisgICAgSlNDOjpJZGVudGlmaWVyIHByb3Bl cnR5TmFtZSgmZXhlYy0+Z2xvYmFsRGF0YSgpLCBrZXlQYXRoLnN0cmluZygpLnV0ZjgoKS5kYXRh KCkpOworCisKKyAgICBzd2l0Y2ggKGtleS0+dHlwZSgpKSB7CisgICAgY2FzZSBJREJLZXk6Ok51 bWJlclR5cGU6CisgICAgICAgIGFzT2JqZWN0KGpzVmFsdWUpLT5wdXREaXJlY3QoZXhlYy0+Z2xv YmFsRGF0YSgpLCBwcm9wZXJ0eU5hbWUsIEpTQzo6SlNWYWx1ZShrZXktPm51bWJlcigpKSk7Cisg ICAgICAgIGJyZWFrOworCisgICAgY2FzZSBJREJLZXk6OlN0cmluZ1R5cGU6CisgICAgY2FzZSBJ REJLZXk6OkRhdGVUeXBlOgorICAgIGNhc2UgSURCS2V5OjpJbnZhbGlkVHlwZToKKyAgICBjYXNl IElEQktleTo6QXJyYXlUeXBlOgorICAgIGNhc2UgSURCS2V5OjpNaW5UeXBlOgorICAgICAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisKKyAgICByZXR1cm4gU2VyaWFsaXplZFNjcmlw dFZhbHVlOjpjcmVhdGUoZXhlYywganNWYWx1ZSk7Cit9CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CiAKICNlbmRpZiAvLyBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuaCBiL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuaAppbmRleCA4ZTBjOWM1Y2QwNDZh ODQwMjczYWNmYjZiNDAxYzAxNTE1NDM5MzMwLi4yMGU0OWVmZDM0MzhjNjA1NTNhODZkNDc1ODY3 M2I1MGVhZTgzNWZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJC aW5kaW5nVXRpbGl0aWVzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmlu ZGluZ1V0aWxpdGllcy5oCkBAIC0yOSw3ICsyOSw5IEBACiAjaWYgRU5BQkxFKElOREVYRURfREFU QUJBU0UpCiAKICNpbmNsdWRlICJEaWN0aW9uYXJ5LmgiCisjaW5jbHVkZSAiSURCS2V5UGF0aC5o IgogI2luY2x1ZGUgIlNjcmlwdFZhbHVlLmgiIAorCiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4K IAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtMzcsNiArMzksOCBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiBjbGFzcyBJREJLZXk7CiAKIFBhc3NSZWZQdHI8SURCS2V5PiBjcmVhdGVJREJLZXlGcm9t VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUpOwordm9pZCBjcmVhdGVJREJLZXlz RnJvbVNlcmlhbGl6ZWRTY3JpcHRWYWx1ZXNBbmRLZXlQYXRoKGNvbnN0IFZlY3RvcjxSZWZQdHI8 U2VyaWFsaXplZFNjcmlwdFZhbHVlPiwgMD4mLCBjb25zdCBJREJLZXlQYXRoJiwgVmVjdG9yPFJl ZlB0cjxJREJLZXk+LCAwPiYpOworUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IGlu amVjdElEQktleUludG9TZXJpYWxpemVkU2NyaXB0VmFsdWUoUGFzc1JlZlB0cjxJREJLZXk+LCBQ YXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4sIGNvbnN0IElEQktleVBhdGgmKTsKIAog fQogCg==