104829 2012-12-12 12:05:11 -0800 Introduce a mechanism to run a task before width computation or layout and migrate RenderCounter to using it 2013-02-21 20:05:04 -0800 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) All All RESOLVED WONTFIX P2 Normal --- 1 jchaffraix jchaffraix buildbot darin dglazkov eric esprehn hyatt inferno koivisto leviw mitz ojan.autocc ojan peter+ews rniwa simon.fraser tonikitoo webkit.review.bot oldest_to_newest 789772 0 jchaffraix 2012-12-12 12:05:11 -0800 Mutating the tree during layout has been the source of a lot of security vulnerabilities over the past year. This mechanism would give the renderers that currently mutate the tree during layout a safe way to do so as a pre-layout phase. This should significantly reduce the risk of confusing the layout logic. Another upside is that it would also make it possible to enforce a strict no-tree-mutation-during-layout policy that would be good to catch up future offenders. Current renderers that could benefit from such a change: * RenderCounter (calling updateText during computePreferredLogicalWidths) * RenderQuote (calling attachQuote during computePreferredLogicalWidths) * RenderListItem (calling updateMarkerLocation during computePreferredLogicalWidths and layout) * first-letter in RenderBlock and RenderTableCell (calling updateFirstLetter during computePreferredLogicalWidths and layout) * RenderMathMLOperator (calling updateFromElement during computePreferredLogicalWidths). Note: We won't be able to remove any mutation for this renderer as RenderMathMLOperator::stretchToHeight requires the operator to rebuild its "glyph" subtree. 789776 1 eric 2012-12-12 12:07:26 -0800 So is this a whole new phase? A two-pass layout of sort? It would help me to understand what is vs. is not OK to put in this phase. :) 789892 2 jchaffraix 2012-12-12 13:57:34 -0800 (In reply to comment #1) > So is this a whole new phase? A two-pass layout of sort? It would help me to understand what is vs. is not OK to put in this phase. :) It's really meant to be a mutation phase before layout so that we operate on a fixed tree. It should stay simple (complexity is what makes it hard to allow any tree mutation during layout) so we should restrict it to mutation tasks only. 789914 3 eric 2012-12-12 14:21:51 -0800 I like it. Would we implement this with a separate dirty bit, and a separate tree-walk? (like style resolve), or share the layout dirty-bit and possibly even the tree-walk (like how paint does its 7-phase burrito). 789976 4 inferno 2012-12-12 15:25:47 -0800 Julien, thanks for taking this up. This is pretty important one and in the past, we have just trying to patch these bugs by pushing tree mutation during layout, but it still creeps in many places. So, this will help to push those things over a new phase before layout. 789979 5 jchaffraix 2012-12-12 15:28:08 -0800 > Would we implement this with a separate dirty bit, and a separate tree-walk? (like style resolve), or share the layout dirty-bit and possibly even the tree-walk (like how paint does its 7-phase burrito). What I am considering is an opt-in mechanism where you register a task to run before layout (I consider the mechanism different from . I was going to post a patch in this direction using global HashMap but the lack of mutation safe iterators made me wonder if I am not trading a known issue for a new one down the road. A separate tree-walk is an overkill as I would expect the renderers mentioned in the first comment are rare or at least sparse in the tree. 789981 6 eric 2012-12-12 15:31:40 -0800 (In reply to comment #5) > What I am considering is an opt-in mechanism where you register a task to run before layout (I consider the mechanism different from . I was going to post a patch in this direction using global HashMap but the lack of mutation safe iterators made me wonder if I am not trading a known issue for a new one down the road. That sounds a lot like the post-attach callback mechanism, which I'm not a big fan of. I find post-attach callbacks cause very difficult to understand control-flow. (Perhaps naively) I'd rather do a full-tree-walk when we need this phase, if the appropriate dirty-bit is set. 790211 7 jchaffraix 2012-12-12 19:40:05 -0800 (In reply to comment #6) > (In reply to comment #5) > > What I am considering is an opt-in mechanism where you register a task to run before layout (I consider the mechanism different from . I was going to post a patch in this direction using global HashMap but the lack of mutation safe iterators made me wonder if I am not trading a known issue for a new one down the road. > > That sounds a lot like the post-attach callback mechanism, which I'm not a big fan of. I find post-attach callbacks cause very difficult to understand control-flow. I don't deny the readability issue for which I don't have a good solution. > (Perhaps naively) I'd rather do a full-tree-walk when we need this phase, if the appropriate dirty-bit is set. The catch of this approach is that we need to either reuse a dirty-bit on RenderObject (which involves a loss of readability too) or free an existing one (challenging but probably possible). This bit will be also mostly unused if we assume that the occurrence of such renderer is low. 790242 8 simon.fraser 2012-12-12 20:46:44 -0800 (In reply to comment #7) > The catch of this approach is that we need to either reuse a dirty-bit on RenderObject (which involves a loss of readability too) or free an existing one (challenging but probably possible). This bit will be also mostly unused if we assume that the occurrence of such renderer is low. Yeah, I'd prefer to avoid another set of dirty bits and a full tree walk. 790263 9 eric 2012-12-12 21:16:15 -0800 Doesn't paint walk the tree 7 times already? :) http://www.w3.org/TR/CSS2/zindex.html#painting-order 793220 10 179844 jchaffraix 2012-12-17 18:11:54 -0800 Created attachment 179844 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. 793258 11 179844 peter+ews 2012-12-17 18:55:32 -0800 Comment on attachment 179844 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. Attachment 179844 did not pass cr-android-ews (chromium-android): Output: http://queues.webkit.org/results/15378903 793297 12 179844 webkit.review.bot 2012-12-17 20:17:02 -0800 Comment on attachment 179844 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. Attachment 179844 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/15402013 New failing tests: css2.1/t1202-counter-01-b.html css2.1/t1202-counter-08-b.html css2.1/t1202-counters-06-b.html css2.1/t1202-counter-07-b.html editing/selection/home-end.html css2.1/t1202-counter-02-b.html css2.1/t1202-counter-04-b.html http/tests/security/view-source-no-refresh.html css2.1/t1202-counter-15-b.html css2.1/t1202-counters-09-b.html css2.1/t1202-counters-11-b.html css2.1/t1202-counter-16-f.html css2.1/t1202-counters-04-b.html css2.1/t1202-counters-03-b.html css2.1/t1202-counter-12-b.html css2.1/t1202-counters-07-b.html css2.1/t1202-counter-09-b.html css2.1/t1202-counters-08-b.html css2.1/t1202-counter-14-b.html css2.1/t1202-counter-11-b.html css2.1/t1202-counters-01-b.html http/tests/security/view-source-no-javascript-url.html css2.1/t1202-counter-13-b.html css2.1/t1202-counter-05-b.html css2.1/t1202-counter-06-b.html css2.1/t1202-counter-03-b.html css2.1/t1202-counters-02-b.html css2.1/t1202-counters-00-b.html css2.1/t1202-counter-00-b.html css2.1/t1202-counters-05-b.html 793320 13 179844 buildbot 2012-12-17 20:52:08 -0800 Comment on attachment 179844 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. Attachment 179844 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/15372989 793375 14 179844 eflews.bot 2012-12-17 22:39:52 -0800 Comment on attachment 179844 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. Attachment 179844 did not pass efl-ews (efl): Output: http://queues.webkit.org/results/15412009 793815 15 179844 jchaffraix 2012-12-18 10:43:29 -0800 Comment on attachment 179844 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. Investigating what went wrong. 793985 16 180014 jchaffraix 2012-12-18 13:19:48 -0800 Created attachment 180014 Proposed change 2: Fixed a dump mistake when switching to tree walking, should pass the tests this time. 794970 17 180014 esprehn 2012-12-19 14:54:01 -0800 Comment on attachment 180014 Proposed change 2: Fixed a dump mistake when switching to tree walking, should pass the tests this time. View in context: https://bugs.webkit.org/attachment.cgi?id=180014&action=review I can't r- this, but I don't think this is right. You're going to execute the mutating tasks inside layout from child frames. > Source/WebCore/rendering/RenderCounter.cpp:35 > +#include <wtf/Functional.h> Why do we need functional? It seems this is not needed anymore. > Source/WebCore/rendering/RenderObject.cpp:462 > +void RenderObject::executePreLayoutTreeMutatingTasks() This should be static. > Source/WebCore/rendering/RenderObject.h:221 > + void executePreLayoutTreeMutatingTasks(); static. And should be called as RenderObject::executePreLayoutTreeMutatingTasks() since it affects every document's render tree, not just the one that's about to layout. This still seems rather dangerous to be honest since inside ::layout() if we call ::layout() on a child frame that would execute all the mutating tasks on the parent render tree which is bad. I think this happens for seamless iframes. 794978 18 esprehn 2012-12-19 14:57:43 -0800 (In reply to comment #17) > (From update of attachment 180014 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=180014&action=review > > I can't r- this, but I don't think this is right. You're going to execute the mutating tasks inside layout from child frames. Oh I see, you walk the entire render tree doing hash set lookup for every renderer to avoid the badness. This is going to be crazy slow for counters and quotes. On the HTML5 spec you just introduced a walk of tens of thousands of renderers right before layout. 794979 19 eric 2012-12-19 14:58:26 -0800 Yes. Seamless is one of the ways you can end up laying out / style resolving your ancestors before you. Its not safe to assume subtree layouts are idempotent. :) 794985 20 esprehn 2012-12-19 15:02:55 -0800 (In reply to comment #19) > Yes. Seamless is one of the ways you can end up laying out / style resolving your ancestors before you. Its not safe to assume subtree layouts are idempotent. :) Yeah, I just noticed that Julien has a full tree walk in there to prevent the badness I had described: for (RenderObject* object = this; object; object = object->nextInPreOrder(this)) { if (gPreLayoutTreeMutatingTasks->contains(object)) object->doPreLayoutTreeMutatingTask(); } and this shouldn't be static, my bad for not looking closer. :) Still this seems like it'll be a huge perf hit for html5-full-parse.html since we're walking tens of thousands of renderers and doing a hashtable lookup for each one as soon as there's a single <q> in there. 794992 21 inferno 2012-12-19 15:07:49 -0800 (In reply to comment #20) > (In reply to comment #19) > > Yes. Seamless is one of the ways you can end up laying out / style resolving your ancestors before you. Its not safe to assume subtree layouts are idempotent. :) > > Yeah, I just noticed that Julien has a full tree walk in there to prevent the badness I had described: > > for (RenderObject* object = this; object; object = object->nextInPreOrder(this)) { > if (gPreLayoutTreeMutatingTasks->contains(object)) > object->doPreLayoutTreeMutatingTask(); > } > > and this shouldn't be static, my bad for not looking closer. :) > > Still this seems like it'll be a huge perf hit for html5-full-parse.html since we're walking tens of thousands of renderers and doing a hashtable lookup for each one as soon as there's a single <q> in there. I think it will be way faster to do it the other way around, go over all the renderers in the hashset and see if they are a descendant of |this|. I hope the order does not matter. 794999 22 esprehn 2012-12-19 15:10:50 -0800 (In reply to comment #21) > ... > > I think it will be way faster to do it the other way around, go over all the renderers in the hashset and see if they are a descendant of |this|. I hope the order does not matter. That would certainly be better. We could also optimize it so that if the |this| is the RenderView then we just check renderer->view() == this instead of walking up through every parent. 795042 23 jchaffraix 2012-12-19 16:51:33 -0800 > > I think it will be way faster to do it the other way around, go over all the renderers in the hashset and see if they are a descendant of |this|. I hope the order does not matter. > > That would certainly be better. We could also optimize it so that if the |this| is the RenderView then we just check renderer->view() == this instead of walking up through every parent. It seems that what you are asking for is what I was proposing initially (see comment #5): basically register a renderer for a pre-layout task and execute the task just on them. Eric was against this idea due to readability concerns and I misread Simon's comment, thinking he agreed with Eric. It may be possible to attach the tasks to the RenderView and run them from there, avoiding the need for the RenderView checks you mentioned. 807403 24 182797 jchaffraix 2013-01-15 10:01:35 -0800 Created attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). 807422 25 182797 tonikitoo 2013-01-15 10:22:12 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review > Source/WebCore/rendering/RenderView.cpp:217 > +bool RenderView::isRegisteredForPreLayoutTask(RenderObject* object) const? 807427 26 182797 esprehn 2013-01-15 10:27:01 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review Awesome! At some point we may consider sorting the HashSet in tree order as it would make implementing Counters or Quotes faster and easier, but we can do that later. > Source/WebCore/ChangeLog:11 > + Refactoring, no expected change in behavior (apart from counter not mutating the tree during layout). You might note that this doesn't execute the tree mutating tasks in tree order, but in registration order. > Source/WebCore/rendering/RenderView.cpp:217 > +bool RenderView::isRegisteredForPreLayoutTask(RenderObject* object) Missing const for the method > Source/WebCore/rendering/RenderView.cpp:244 > + RenderObject* currentRenderer = renderers[i]; You might add a comment here that currentRenderer could have already been free'd() because of a previous call to executePreLayoutTreeMutatingTask(). > Source/WebCore/rendering/RenderView.h:232 > + bool isRegisteredForPreLayoutTask(RenderObject*); const; 807429 27 182797 darin 2013-01-15 10:27:34 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review > Source/WebCore/rendering/RenderView.cpp:247 > + Vector<RenderObject*> renderers; > + copyToVector(*m_preLayoutTreeMutatingTasks, renderers); > + for (size_t i = 0; i < renderers.size(); ++i) { > + RenderObject* currentRenderer = renderers[i]; > + if (m_preLayoutTreeMutatingTasks->contains(currentRenderer)) > + currentRenderer->executePreLayoutTreeMutatingTask(); > + } Is it safe to do these in an unpredictable, hash table order? If we want to do them in registration order we need to use a ListHashSet instead of a HashSet. 807436 28 esprehn 2013-01-15 10:31:20 -0800 (In reply to comment #26) > (From update of attachment 182797 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review > ... > > You might note that this doesn't execute the tree mutating tasks in tree order, but in registration order. I noticed I was wrong, but forgot to remove this comment. HashSet is effectively random order, ListHashSet would be registration order. It's probably better to use HashSet for now since it keeps people from depending on the order since the initial render tree construction on page load would produce tree order from registration order, but then doing an appendChild(...) of a new counter would place it out of order (on the end). I like having this imposed randomness unless we plan to sort in tree order. 807437 29 182797 buildbot 2013-01-15 10:32:20 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). Attachment 182797 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/15900086 807471 30 182797 peter+ews 2013-01-15 11:05:34 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). Attachment 182797 did not pass cr-android-ews (chromium-android): Output: http://queues.webkit.org/results/15900090 807510 31 182797 jchaffraix 2013-01-15 11:34:47 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review >>> Source/WebCore/rendering/RenderView.cpp:217 >>> +bool RenderView::isRegisteredForPreLayoutTask(RenderObject* object) >> >> const? > > Missing const for the method Totally missed this one, will fix (along with the build). >> Source/WebCore/rendering/RenderView.cpp:244 >> + RenderObject* currentRenderer = renderers[i]; > > You might add a comment here that currentRenderer could have already been free'd() because of a previous call to executePreLayoutTreeMutatingTask(). Sure to both comments. >> Source/WebCore/rendering/RenderView.cpp:247 >> + } > > Is it safe to do these in an unpredictable, hash table order? If we want to do them in registration order we need to use a ListHashSet instead of a HashSet. Both orders are arbitrary as we ideally should follow a tree ordering. As the pre-layout tasks are very self-contained (ie touch one renderer) and we properly check for deletion, a random order should be fine. 807518 32 rniwa 2013-01-15 11:39:42 -0800 (In reply to comment #31) > (From update of attachment 182797 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review > > >> Source/WebCore/rendering/RenderView.cpp:247 > >> + } > > > > Is it safe to do these in an unpredictable, hash table order? If we want to do them in registration order we need to use a ListHashSet instead of a HashSet. > > Both orders are arbitrary as we ideally should follow a tree ordering. As the pre-layout tasks are very self-contained (ie touch one renderer) and we properly check for deletion, a random order should be fine. Is there a way to enforce that? Or can we change function/variable names to reflect this intention? It's not obvious from your patch that pre layout mutation is supposed to be constrained within one renderer. 807574 33 182797 eflews.bot 2013-01-15 12:38:19 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). Attachment 182797 did not pass efl-ews (efl): Output: http://queues.webkit.org/results/15908003 807611 34 182797 jchaffraix 2013-01-15 13:00:11 -0800 Comment on attachment 182797 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review >>>> Source/WebCore/rendering/RenderView.cpp:247 >>>> + } >>> >>> Is it safe to do these in an unpredictable, hash table order? If we want to do them in registration order we need to use a ListHashSet instead of a HashSet. >> >> Both orders are arbitrary as we ideally should follow a tree ordering. As the pre-layout tasks are very self-contained (ie touch one renderer) and we properly check for deletion, a random order should be fine. > > Is there a way to enforce that? Or can we change function/variable names to reflect this intention? It's not obvious from your patch that pre layout mutation is supposed to be constrained within one renderer. My wording was wrong: some tasks are self-contained (e.g RenderCounter) but other are not (like RenderMathMLOperation or RenderQuote). That's also why we need to handle deletion in the loop above. Enforcing self-containment would be artificial and reduce the usefulness of this code. 807621 35 rniwa 2013-01-15 13:06:14 -0800 (In reply to comment #34) > (From update of attachment 182797 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182797&action=review > > My wording was wrong: some tasks are self-contained (e.g RenderCounter) but other are not (like RenderMathMLOperation or RenderQuote). That's also why we need to handle deletion in the loop above. > > Enforcing self-containment would be artificial and reduce the usefulness of this code. If that were the case, why is it okay to execute these tasks in a random order? 807682 36 jchaffraix 2013-01-15 14:18:14 -0800 (Replying inline as the review tool didn't show your comment, not sure why) > > Enforcing self-containment would be artificial and reduce the usefulness of this code. > > If that were the case, why is it okay to execute these tasks in a random order? It is fine to do a random order execution as we iterate over a frozen set ensuring the objects are still alive when executing the task. We thought of other bugs that could be traversal dependent but couldn't think of others. If there are other bugs, we can ensure that the renderers are ordered. Note that random order could end up doing some extra-work (e.g. if you process the children and then blow them off when you reach the parent) but that shouldn't be much of a big deal as these conditions should be rare. 807835 37 182878 jchaffraix 2013-01-15 17:10:40 -0800 Created attachment 182878 Patch v4: Fixed release build and integrated all the comments. 807849 38 182883 jchaffraix 2013-01-15 17:30:06 -0800 Created attachment 182883 Patch v5: Rebaselined for the EWS. 807988 39 rniwa 2013-01-15 20:02:47 -0800 (In reply to comment #36) > > Note that random order could end up doing some extra-work (e.g. if you process the children and then blow them off when you reach the parent) but that shouldn't be much of a big deal as these conditions should be rare. That sounds extremely bad. What if we had a bug in that rare cases? We'll end up having a non-deterministic test failures. 814696 40 jchaffraix 2013-01-23 14:57:32 -0800 (In reply to comment #39) > (In reply to comment #36) > > > > Note that random order could end up doing some extra-work (e.g. if you process the children and then blow them off when you reach the parent) but that shouldn't be much of a big deal as these conditions should be rare. > > That sounds extremely bad. What if we had a bug in that rare cases? We'll end up having a non-deterministic test failures. I have a hard time figuring your point here. Are you arguing to use a ListHashSet to get a deterministic traversal or is it something else? 816744 41 182883 inferno 2013-01-25 10:55:38 -0800 Comment on attachment 182883 Patch v5: Rebaselined for the EWS. View in context: https://bugs.webkit.org/attachment.cgi?id=182883&action=review Lets use the ListHashSet for deterministic order in traversal and predictable failures. > Source/WebCore/rendering/RenderView.cpp:218 > + m_preLayoutTreeMutatingTasks = adoptPtr(new HashSet<RenderObject*>()); Don't we have a typedef for ListHashSet<RenderObject*> ? 816749 42 182883 ojan 2013-01-25 11:00:35 -0800 Comment on attachment 182883 Patch v5: Rebaselined for the EWS. Are we guaranteed that computePreferredLogicalWidths is only called from within layout? If not, you could end up in a case where computePreferredLogicalWidths computes the wrong values because the pre layout tasks haven't been run. 816755 43 ojan 2013-01-25 11:03:08 -0800 *** Bug 107958 has been marked as a duplicate of this bug. *** 816763 44 esprehn 2013-01-25 11:06:37 -0800 (In reply to comment #41) > (From update of attachment 182883 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=182883&action=review > > Lets use the ListHashSet for deterministic order in traversal and predictable failures. > If we go this route we need to be really careful about test coverage. Lots of tests are going to end up running the tasks in tree order because they just use the render tree as it resulted from the page load. Maybe we can use mod or something to predictably shuffle the elements out of tree order, or just make sure it's always sorted in tree order. I liked using HashSet since it prevents people from depending on this, but it does make test failures hard to debug. 816771 45 ojan 2013-01-25 11:13:02 -0800 I'll try adding an assert that we're in layout when computing preferred widths and see what breaks. :) 816779 46 ojan 2013-01-25 11:23:24 -0800 Looks like we hit this assert a lot. Will dig into the stack to see if this is easily fixable. Until this is fixed, this patch isn't quite correct though. 816784 47 jchaffraix 2013-01-25 11:29:29 -0800 (In reply to comment #46) > Looks like we hit this assert a lot. Will dig into the stack to see if this is easily fixable. Until this is fixed, this patch isn't quite correct though. Weird, I did some manual checking (not as good as your ASSERT) and found one violation: RenderMarquee which pokes its box's preferred logical widths during scroll (which should be fine as we expect layout information to be accurate). (In reply to comment #44) > (In reply to comment #41) > > (From update of attachment 182883 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=182883&action=review > > > > Lets use the ListHashSet for deterministic order in traversal and predictable failures. > > > > If we go this route we need to be really careful about test coverage. Lots of tests are going to end up running the tasks in tree order because they just use the render tree as it resulted from the page load. > > Maybe we can use mod or something to predictably shuffle the elements out of tree order, or just make sure it's always sorted in tree order. > > I liked using HashSet since it prevents people from depending on this, but it does make test failures hard to debug. I would rather keep that for a follow-up patch if we see the need for it. Also I would expect our fuzzers to pick up out of order traversal if it causes an issue. 816820 48 ojan 2013-01-25 12:00:34 -0800 (In reply to comment #47) > (In reply to comment #46) > > Looks like we hit this assert a lot. Will dig into the stack to see if this is easily fixable. Until this is fixed, this patch isn't quite correct though. > > Weird, I did some manual checking (not as good as your ASSERT) and found one violation: RenderMarquee which pokes its box's preferred logical widths during scroll (which should be fine as we expect layout information to be accurate). I'm working on refining the assert. I think this patch is fine to go in and we can just fix any violations that would be a problem. For example, the most common violation is in RenderImage, which is fine as long as we don't add a pre-layout hook to RenderImage. 816836 49 esprehn 2013-01-25 12:18:48 -0800 (In reply to comment #48) > (In reply to comment #47) > > (In reply to comment #46) > > > Looks like we hit this assert a lot. Will dig into the stack to see if this is easily fixable. Until this is fixed, this patch isn't quite correct though. > > > > Weird, I did some manual checking (not as good as your ASSERT) and found one violation: RenderMarquee which pokes its box's preferred logical widths during scroll (which should be fine as we expect layout information to be accurate). > > I'm working on refining the assert. I think this patch is fine to go in and we can just fix any violations that would be a problem. For example, the most common violation is in RenderImage, which is fine as long as we don't add a pre-layout hook to RenderImage. Can we add an ASSERT(!renderer->isImage()) in the register function for the hook with a FIXME? 816905 50 182883 ojan 2013-01-25 14:06:33 -0800 Comment on attachment 182883 Patch v5: Rebaselined for the EWS. View in context: https://bugs.webkit.org/attachment.cgi?id=182883&action=review > Source/WebCore/rendering/RenderCounter.h:52 > + virtual void executePreLayoutTreeMutatingTask() OVERRIDE; I think this name needs to change. Really this needs to run before we compute intrinsic widths. For example, see RenderIFrame::maxPreferredLogicalWidth. We need to run this on childRoot before we run childRoot->maxPreferredLogicalWidth(). There's no layout involved. Same thing applies to the documentView->minPreferredLogicalWidth() call in FrameView::autoSizeIfEnabled. prepareTreeForWidthComputation ? 816914 51 182883 jchaffraix 2013-01-25 14:25:32 -0800 Comment on attachment 182883 Patch v5: Rebaselined for the EWS. View in context: https://bugs.webkit.org/attachment.cgi?id=182883&action=review >> Source/WebCore/rendering/RenderCounter.h:52 >> + virtual void executePreLayoutTreeMutatingTask() OVERRIDE; > > I think this name needs to change. Really this needs to run before we compute intrinsic widths. For example, see RenderIFrame::maxPreferredLogicalWidth. We need to run this on childRoot before we run childRoot->maxPreferredLogicalWidth(). There's no layout involved. > > Same thing applies to the documentView->minPreferredLogicalWidth() call in FrameView::autoSizeIfEnabled. > > prepareTreeForWidthComputation ? Fine with the new name (not super happy that it doesn't underline that the tasks are tree mutating but I could live with that). >> Source/WebCore/rendering/RenderView.cpp:218 >> + m_preLayoutTreeMutatingTasks = adoptPtr(new HashSet<RenderObject*>()); > > Don't we have a typedef for ListHashSet<RenderObject*> ? No, there is none. > Source/WebCore/rendering/RenderView.cpp:235 > + copyToVector(*m_preLayoutTreeMutatingTasks, renderers); Using ListHashSet will require implementing copyToVector (just a FYI). 816917 52 ojan 2013-01-25 14:34:23 -0800 Was talking to Emil and Levi and we had some more thoughts on this. While this is a clear improvement over our current state of affairs, the ideal solution would be to not do any of the tree mutating at all (e.g. do it during styleDidChange/childrenChanged or something like that). Given that, we should try to make it as clear as possible that new code could not be adding treemutating tasks. Maybe we could make the naming clear that it's only for quotes and counters? Or maybe we could have the register function assert that the object it gets is a quote/counter? Is there anything other than quotes/counters we want this for? (In reply to comment #51) > > prepareTreeForWidthComputation ? > > Fine with the new name (not super happy that it doesn't underline that the tasks are tree mutating but I could live with that). I'd be fine with an even more verbose name. I just think it needs to be clear that it's pre width computation, not just pre layout. 816937 53 ojan 2013-01-25 14:57:16 -0800 How's this for verbose: mutateTreeBeforeWidthComputationOrLayout :) 816947 54 jchaffraix 2013-01-25 15:17:36 -0800 (In reply to comment #52) > Was talking to Emil and Levi and we had some more thoughts on this. While this is a clear improvement over our current state of affairs, the ideal solution would be to not do any of the tree mutating at all (e.g. do it during styleDidChange/childrenChanged or something like that). The idea is really to start enforcing a no-tree-mutation policy, which would effectively prevent new violations. > Given that, we should try to make it as clear as possible that new code could not be adding treemutating tasks. Maybe we could make the naming clear that it's only for quotes and counters? Or maybe we could have the register function assert that the object it gets is a quote/counter? Is there anything other than quotes/counters we want this for? From the description (comment 0), here is the (non-exhaustive) list: * RenderCounter (calling updateText during computePreferredLogicalWidths) * RenderQuote (calling attachQuote during computePreferredLogicalWidths) * first-letter in RenderBlock and RenderTableCell (calling updateFirstLetter during computePreferredLogicalWidths and layout) * RenderMathMLOperator (calling updateFromElement during computePreferredLogicalWidths). [You removed the tree mutation in RenderListItem since this bug was open.] We could probably add an ASSERT but we will have to be careful to avoid weakening it (RenderBlocks should only have a pre-width computation task if they have first-letter set). (In reply to comment #53) > How's this for verbose: mutateTreeBeforeWidthComputationOrLayout :) I like it better than the previous version, it also conveys the idea that pre-width computation hooks (a bit dry). 816965 55 esprehn 2013-01-25 15:39:25 -0800 (In reply to comment #52) > Was talking to Emil and Levi and we had some more thoughts on this. While this is a clear improvement over our current state of affairs, the ideal solution would be to not do any of the tree mutating at all (e.g. do it during styleDidChange/childrenChanged or something like that). > Yes, I have plans to move more and more of this into recalcStyle() hooks. 833605 56 esprehn 2013-02-14 18:10:50 -0800 (In reply to comment #55) > (In reply to comment #52) > > Was talking to Emil and Levi and we had some more thoughts on this. While this is a clear improvement over our current state of affairs, the ideal solution would be to not do any of the tree mutating at all (e.g. do it during styleDidChange/childrenChanged or something like that). > > > > Yes, I have plans to move more and more of this into recalcStyle() hooks. First step of RenderQuote: https://bugs.webkit.org/show_bug.cgi?id=109876 839163 57 jchaffraix 2013-02-21 20:04:36 -0800 We discussed this patch with Ojan and Elliot and based on the fact that computePreferredLogicalWidths is called outside layout, the assumptions that this patch make are wrong. There is no clear path to fix the patch and it would probably be better to just fix the offending call sites instead of introducing the concept of pre-layout hooks in the first place. Marking as WONTFIX based on the previous explanations. 179844 2012-12-17 18:11:54 -0800 2012-12-18 13:19:45 -0800 Proposed fix: Took Simon & Eric comments into account -> full tree traversal if we have a task, use of an out-of-band mechanism. bug-104829-20121217180911.patch text/plain 8367 jchaffraix U3VidmVyc2lvbiBSZXZpc2lvbjogMTM3OTE1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmM3ODMyNjAyYTdkNTRi NGFmMjdkZTQ2ZjFlNGY1MzgxZDNjMTQ4Ni4uMjJkNGIzOTYyODAyZjNmZGJmNjI4OTQ3MWY5YjZh NTk1OTQ3NjczYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ2IEBACisyMDEyLTEyLTE3ICBKdWxp ZW4gQ2hhZmZyYWl4ICA8amNoYWZmcmFpeEB3ZWJraXQub3JnPgorCisgICAgICAgIEludHJvZHVj ZSBhIG1lY2hhbmlzbSB0byBydW4gYSB0YXNrIGJlZm9yZSBsYXlvdXQgYW5kIG1pZ3JhdGUgUmVu ZGVyQ291bnRlciB0byB1c2luZyBpdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTA0ODI5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhlIG1lY2hhbmlzbSB1c2VzIGEgSGFzaFNldCB0byBzdG9yZSB0aGUg aW5mb3JtYXRpb24gYWJvdXQgd2hldGhlciB0aGVyZSBpcyBhIHRyZWUgbXV0YXRpbmcgdGFzay4g VGhpcworICAgICAgICBtYWtlcyBpdCBlYXN5IHRvIGNoZWNrIGlmIGFueSByZW5kZXJlciBuZWVk cyB0aGUgcGhhc2UgYXMgd2VsbCBhcyBvbmx5IGNhbGwgZG9QcmVMYXlvdXRUcmVlTXV0YXRpbmdU YXNrCisgICAgICAgIG9uIHRoZSByaWdodCByZW5kZXJlcnMuCisKKyAgICAgICAgUmVmYWN0b3Jp bmcsIG5vIGV4cGVjdGVkIGNoYW5nZSBpbiBiZWhhdmlvciAoYXBhcnQgZnJvbSBjb3VudGVyIG5v dCBtdXRhdGluZyB0aGUgdHJlZSBkdXJpbmcgbGF5b3V0KS4KKworICAgICAgICAqIHBhZ2UvRnJh bWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6bGF5b3V0KToKKyAgICAg ICAgQWRkZWQgYSBjYWxsIHRvIGV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy4KKwor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlbmRlckNvdW50ZXI6OlJlbmRlckNvdW50ZXIpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVy Q291bnRlcjo6d2lsbEJlRGVzdHJveWVkKToKKyAgICAgICAgQWRkZWQgdGhlIHJlZ2lzdHJhdGlv biAvIGRlcmVnaXN0cmF0aW9uIGZvciBwcmUtbGF5b3V0IGNhbGxiYWNrLgorCisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJDb3VudGVyOjp1cGRhdGVUZXh0KToKKyAgICAgICAgVXBkYXRlZCB0byBj YWxsIHNldFRleHQsIG1hdGNoaW5nIG90aGVyIG1ldGhvZHMuCisKKyAgICAgICAgKFdlYkNvcmU6 OlJlbmRlckNvdW50ZXI6OmRvUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayk6CisgICAgICAgIEFk ZGVkIHRoaXMgZnVuY3Rpb24gdG8gY2FsbCB1cGRhdGVUZXh0SWZOZWVkZWQgc28gdGhhdCBvdXIg dGV4dCBpcworICAgICAgICB1cC10by1kYXRlIHdoZW4gbGF5b3V0IGhhcHBlbnMuCisKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5k ZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjpyZWdpc3RlclBy ZUxheW91dFRyZWVNdXRhdGluZ1Rhc2spOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Ojp1bnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayk6CisgICAgICAgIChXZWJDb3Jl OjpSZW5kZXJPYmplY3Q6OmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyk6CisgICAg ICAgIEFkZGVkIHRoZXNlIGhlbHBlciBmdW5jdGlvbnMuCisKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlck9iamVjdDo6d2lsbEJlRGVzdHJveWVkKToKKyAgICAgICAgQWRkZWQgYW4gQVNTRVJUIHRv IGNhdGNoIGFueSByZW5kZXJlciB0aGF0IHdvdWxkIGZvcmdldCB0byBkZXJlZ2lzdGVyIGl0c2Vs ZiBkdXJpbmcgZGVzdHJ1Y3Rpb24uCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0 Lmg6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmRvUHJlTGF5b3V0VHJlZU11dGF0 aW5nVGFzayk6CisgICAgICAgIEFkZGVkIHRoZSBwcmV2aW91cyBuZXcgZnVuY3Rpb25zIGFuZCB0 aGUgdmlydHVhbCBkb1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2suCisKIDIwMTItMTItMTcgIEFu dG9pbmUgUXVpbnQgIDxncmFvdXRzQGFwcGxlLmNvbT4KIAogICAgICAgICBHcmFwaGljc0xheWVy J3MgcmVwYWludCBjb3VudCBzaG91bGQgdXBkYXRlIGV2ZW4gd2hlbiBkZWJ1Z2dpbmcgb3B0aW9u IHRvIHNob3cgaXQgaXMgb2ZmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1l Vmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKaW5kZXggYzZiNjJj NzBlNWJiYjA0MGE2NjIzMTRkZjMzNDVjMzk4OTk2NjYxMi4uMGZiYjUzY2M2ZjQxOTM2YTJkZDY4 ZTQ3YzA3MjZkYzYwZjY4ODk2NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApAQCAtMTIw MSw2ICsxMjAxLDcgQEAgdm9pZCBGcmFtZVZpZXc6OmxheW91dChib29sIGFsbG93U3VidHJlZSkK ICAgICAgICAgICAgIG1faW5MYXlvdXQgPSB0cnVlOwogICAgICAgICAgICAgYmVnaW5EZWZlcnJl ZFJlcGFpbnRzKCk7CiAgICAgICAgICAgICBmb3JjZUxheW91dFBhcmVudFZpZXdJZk5lZWRlZCgp OworICAgICAgICAgICAgcm9vdC0+ZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzKCk7 CiAgICAgICAgICAgICByb290LT5sYXlvdXQoKTsKICNpZiBFTkFCTEUoVEVYVF9BVVRPU0laSU5H KQogICAgICAgICAgICAgYm9vbCBhdXRvc2l6ZWQgPSBkb2N1bWVudC0+dGV4dEF1dG9zaXplcigp LT5wcm9jZXNzU3VidHJlZShyb290KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJDb3VudGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJD b3VudGVyLmNwcAppbmRleCBhZmZjNThkZDBlMzlhMTAxOTE5ZGYyYjMyOGFkZDBhMmQzYmU1MWMz Li5hNTdhYzk1MGRiYjZiNTdjZjdhODcxNjQ1MDljNWUyMGQ4ZTNkOTdmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCkBAIC0zMiw2ICszMiw3IEBACiAjaW5j bHVkZSAiUmVuZGVyTGlzdE1hcmtlci5oIgogI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCiAjaW5j bHVkZSAiUmVuZGVyVmlldy5oIgorI2luY2x1ZGUgPHd0Zi9GdW5jdGlvbmFsLmg+CiAjaW5jbHVk ZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiAjaWZuZGVmIE5ERUJVRwpAQCAtNDY4LDYgKzQ2OSw3 IEBAIFJlbmRlckNvdW50ZXI6OlJlbmRlckNvdW50ZXIoRG9jdW1lbnQqIG5vZGUsIGNvbnN0IENv dW50ZXJDb250ZW50JiBjb3VudGVyKQogICAgICwgbV9uZXh0Rm9yU2FtZUNvdW50ZXIoMCkKIHsK ICAgICB2aWV3KCktPmFkZFJlbmRlckNvdW50ZXIoKTsKKyAgICByZWdpc3RlclByZUxheW91dFRy ZWVNdXRhdGluZ1Rhc2soKTsKIH0KIAogUmVuZGVyQ291bnRlcjo6flJlbmRlckNvdW50ZXIoKQpA QCAtNDgwLDYgKzQ4Miw3IEBAIFJlbmRlckNvdW50ZXI6On5SZW5kZXJDb3VudGVyKCkKIAogdm9p ZCBSZW5kZXJDb3VudGVyOjp3aWxsQmVEZXN0cm95ZWQoKQogeworICAgIHVucmVnaXN0ZXJQcmVM YXlvdXRUcmVlTXV0YXRpbmdUYXNrKCk7CiAgICAgaWYgKHZpZXcoKSkKICAgICAgICAgdmlldygp LT5yZW1vdmVSZW5kZXJDb3VudGVyKCk7CiAgICAgUmVuZGVyVGV4dDo6d2lsbEJlRGVzdHJveWVk KCk7CkBAIC01MzIsMTMgKzUzNSwxMyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IFJlbmRlckNv dW50ZXI6Om9yaWdpbmFsVGV4dCgpIGNvbnN0CiAKIHZvaWQgUmVuZGVyQ291bnRlcjo6dXBkYXRl VGV4dCgpCiB7CisgICAgc2V0VGV4dEludGVybmFsKG9yaWdpbmFsVGV4dCgpKTsKICAgICBjb21w dXRlUHJlZmVycmVkTG9naWNhbFdpZHRocygwKTsKIH0KIAotdm9pZCBSZW5kZXJDb3VudGVyOjpj b21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocyhmbG9hdCBsZWFkKQordm9pZCBSZW5kZXJDb3Vu dGVyOjpkb1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2soKQogewotICAgIHNldFRleHRJbnRlcm5h bChvcmlnaW5hbFRleHQoKSk7Ci0gICAgUmVuZGVyVGV4dDo6Y29tcHV0ZVByZWZlcnJlZExvZ2lj YWxXaWR0aHMobGVhZCk7CisgICAgdXBkYXRlVGV4dElmTmVlZGVkKCk7CiB9CiAKIHZvaWQgUmVu ZGVyQ291bnRlcjo6aW52YWxpZGF0ZSgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQ291bnRlci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuaAppbmRleCA1NDg4Mjg2NDc5MjRlZGFhODVhNmQzMDkyMGZkMmY0YTVlMWEwODk4Li42 M2ExODczOTM4YjgxZDkwZjJmMGZjZjY5NDhkYTRkMjk2OGNjZDkxIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgKQEAgLTQ3LDkgKzQ3LDEwIEBAIHByaXZhdGU6CiAg ICAgdmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3Q7CiAgICAgdmlydHVhbCBi b29sIGlzQ291bnRlcigpIGNvbnN0OwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxTdHJpbmdJbXBs PiBvcmlnaW5hbFRleHQoKSBjb25zdDsKLSAgICAKKwogICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVU ZXh0KCkgT1ZFUlJJREU7Ci0gICAgdmlydHVhbCB2b2lkIGNvbXB1dGVQcmVmZXJyZWRMb2dpY2Fs V2lkdGhzKGZsb2F0IGxlYWRXaWR0aCk7CisKKyAgICB2aXJ0dWFsIHZvaWQgZG9QcmVMYXlvdXRU cmVlTXV0YXRpbmdUYXNrKCkgT1ZFUlJJREU7CiAKICAgICAvLyBSZW1vdmVzIHRoZSByZWZlcmVu Y2UgdG8gdGhlIENvdW50ZXJOb2RlIGFzc29jaWF0ZWQgd2l0aCB0aGlzIHJlbmRlcmVyLgogICAg IC8vIFRoaXMgaXMgdXNlZCB0byBjYXVzZSBhIGNvdW50ZXIgZGlzcGxheSB1cGRhdGUgd2hlbiB0 aGUgQ291bnRlck5vZGUgdHJlZSBjaGFuZ2VzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyT2JqZWN0LmNwcAppbmRleCBkZWI2ZDk2MGM4ODYwMTI3YjlhN2VkNTg5YWI2ZDA0M2ZkNjA1 ODc0Li42OGRhMTM5MDI5ZmJkODRmYmFhNzJjMDA5ZWUyM2EyOGFhOTY4ZjQ0IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtNzMsNiArNzMsNyBAQAogI2lu Y2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUgPHN0 ZGlvLmg+CisjaW5jbHVkZSA8d3RmL0Z1bmN0aW9uYWwuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291 bnRlZExlYWtDb3VudGVyLmg+CiAjaW5jbHVkZSA8d3RmL1VudXNlZFBhcmFtLmg+CiAKQEAgLTQ0 MSw2ICs0NDIsMzQgQEAgUmVuZGVyT2JqZWN0KiBSZW5kZXJPYmplY3Q6Omxhc3RMZWFmQ2hpbGQo KSBjb25zdAogICAgIHJldHVybiByOwogfQogCitzdGF0aWMgSGFzaFNldDxjb25zdCBSZW5kZXJP YmplY3QqPiogZ1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzOworCit2b2lkIFJlbmRlck9iamVj dDo6cmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCkKK3sKKyAgICBpZiAoIWdQcmVM YXlvdXRUcmVlTXV0YXRpbmdUYXNrcykKKyAgICAgICAgZ1ByZUxheW91dFRyZWVNdXRhdGluZ1Rh c2tzID0gbmV3IEhhc2hTZXQ8Y29uc3QgUmVuZGVyT2JqZWN0Kj47CisgICAgSGFzaFNldDxjb25z dCBSZW5kZXJPYmplY3QqPjo6QWRkUmVzdWx0IHJlc3VsdCA9IGdQcmVMYXlvdXRUcmVlTXV0YXRp bmdUYXNrcy0+YWRkKHRoaXMpOworICAgIEFTU0VSVChyZXN1bHQuaXNOZXdFbnRyeSk7Cit9CisK K3ZvaWQgUmVuZGVyT2JqZWN0Ojp1bnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygp Cit7CisgICAgQVNTRVJUKGdQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyk7CisgICAgQVNTRVJU KGdQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy0+Y29udGFpbnModGhpcykpOworICAgIGdQcmVM YXlvdXRUcmVlTXV0YXRpbmdUYXNrcy0+cmVtb3ZlKHRoaXMpOworfQorCit2b2lkIFJlbmRlck9i amVjdDo6ZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzKCkKK3sKKyAgICBpZiAoIWdQ cmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyB8fCBnUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3Mt PmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgZm9yIChSZW5kZXJPYmplY3QqIG9i amVjdCA9IHRoaXM7IG9iamVjdDsgb2JqZWN0LT5uZXh0SW5QcmVPcmRlcih0aGlzKSkgeworICAg ICAgICBpZiAoZ1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzLT5jb250YWlucyhvYmplY3QpKQor ICAgICAgICAgICAgb2JqZWN0LT5kb1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2soKTsKKyAgICB9 Cit9CisKIHN0YXRpYyB2b2lkIGFkZExheWVycyhSZW5kZXJPYmplY3QqIG9iaiwgUmVuZGVyTGF5 ZXIqIHBhcmVudExheWVyLCBSZW5kZXJPYmplY3QqJiBuZXdPYmplY3QsCiAgICAgICAgICAgICAg ICAgICAgICAgUmVuZGVyTGF5ZXIqJiBiZWZvcmVDaGlsZCkKIHsKQEAgLTIzNTgsNiArMjM4Nyw4 IEBAIGlubGluZSB2b2lkIFJlbmRlck9iamVjdDo6Y2xlYXJMYXlvdXRSb290SWZOZWVkZWQoKSBj b25zdAogCiB2b2lkIFJlbmRlck9iamVjdDo6d2lsbEJlRGVzdHJveWVkKCkKIHsKKyAgICBBU1NF UlQoIWdQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyB8fCAhZ1ByZUxheW91dFRyZWVNdXRhdGlu Z1Rhc2tzLT5jb250YWlucyh0aGlzKSk7CisKICAgICAvLyBEZXN0cm95IGFueSBsZWZ0b3ZlciBh bm9ueW1vdXMgY2hpbGRyZW4uCiAgICAgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0KiBjaGlsZHJlbiA9 IHZpcnR1YWxDaGlsZHJlbigpOwogICAgIGlmIChjaGlsZHJlbikKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJPYmplY3QuaAppbmRleCBkMzgwOTMwYjdjZjBiNmQzZjViZWFhMjdiMjlhM2M2 NGVkNWVlNjk3Li4wZjY3YTAzODBhNGZmODAyNDMxYWFjMjU4MDA0ZDY3MjVhNTE1MTcyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCkBAIC0yMTYsNiArMjE2LDEwIEBA IHB1YmxpYzoKICAgICBSZW5kZXJPYmplY3QqIGZpcnN0TGVhZkNoaWxkKCkgY29uc3Q7CiAgICAg UmVuZGVyT2JqZWN0KiBsYXN0TGVhZkNoaWxkKCkgY29uc3Q7CiAKKyAgICB2b2lkIHJlZ2lzdGVy UHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygpOworICAgIHZvaWQgdW5yZWdpc3RlclByZUxheW91 dFRyZWVNdXRhdGluZ1Rhc2soKTsKKyAgICB2b2lkIGV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRp bmdUYXNrcygpOworCiAgICAgLy8gVGhlIGZvbGxvd2luZyBzaXggZnVuY3Rpb25zIGFyZSB1c2Vk IHdoZW4gdGhlIHJlbmRlciB0cmVlIGhpZXJhcmNoeSBjaGFuZ2VzIHRvIG1ha2Ugc3VyZSBsYXll cnMgZ2V0CiAgICAgLy8gcHJvcGVybHkgYWRkZWQgYW5kIHJlbW92ZWQuICBTaW5jZSBjb250YWlu ZXJzaGlwIGNhbiBiZSBpbXBsZW1lbnRlZCBieSBhbnkgc3ViY2xhc3MsIGFuZCBzaW5jZSBhIGhp ZXJhcmNoeQogICAgIC8vIGNhbiBjb250YWluIGEgbWl4dHVyZSBvZiBib3hlcyBhbmQgb3RoZXIg b2JqZWN0IHR5cGVzLCB0aGVzZSBmdW5jdGlvbnMgbmVlZCB0byBiZSBpbiB0aGUgYmFzZSBjbGFz cy4KQEAgLTI5Nyw2ICszMDEsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgc2V0TGF5ZXJOZWVkc0Z1 bGxSZXBhaW50KCk7CiAgICAgdm9pZCBzZXRMYXllck5lZWRzRnVsbFJlcGFpbnRGb3JQb3NpdGlv bmVkTW92ZW1lbnRMYXlvdXQoKTsKIAorICAgIHZpcnR1YWwgdm9pZCBkb1ByZUxheW91dFRyZWVN dXRhdGluZ1Rhc2soKSB7IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisKIHB1YmxpYzoKICNpZm5k ZWYgTkRFQlVHCiAgICAgdm9pZCBzaG93VHJlZUZvclRoaXMoKSBjb25zdDsK 180014 2012-12-18 13:19:48 -0800 2013-01-15 10:01:30 -0800 Proposed change 2: Fixed a dump mistake when switching to tree walking, should pass the tests this time. bug-104829-20121218131705.patch text/plain 8365 jchaffraix U3VidmVyc2lvbiBSZXZpc2lvbjogMTM4MDM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzMwZTZhMGU3ODU1MGVj MWFlOWQwNmM1ODYwZTJmN2ZiNjFlNzBmMi4uMTc3MDFkMzM0ZWFmY2EzZTcwNDQ3ZmZhNGIzOWZk YjEwMDkzNTBiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ2IEBACisyMDEyLTEyLTE4ICBKdWxp ZW4gQ2hhZmZyYWl4ICA8amNoYWZmcmFpeEB3ZWJraXQub3JnPgorCisgICAgICAgIEludHJvZHVj ZSBhIG1lY2hhbmlzbSB0byBydW4gYSB0YXNrIGJlZm9yZSBsYXlvdXQgYW5kIG1pZ3JhdGUgUmVu ZGVyQ291bnRlciB0byB1c2luZyBpdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTA0ODI5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhlIG1lY2hhbmlzbSB1c2VzIGEgSGFzaFNldCB0byBzdG9yZSB0aGUg aW5mb3JtYXRpb24gYWJvdXQgd2hldGhlciB0aGVyZSBpcyBhIHRyZWUgbXV0YXRpbmcgdGFzay4g VGhpcworICAgICAgICBtYWtlcyBpdCBlYXN5IHRvIGNoZWNrIGlmIGFueSByZW5kZXJlciBuZWVk cyB0aGUgcGhhc2UgYXMgd2VsbCBhcyBvbmx5IGNhbGwgZG9QcmVMYXlvdXRUcmVlTXV0YXRpbmdU YXNrCisgICAgICAgIG9uIHRoZSByaWdodCByZW5kZXJlcnMuCisKKyAgICAgICAgUmVmYWN0b3Jp bmcsIG5vIGV4cGVjdGVkIGNoYW5nZSBpbiBiZWhhdmlvciAoYXBhcnQgZnJvbSBjb3VudGVyIG5v dCBtdXRhdGluZyB0aGUgdHJlZSBkdXJpbmcgbGF5b3V0KS4KKworICAgICAgICAqIHBhZ2UvRnJh bWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6bGF5b3V0KToKKyAgICAg ICAgQWRkZWQgYSBjYWxsIHRvIGV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy4KKwor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlJlbmRlckNvdW50ZXI6OlJlbmRlckNvdW50ZXIpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVy Q291bnRlcjo6d2lsbEJlRGVzdHJveWVkKToKKyAgICAgICAgQWRkZWQgdGhlIHJlZ2lzdHJhdGlv biAvIGRlcmVnaXN0cmF0aW9uIGZvciBwcmUtbGF5b3V0IGNhbGxiYWNrLgorCisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJDb3VudGVyOjp1cGRhdGVUZXh0KToKKyAgICAgICAgVXBkYXRlZCB0byBj YWxsIHNldFRleHQsIG1hdGNoaW5nIG90aGVyIG1ldGhvZHMuCisKKyAgICAgICAgKFdlYkNvcmU6 OlJlbmRlckNvdW50ZXI6OmRvUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayk6CisgICAgICAgIEFk ZGVkIHRoaXMgZnVuY3Rpb24gdG8gY2FsbCB1cGRhdGVUZXh0SWZOZWVkZWQgc28gdGhhdCBvdXIg dGV4dCBpcworICAgICAgICB1cC10by1kYXRlIHdoZW4gbGF5b3V0IGhhcHBlbnMuCisKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5k ZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjpyZWdpc3RlclBy ZUxheW91dFRyZWVNdXRhdGluZ1Rhc2spOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Ojp1bnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayk6CisgICAgICAgIChXZWJDb3Jl OjpSZW5kZXJPYmplY3Q6OmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyk6CisgICAg ICAgIEFkZGVkIHRoZXNlIGhlbHBlciBmdW5jdGlvbnMuCisKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlck9iamVjdDo6d2lsbEJlRGVzdHJveWVkKToKKyAgICAgICAgQWRkZWQgYW4gQVNTRVJUIHRv IGNhdGNoIGFueSByZW5kZXJlciB0aGF0IHdvdWxkIGZvcmdldCB0byBkZXJlZ2lzdGVyIGl0c2Vs ZiBkdXJpbmcgZGVzdHJ1Y3Rpb24uCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0 Lmg6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmRvUHJlTGF5b3V0VHJlZU11dGF0 aW5nVGFzayk6CisgICAgICAgIEFkZGVkIHRoZSBwcmV2aW91cyBuZXcgZnVuY3Rpb25zIGFuZCB0 aGUgdmlydHVhbCBkb1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2suCisKIDIwMTItMTItMTggIFRv bnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSRUdSRVNTSU9OKHIxMzYz MjQpOiBmbGV4IGl0ZW1zIHdpdGggcGVyY2VudCBoZWlnaHRzIG5vdCByZXNpemluZwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IGM2YjYyYzcwZTViYmIwNDBhNjYyMzE0ZGYzMzQ1YzM5 ODk5NjY2MTIuLjBmYmI1M2NjNmY0MTkzNmEyZGQ2OGU0N2MwNzI2ZGM2MGY2ODg5NjQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTEyMDEsNiArMTIwMSw3IEBAIHZvaWQgRnJhbWVW aWV3OjpsYXlvdXQoYm9vbCBhbGxvd1N1YnRyZWUpCiAgICAgICAgICAgICBtX2luTGF5b3V0ID0g dHJ1ZTsKICAgICAgICAgICAgIGJlZ2luRGVmZXJyZWRSZXBhaW50cygpOwogICAgICAgICAgICAg Zm9yY2VMYXlvdXRQYXJlbnRWaWV3SWZOZWVkZWQoKTsKKyAgICAgICAgICAgIHJvb3QtPmV4ZWN1 dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcygpOwogICAgICAgICAgICAgcm9vdC0+bGF5b3V0 KCk7CiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJWklORykKICAgICAgICAgICAgIGJvb2wgYXV0b3Np emVkID0gZG9jdW1lbnQtPnRleHRBdXRvc2l6ZXIoKS0+cHJvY2Vzc1N1YnRyZWUocm9vdCk7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAKaW5kZXggYWZmYzU4ZGQw ZTM5YTEwMTkxOWRmMmIzMjhhZGQwYTJkM2JlNTFjMy4uYTU3YWM5NTBkYmI2YjU3Y2Y3YTg3MTY0 NTA5YzVlMjBkOGUzZDk3ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckNvdW50ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3Vu dGVyLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlJlbmRlckxpc3RNYXJrZXIuaCIK ICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKKyNpbmNs dWRlIDx3dGYvRnVuY3Rpb25hbC5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAog I2lmbmRlZiBOREVCVUcKQEAgLTQ2OCw2ICs0NjksNyBAQCBSZW5kZXJDb3VudGVyOjpSZW5kZXJD b3VudGVyKERvY3VtZW50KiBub2RlLCBjb25zdCBDb3VudGVyQ29udGVudCYgY291bnRlcikKICAg ICAsIG1fbmV4dEZvclNhbWVDb3VudGVyKDApCiB7CiAgICAgdmlldygpLT5hZGRSZW5kZXJDb3Vu dGVyKCk7CisgICAgcmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCk7CiB9CiAKIFJl bmRlckNvdW50ZXI6On5SZW5kZXJDb3VudGVyKCkKQEAgLTQ4MCw2ICs0ODIsNyBAQCBSZW5kZXJD b3VudGVyOjp+UmVuZGVyQ291bnRlcigpCiAKIHZvaWQgUmVuZGVyQ291bnRlcjo6d2lsbEJlRGVz dHJveWVkKCkKIHsKKyAgICB1bnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygpOwog ICAgIGlmICh2aWV3KCkpCiAgICAgICAgIHZpZXcoKS0+cmVtb3ZlUmVuZGVyQ291bnRlcigpOwog ICAgIFJlbmRlclRleHQ6OndpbGxCZURlc3Ryb3llZCgpOwpAQCAtNTMyLDEzICs1MzUsMTMgQEAg UGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBSZW5kZXJDb3VudGVyOjpvcmlnaW5hbFRleHQoKSBjb25z dAogCiB2b2lkIFJlbmRlckNvdW50ZXI6OnVwZGF0ZVRleHQoKQogeworICAgIHNldFRleHRJbnRl cm5hbChvcmlnaW5hbFRleHQoKSk7CiAgICAgY29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0aHMo MCk7CiB9CiAKLXZvaWQgUmVuZGVyQ291bnRlcjo6Y29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0 aHMoZmxvYXQgbGVhZCkKK3ZvaWQgUmVuZGVyQ291bnRlcjo6ZG9QcmVMYXlvdXRUcmVlTXV0YXRp bmdUYXNrKCkKIHsKLSAgICBzZXRUZXh0SW50ZXJuYWwob3JpZ2luYWxUZXh0KCkpOwotICAgIFJl bmRlclRleHQ6OmNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzKGxlYWQpOworICAgIHVwZGF0 ZVRleHRJZk5lZWRlZCgpOwogfQogCiB2b2lkIFJlbmRlckNvdW50ZXI6OmludmFsaWRhdGUoKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaCBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgKaW5kZXggNTQ4ODI4NjQ3OTI0 ZWRhYTg1YTZkMzA5MjBmZDJmNGE1ZTFhMDg5OC4uNjNhMTg3MzkzOGI4MWQ5MGYyZjBmY2Y2OTQ4 ZGE0ZDI5NjhjY2Q5MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckNvdW50ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5o CkBAIC00Nyw5ICs0NywxMCBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVu ZGVyTmFtZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBpc0NvdW50ZXIoKSBjb25zdDsKICAg ICB2aXJ0dWFsIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4gb3JpZ2luYWxUZXh0KCkgY29uc3Q7Ci0g ICAgCisKICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlVGV4dCgpIE9WRVJSSURFOwotICAgIHZpcnR1 YWwgdm9pZCBjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocyhmbG9hdCBsZWFkV2lkdGgpOwor CisgICAgdmlydHVhbCB2b2lkIGRvUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygpIE9WRVJSSURF OwogCiAgICAgLy8gUmVtb3ZlcyB0aGUgcmVmZXJlbmNlIHRvIHRoZSBDb3VudGVyTm9kZSBhc3Nv Y2lhdGVkIHdpdGggdGhpcyByZW5kZXJlci4KICAgICAvLyBUaGlzIGlzIHVzZWQgdG8gY2F1c2Ug YSBjb3VudGVyIGRpc3BsYXkgdXBkYXRlIHdoZW4gdGhlIENvdW50ZXJOb2RlIHRyZWUgY2hhbmdl cy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXggZGViNmQ5 NjBjODg2MDEyN2I5YTdlZDU4OWFiNmQwNDNmZDYwNTg3NC4uN2Y5YmZiYjVmZDM5ZTM2NWI1Njhm NjQwZTBjODQxNzQ3MDRhZjI3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlck9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9i amVjdC5jcHAKQEAgLTczLDYgKzczLDcgQEAKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgogI2lu Y2x1ZGUgPGFsZ29yaXRobT4KICNpbmNsdWRlIDxzdGRpby5oPgorI2luY2x1ZGUgPHd0Zi9GdW5j dGlvbmFsLmg+CiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWRMZWFrQ291bnRlci5oPgogI2luY2x1 ZGUgPHd0Zi9VbnVzZWRQYXJhbS5oPgogCkBAIC00NDEsNiArNDQyLDM0IEBAIFJlbmRlck9iamVj dCogUmVuZGVyT2JqZWN0OjpsYXN0TGVhZkNoaWxkKCkgY29uc3QKICAgICByZXR1cm4gcjsKIH0K IAorc3RhdGljIEhhc2hTZXQ8Y29uc3QgUmVuZGVyT2JqZWN0Kj4qIGdQcmVMYXlvdXRUcmVlTXV0 YXRpbmdUYXNrczsKKwordm9pZCBSZW5kZXJPYmplY3Q6OnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11 dGF0aW5nVGFzaygpCit7CisgICAgaWYgKCFnUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MpCisg ICAgICAgIGdQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyA9IG5ldyBIYXNoU2V0PGNvbnN0IFJl bmRlck9iamVjdCo+OworICAgIEhhc2hTZXQ8Y29uc3QgUmVuZGVyT2JqZWN0Kj46OkFkZFJlc3Vs dCByZXN1bHQgPSBnUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MtPmFkZCh0aGlzKTsKKyAgICBB U1NFUlRfVU5VU0VEKHJlc3VsdCwgcmVzdWx0LmlzTmV3RW50cnkpOworfQorCit2b2lkIFJlbmRl ck9iamVjdDo6dW5yZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2soKQoreworICAgIEFT U0VSVChnUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MpOworICAgIEFTU0VSVChnUHJlTGF5b3V0 VHJlZU11dGF0aW5nVGFza3MtPmNvbnRhaW5zKHRoaXMpKTsKKyAgICBnUHJlTGF5b3V0VHJlZU11 dGF0aW5nVGFza3MtPnJlbW92ZSh0aGlzKTsKK30KKwordm9pZCBSZW5kZXJPYmplY3Q6OmV4ZWN1 dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcygpCit7CisgICAgaWYgKCFnUHJlTGF5b3V0VHJl ZU11dGF0aW5nVGFza3MgfHwgZ1ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzLT5pc0VtcHR5KCkp CisgICAgICAgIHJldHVybjsKKworICAgIGZvciAoUmVuZGVyT2JqZWN0KiBvYmplY3QgPSB0aGlz OyBvYmplY3Q7IG9iamVjdCA9IG9iamVjdC0+bmV4dEluUHJlT3JkZXIodGhpcykpIHsKKyAgICAg ICAgaWYgKGdQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy0+Y29udGFpbnMob2JqZWN0KSkKKyAg ICAgICAgICAgIG9iamVjdC0+ZG9QcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCk7CisgICAgfQor fQorCiBzdGF0aWMgdm9pZCBhZGRMYXllcnMoUmVuZGVyT2JqZWN0KiBvYmosIFJlbmRlckxheWVy KiBwYXJlbnRMYXllciwgUmVuZGVyT2JqZWN0KiYgbmV3T2JqZWN0LAogICAgICAgICAgICAgICAg ICAgICAgIFJlbmRlckxheWVyKiYgYmVmb3JlQ2hpbGQpCiB7CkBAIC0yMzU4LDYgKzIzODcsOCBA QCBpbmxpbmUgdm9pZCBSZW5kZXJPYmplY3Q6OmNsZWFyTGF5b3V0Um9vdElmTmVlZGVkKCkgY29u c3QKIAogdm9pZCBSZW5kZXJPYmplY3Q6OndpbGxCZURlc3Ryb3llZCgpCiB7CisgICAgQVNTRVJU KCFnUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MgfHwgIWdQcmVMYXlvdXRUcmVlTXV0YXRpbmdU YXNrcy0+Y29udGFpbnModGhpcykpOworCiAgICAgLy8gRGVzdHJveSBhbnkgbGVmdG92ZXIgYW5v bnltb3VzIGNoaWxkcmVuLgogICAgIFJlbmRlck9iamVjdENoaWxkTGlzdCogY2hpbGRyZW4gPSB2 aXJ0dWFsQ2hpbGRyZW4oKTsKICAgICBpZiAoY2hpbGRyZW4pCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmgKaW5kZXggZDM4MDkzMGI3Y2YwYjZkM2Y1YmVhYTI3YjI5YTNjNjRl ZDVlZTY5Ny4uMGY2N2EwMzgwYTRmZjgwMjQzMWFhYzI1ODAwNGQ2NzI1YTUxNTE3MiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaApAQCAtMjE2LDYgKzIxNiwxMCBAQCBw dWJsaWM6CiAgICAgUmVuZGVyT2JqZWN0KiBmaXJzdExlYWZDaGlsZCgpIGNvbnN0OwogICAgIFJl bmRlck9iamVjdCogbGFzdExlYWZDaGlsZCgpIGNvbnN0OwogCisgICAgdm9pZCByZWdpc3RlclBy ZUxheW91dFRyZWVNdXRhdGluZ1Rhc2soKTsKKyAgICB2b2lkIHVucmVnaXN0ZXJQcmVMYXlvdXRU cmVlTXV0YXRpbmdUYXNrKCk7CisgICAgdm9pZCBleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5n VGFza3MoKTsKKwogICAgIC8vIFRoZSBmb2xsb3dpbmcgc2l4IGZ1bmN0aW9ucyBhcmUgdXNlZCB3 aGVuIHRoZSByZW5kZXIgdHJlZSBoaWVyYXJjaHkgY2hhbmdlcyB0byBtYWtlIHN1cmUgbGF5ZXJz IGdldAogICAgIC8vIHByb3Blcmx5IGFkZGVkIGFuZCByZW1vdmVkLiAgU2luY2UgY29udGFpbmVy c2hpcCBjYW4gYmUgaW1wbGVtZW50ZWQgYnkgYW55IHN1YmNsYXNzLCBhbmQgc2luY2UgYSBoaWVy YXJjaHkKICAgICAvLyBjYW4gY29udGFpbiBhIG1peHR1cmUgb2YgYm94ZXMgYW5kIG90aGVyIG9i amVjdCB0eXBlcywgdGhlc2UgZnVuY3Rpb25zIG5lZWQgdG8gYmUgaW4gdGhlIGJhc2UgY2xhc3Mu CkBAIC0yOTcsNiArMzAxLDggQEAgcHJpdmF0ZToKICAgICB2b2lkIHNldExheWVyTmVlZHNGdWxs UmVwYWludCgpOwogICAgIHZvaWQgc2V0TGF5ZXJOZWVkc0Z1bGxSZXBhaW50Rm9yUG9zaXRpb25l ZE1vdmVtZW50TGF5b3V0KCk7CiAKKyAgICB2aXJ0dWFsIHZvaWQgZG9QcmVMYXlvdXRUcmVlTXV0 YXRpbmdUYXNrKCkgeyBBU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorCiBwdWJsaWM6CiAjaWZuZGVm IE5ERUJVRwogICAgIHZvaWQgc2hvd1RyZWVGb3JUaGlzKCkgY29uc3Q7Cg== 182797 2013-01-15 10:01:35 -0800 2013-01-15 17:10:36 -0800 Updated fix: Avoids the tree iteration, the mechanism hangs off the RenderView (like the counter counting mechanism). bug-104829-20130115095836.patch text/plain 9907 jchaffraix U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5NjE0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzljZGI0NWFlZjg4ZGIz NTBhZGUxOTVlOTc1ZjdkZmQ2YjM2YzBhZS4uYjMyZTU5OGZiNjllMjlmMDFkM2JlMzdkZGY4MWYx OTkzMGI0ZTVhZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU4IEBACisyMDEzLTAxLTE1ICBKdWxp ZW4gQ2hhZmZyYWl4ICA8amNoYWZmcmFpeEB3ZWJraXQub3JnPgorCisgICAgICAgIEludHJvZHVj ZSBhIG1lY2hhbmlzbSB0byBydW4gYSB0YXNrIGJlZm9yZSBsYXlvdXQgYW5kIG1pZ3JhdGUgUmVu ZGVyQ291bnRlciB0byB1c2luZyBpdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTA0ODI5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhlIHByZS1sYXlvdXQgdGFza3MgYXJlIHJlZ2lzdGVyZWQgYW5kIGtl cHQgYnkgdGhlIFJlbmRlclZpZXcuIFRoaXMgYXZvaWRzIGhhdmluZyB0byBtYWludGFpbiB0aGUK KyAgICAgICAgaW5mb3JtYXRpb24gaW4gdGhlIHJlbmRlcmVyIGFzIGl0IGlzIHN1cHBvc2VkIHRv IGJlIHJhcmUuCisKKyAgICAgICAgUmVmYWN0b3JpbmcsIG5vIGV4cGVjdGVkIGNoYW5nZSBpbiBi ZWhhdmlvciAoYXBhcnQgZnJvbSBjb3VudGVyIG5vdCBtdXRhdGluZyB0aGUgdHJlZSBkdXJpbmcg bGF5b3V0KS4KKworICAgICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkZyYW1lVmlldzo6bGF5b3V0KToKKyAgICAgICAgQ2hhbmdlZCB0byBjYWxsIFJlbmRlclZp ZXc6OmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy4KKworICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJDb3VudGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50ZXI6 OlJlbmRlckNvdW50ZXIpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6d2lsbEJl RGVzdHJveWVkKToKKyAgICAgICAgVXBkYXRlZCB0byByZWdpc3RlciAvIHVucmVnaXN0ZXIgdGhp cyByZW5kZXJlciBhcyBuZWVkaW5nIGEgcHJlLWxheW91dCB0YXNrLgorCisgICAgICAgIChXZWJD b3JlOjpSZW5kZXJDb3VudGVyOjp1cGRhdGVUZXh0KToKKyAgICAgICAgTWVyZ2UgY29tcHV0ZVBy ZWZlcnJlZExvZ2ljYWxXaWR0aHMgY29kZSBoZXJlIHNvIHRoYXQgY29tcHV0ZVByZWZlcnJlZExv Z2ljYWxXaWR0aHMKKyAgICAgICAgbm93IGRvZXNuJ3QgbXV0YXRlIHRoZSB0cmVlLgorCisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5n VGFzayk6CisgICAgICAgIEFkZGVkIGEgY2FsbCB0byB1cGRhdGVUZXh0SWZOZWVkZWQgc28gdGhh dCB0aGUgdGV4dCBpcyB1cC10by1kYXRlIGZvciBsYXlvdXQuCisKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyQ291bnRlci5oOgorICAgICAgICBSZW1vdmVkIGNvbXB1dGVQcmVmZXJyZWRMb2dp Y2FsV2lkdGhzLCBhZGRlZCBleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzay4KKworICAg ICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVu ZGVyT2JqZWN0Ojp3aWxsQmVEZXN0cm95ZWQpOgorICAgICAgICBBZGRlZCBhbiBBU1NFUlQgdG8g Y2F0Y2ggYW55IHJlbmRlcmVyIHRoYXQgd291bGQgZm9yZ2V0IHRvIHVucmVnaXN0ZXIgaXRzZWxm IGR1cmluZyBkZXN0cnVjdGlvbi4KKworICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3Qu aDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6ZXhlY3V0ZVByZUxheW91dFRyZWVN dXRhdGluZ1Rhc2spOgorICAgICAgICBOby1vcCBiYXNlIGltcGxlbWVudGF0aW9uIChBU1NFUlQn aW5nIGZvciBwZXJmb3JtYW5jZSByZWFzb24pLgorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRl clZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVmlldzo6aXNSZWdpc3RlcmVkRm9y UHJlTGF5b3V0VGFzayk6CisgICAgICAgIEhlbHBlciBmdW5jdGlvbiBmb3IgQVNTRVJUcy4KKwor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVmlldzo6cmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRp bmdUYXNrKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclZpZXc6OnVucmVnaXN0ZXJQcmVMYXlv dXRUcmVlTXV0YXRpbmdUYXNrKToKKyAgICAgICAgUmVnaXN0ZXIgLyB1bnJlZ2lzdGVyIG1ldGhv ZHMuCisKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlclZpZXc6OmV4ZWN1dGVQcmVMYXlvdXRUcmVl TXV0YXRpbmdUYXNrcyk6CisgICAgICAgIFRoaXMgZnVuY3Rpb24gaXRlcmF0ZXMgb3ZlciB0aGUg ZnJvemVuIHNldCBvZiByZW5kZXJlcnMsIGNhbGxpbmcgZXhlY3V0ZVByZUxheW91dFRyZWVNdXRh dGluZ1Rhc2sKKyAgICAgICAgb24gdGhlbS4gTm90ZSB0aGF0IGJlY2F1c2UgdGhlIHRyZWUgaXMg bXV0YXRlZCwgdGhpcyBpdGVyYXRpb24gaGFzIHRvIGJlIGRlbGV0aW9uIGF3YXJlLgorCisgICAg ICAgICogcmVuZGVyaW5nL1JlbmRlclZpZXcuaDoKKyAgICAgICAgQWRkZWQgdGhlIHByZXZpb3Vz IG5ldyBmdW5jdGlvbnMsIGFsb25nIHdpdGggYSBIYXNoU2V0IHRvIGhvbGQgdGhlIHJlbmRlcmVy cyBhcyB0aGUgZGlzcGF0Y2ggb3JkZXIKKyAgICAgICAgc2hvdWxkbid0IG1hdHRlci4KKwogMjAx My0wMS0xNCAgQW5kcmV5IEFkYWlraW4gIDxhYW5kcmV5QGNocm9taXVtLm9yZz4KIAogICAgICAg ICBXZWIgSW5zcGVjdG9yOiBbQ2FudmFzXSBVSTogYWRkIGNvbnRyb2wgYnV0dG9ucyBmb3IgZG9p bmcgdGhlIHJlcGxheSBzdGVwcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFt ZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IGRlNTM2 MTUzNjdhZTYxYTM4OWY2NWQwN2I3Y2U0YTAxODJkOTZmZmQuLjEwNTc1NDMxMWEwMTE2N2RlZTY5 NGQ0ODg3MGM5YjMwYmFmMmQyMGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJh bWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTEy MTAsNiArMTIxMCw3IEBAIHZvaWQgRnJhbWVWaWV3OjpsYXlvdXQoYm9vbCBhbGxvd1N1YnRyZWUp CiAgICAgICAgICAgICBtX2luTGF5b3V0ID0gdHJ1ZTsKICAgICAgICAgICAgIGJlZ2luRGVmZXJy ZWRSZXBhaW50cygpOwogICAgICAgICAgICAgZm9yY2VMYXlvdXRQYXJlbnRWaWV3SWZOZWVkZWQo KTsKKyAgICAgICAgICAgIHJvb3QtPnZpZXcoKS0+ZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGlu Z1Rhc2tzKCk7CiAgICAgICAgICAgICByb290LT5sYXlvdXQoKTsKICNpZiBFTkFCTEUoVEVYVF9B VVRPU0laSU5HKQogICAgICAgICAgICAgYm9vbCBhdXRvc2l6ZWQgPSBkb2N1bWVudC0+dGV4dEF1 dG9zaXplcigpLT5wcm9jZXNzU3VidHJlZShyb290KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJDb3VudGVyLmNwcAppbmRleCBlZWNmNWY2OTBiNGE2Yjg3ZTk5MTMyZGMzMDEwYmJm MTE0NWMwMmQwLi4xODRhNDU1MjdhODE2N2ZkNDgzY2U3Yjk5NGMxNDliNzhmYThjY2E2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCkBAIC00NTAsNiArNDUw LDcgQEAgUmVuZGVyQ291bnRlcjo6UmVuZGVyQ291bnRlcihEb2N1bWVudCogbm9kZSwgY29uc3Qg Q291bnRlckNvbnRlbnQmIGNvdW50ZXIpCiAgICAgLCBtX25leHRGb3JTYW1lQ291bnRlcigwKQog ewogICAgIHZpZXcoKS0+YWRkUmVuZGVyQ291bnRlcigpOworICAgIHZpZXcoKS0+cmVnaXN0ZXJQ cmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKHRoaXMpOwogfQogCiBSZW5kZXJDb3VudGVyOjp+UmVu ZGVyQ291bnRlcigpCkBAIC00NjIsOCArNDYzLDEwIEBAIFJlbmRlckNvdW50ZXI6On5SZW5kZXJD b3VudGVyKCkKIAogdm9pZCBSZW5kZXJDb3VudGVyOjp3aWxsQmVEZXN0cm95ZWQoKQogewotICAg IGlmICh2aWV3KCkpCisgICAgaWYgKHZpZXcoKSkgewogICAgICAgICB2aWV3KCktPnJlbW92ZVJl bmRlckNvdW50ZXIoKTsKKyAgICAgICAgdmlldygpLT51bnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11 dGF0aW5nVGFzayh0aGlzKTsKKyAgICB9CiAgICAgUmVuZGVyVGV4dDo6d2lsbEJlRGVzdHJveWVk KCk7CiB9CiAKQEAgLTUxNCwxMyArNTE3LDEzIEBAIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4gUmVu ZGVyQ291bnRlcjo6b3JpZ2luYWxUZXh0KCkgY29uc3QKIAogdm9pZCBSZW5kZXJDb3VudGVyOjp1 cGRhdGVUZXh0KCkKIHsKKyAgICBzZXRUZXh0SW50ZXJuYWwob3JpZ2luYWxUZXh0KCkpOwogICAg IGNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzKDApOwogfQogCi12b2lkIFJlbmRlckNvdW50 ZXI6OmNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzKGZsb2F0IGxlYWQpCit2b2lkIFJlbmRl ckNvdW50ZXI6OmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCkKIHsKLSAgICBzZXRU ZXh0SW50ZXJuYWwob3JpZ2luYWxUZXh0KCkpOwotICAgIFJlbmRlclRleHQ6OmNvbXB1dGVQcmVm ZXJyZWRMb2dpY2FsV2lkdGhzKGxlYWQpOworICAgIHVwZGF0ZVRleHRJZk5lZWRlZCgpOwogfQog CiB2b2lkIFJlbmRlckNvdW50ZXI6OmludmFsaWRhdGUoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJDb3VudGVyLmgKaW5kZXggNTQ4ODI4NjQ3OTI0ZWRhYTg1YTZkMzA5MjBmZDJmNGE1 ZTFhMDg5OC4uODNkZWRjZTg5NTZhZjRkZWRiYzY3YWUxNjdmNmFkYWVkODZhMmExYSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCkBAIC00Nyw5ICs0Nyw5IEBAIHBy aXZhdGU6CiAgICAgdmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3Q7CiAgICAg dmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0OwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxT dHJpbmdJbXBsPiBvcmlnaW5hbFRleHQoKSBjb25zdDsKLSAgICAKKwogICAgIHZpcnR1YWwgdm9p ZCB1cGRhdGVUZXh0KCkgT1ZFUlJJREU7Ci0gICAgdmlydHVhbCB2b2lkIGNvbXB1dGVQcmVmZXJy ZWRMb2dpY2FsV2lkdGhzKGZsb2F0IGxlYWRXaWR0aCk7CisgICAgdmlydHVhbCB2b2lkIGV4ZWN1 dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCkgT1ZFUlJJREU7CiAKICAgICAvLyBSZW1vdmVz IHRoZSByZWZlcmVuY2UgdG8gdGhlIENvdW50ZXJOb2RlIGFzc29jaWF0ZWQgd2l0aCB0aGlzIHJl bmRlcmVyLgogICAgIC8vIFRoaXMgaXMgdXNlZCB0byBjYXVzZSBhIGNvdW50ZXIgZGlzcGxheSB1 cGRhdGUgd2hlbiB0aGUgQ291bnRlck5vZGUgdHJlZSBjaGFuZ2VzLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAppbmRleCA4MDAxNzk4ZmFmM2Y1YTI1MTAwOGFhNzk4 YzdlNTVmZWE1NGJmNjY0Li5lNWJiOWNhZGJmNzkyYmNhYTEyZjY2YTJlOWY0ODVhMmRmZmZiNmY4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtMjM1Niw2 ICsyMzU2LDggQEAgaW5saW5lIHZvaWQgUmVuZGVyT2JqZWN0OjpjbGVhckxheW91dFJvb3RJZk5l ZWRlZCgpIGNvbnN0CiAKIHZvaWQgUmVuZGVyT2JqZWN0Ojp3aWxsQmVEZXN0cm95ZWQoKQogewor ICAgIEFTU0VSVCghdmlldygpIHx8ICF2aWV3KCktPmlzUmVnaXN0ZXJlZEZvclByZUxheW91dFRh c2sodGhpcykpOworCiAgICAgLy8gRGVzdHJveSBhbnkgbGVmdG92ZXIgYW5vbnltb3VzIGNoaWxk cmVuLgogICAgIFJlbmRlck9iamVjdENoaWxkTGlzdCogY2hpbGRyZW4gPSB2aXJ0dWFsQ2hpbGRy ZW4oKTsKICAgICBpZiAoY2hpbGRyZW4pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmgKaW5kZXggOGVlNjFmMGM4MTMxN2Q1MDY4ZmQxZjJmODEzMzM5M2ExNzhiOTA1YS4uOGNl ZTRhMTJiYTdiNTUzYzQ0ZjdhOTQ3NzgwOGZlOGZiOGFiOGM1YSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJPYmplY3QuaApAQCAtMjYyLDYgKzI2Miw4IEBAIHB1YmxpYzoKIAogICAg IHZpcnR1YWwgdm9pZCByZXBvcnRNZW1vcnlVc2FnZShNZW1vcnlPYmplY3RJbmZvKikgY29uc3Q7 CiAKKyAgICB2aXJ0dWFsIHZvaWQgZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2soKSB7 IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CisKIHByb3RlY3RlZDoKICAgICAvLy8vLy8vLy8vLy8v Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KICAgICAvLyBIZWxwZXIgZnVuY3Rpb25zLiBE YW5nZXJvdXMgdG8gdXNlIQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlclZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcuY3BwCmlu ZGV4IDE4ZmUyY2IzZDEyMTBmMmU5NWI0M2QxOTlmOWQ1NWYyYjJiNzFlMGEuLjNmMDIxMWFhNjZm YTdjNGY2YmI0ZjkxYzBjYmI2OWFiMWMxMjNkMTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyVmlldy5jcHAKQEAgLTIxNCw2ICsyMTQsMzkgQEAgdm9pZCBSZW5kZXJWaWV3OjpsYXlv dXQoKQogICAgIHNldE5lZWRzTGF5b3V0KGZhbHNlKTsKIH0KIAorYm9vbCBSZW5kZXJWaWV3Ojpp c1JlZ2lzdGVyZWRGb3JQcmVMYXlvdXRUYXNrKFJlbmRlck9iamVjdCogb2JqZWN0KQoreworICAg IHJldHVybiBtX3ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzICYmIG1fcHJlTGF5b3V0VHJlZU11 dGF0aW5nVGFza3MtPmNvbnRhaW5zKG9iamVjdCk7Cit9CisKK3ZvaWQgUmVuZGVyVmlldzo6cmVn aXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKFJlbmRlck9iamVjdCogb2JqZWN0KQorewor ICAgIGlmICghbV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcykKKyAgICAgICAgbV9wcmVMYXlv dXRUcmVlTXV0YXRpbmdUYXNrcyA9IGFkb3B0UHRyKG5ldyBIYXNoU2V0PFJlbmRlck9iamVjdCo+ KCkpOworICAgIEhhc2hTZXQ8UmVuZGVyT2JqZWN0Kj46OkFkZFJlc3VsdCByZXN1bHQgPSBtX3By ZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzLT5hZGQob2JqZWN0KTsKKyAgICBBU1NFUlQocmVzdWx0 LmlzTmV3RW50cnkpOworfQorCit2b2lkIFJlbmRlclZpZXc6OnVucmVnaXN0ZXJQcmVMYXlvdXRU cmVlTXV0YXRpbmdUYXNrKFJlbmRlck9iamVjdCogb2JqZWN0KQoreworICAgIEFTU0VSVChpc1Jl Z2lzdGVyZWRGb3JQcmVMYXlvdXRUYXNrKG9iamVjdCkpOworICAgIG1fcHJlTGF5b3V0VHJlZU11 dGF0aW5nVGFza3MtPnJlbW92ZShvYmplY3QpOworfQorCit2b2lkIFJlbmRlclZpZXc6OmV4ZWN1 dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcygpCit7CisgICAgaWYgKCFtX3ByZUxheW91dFRy ZWVNdXRhdGluZ1Rhc2tzKQorICAgICAgICByZXR1cm47CisKKyAgICBWZWN0b3I8UmVuZGVyT2Jq ZWN0Kj4gcmVuZGVyZXJzOworICAgIGNvcHlUb1ZlY3RvcigqbV9wcmVMYXlvdXRUcmVlTXV0YXRp bmdUYXNrcywgcmVuZGVyZXJzKTsKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHJlbmRlcmVy cy5zaXplKCk7ICsraSkgeworICAgICAgICBSZW5kZXJPYmplY3QqIGN1cnJlbnRSZW5kZXJlciA9 IHJlbmRlcmVyc1tpXTsKKyAgICAgICAgaWYgKG1fcHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3Mt PmNvbnRhaW5zKGN1cnJlbnRSZW5kZXJlcikpCisgICAgICAgICAgICBjdXJyZW50UmVuZGVyZXIt PmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCk7CisgICAgfQorfQorCiB2b2lkIFJl bmRlclZpZXc6Om1hcExvY2FsVG9Db250YWluZXIoY29uc3QgUmVuZGVyTGF5ZXJNb2RlbE9iamVj dCogcmVwYWludENvbnRhaW5lciwgVHJhbnNmb3JtU3RhdGUmIHRyYW5zZm9ybVN0YXRlLCBNYXBD b29yZGluYXRlc0ZsYWdzIG1vZGUsIGJvb2wqIHdhc0ZpeGVkKSBjb25zdAogewogICAgIC8vIElm IGEgY29udGFpbmVyIHdhcyBzcGVjaWZpZWQsIGFuZCB3YXMgbm90IDAgb3IgdGhlIFJlbmRlclZp ZXcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5oIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcuaAppbmRleCBjYTc4ZDM1ZTE2NzQw MTAxNjNjNDQ1MjJhNzhjMDZkYTNmZTQwZWFkLi44NWFiNjk0MTI3MTM1MzE0YmQ4YWY0YzRlYzZi ZmRkY2IxZGVmY2QxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy Vmlldy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJWaWV3LmgKQEAgLTIy OSw2ICsyMjksMTEgQEAgcHVibGljOgogICAgIHZvaWQgcmVtb3ZlUmVuZGVyQ291bnRlcigpIHsg QVNTRVJUKG1fcmVuZGVyQ291bnRlckNvdW50ID4gMCk7IG1fcmVuZGVyQ291bnRlckNvdW50LS07 IH0KICAgICBib29sIGhhc1JlbmRlckNvdW50ZXJzKCkgeyByZXR1cm4gbV9yZW5kZXJDb3VudGVy Q291bnQ7IH0KIAorICAgIGJvb2wgaXNSZWdpc3RlcmVkRm9yUHJlTGF5b3V0VGFzayhSZW5kZXJP YmplY3QqKTsKKyAgICB2b2lkIHJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayhSZW5k ZXJPYmplY3QqKTsKKyAgICB2b2lkIHVucmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNr KFJlbmRlck9iamVjdCopOworICAgIHZvaWQgZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rh c2tzKCk7CisKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIHZvaWQgbWFwTG9jYWxUb0NvbnRhaW5l cihjb25zdCBSZW5kZXJMYXllck1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyLCBUcmFuc2Zv cm1TdGF0ZSYsIE1hcENvb3JkaW5hdGVzRmxhZ3MgPSBBcHBseUNvbnRhaW5lckZsaXAsIGJvb2wq IHdhc0ZpeGVkID0gMCkgY29uc3QgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBjb25zdCBSZW5kZXJP YmplY3QqIHB1c2hNYXBwaW5nVG9Db250YWluZXIoY29uc3QgUmVuZGVyTGF5ZXJNb2RlbE9iamVj dCogYW5jZXN0b3JUb1N0b3BBdCwgUmVuZGVyR2VvbWV0cnlNYXAmKSBjb25zdCBPVkVSUklERTsK QEAgLTMzNyw2ICszNDIsOCBAQCBwcml2YXRlOgogICAgIFJlbmRlclF1b3RlKiBtX3JlbmRlclF1 b3RlSGVhZDsKICAgICB1bnNpZ25lZCBtX3JlbmRlckNvdW50ZXJDb3VudDsKICAgICBSZW5kZXJW aWV3TGF5b3V0UGhhc2UgbV9sYXlvdXRQaGFzZTsKKworICAgIE93blB0cjxIYXNoU2V0PFJlbmRl ck9iamVjdCo+ID4gbV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrczsKIH07CiAKIGlubGluZSBS ZW5kZXJWaWV3KiB0b1JlbmRlclZpZXcoUmVuZGVyT2JqZWN0KiBvYmplY3QpCg== 182878 2013-01-15 17:10:40 -0800 2013-01-15 17:30:02 -0800 Patch v4: Fixed release build and integrated all the comments. bug-104829-20130115170742.patch text/plain 10288 jchaffraix U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5NzY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmNiNGMzMGQ3MzY0ZGQx OGEwZWM5YmNkODEwMTY2NWNlYzVhOTcyOC4uMjA1MGU5ZThhOTk5YTU0MmQwMzUwMmU3Y2RkMGE1 YmY4Y2IyZTZhMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYwIEBACisyMDEzLTAxLTE1ICBKdWxp ZW4gQ2hhZmZyYWl4ICA8amNoYWZmcmFpeEB3ZWJraXQub3JnPgorCisgICAgICAgIEludHJvZHVj ZSBhIG1lY2hhbmlzbSB0byBydW4gYSB0YXNrIGJlZm9yZSBsYXlvdXQgYW5kIG1pZ3JhdGUgUmVu ZGVyQ291bnRlciB0byB1c2luZyBpdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTA0ODI5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhlIHByZS1sYXlvdXQgdGFza3MgYXJlIHJlZ2lzdGVyZWQgYW5kIGtl cHQgYnkgdGhlIFJlbmRlclZpZXcuIFRoaXMgYXZvaWRzIGhhdmluZyB0byBtYWludGFpbiB0aGUK KyAgICAgICAgaW5mb3JtYXRpb24gaW4gdGhlIHJlbmRlcmVyIGFzIGl0IGlzIHN1cHBvc2VkIHRv IGJlIHJhcmUuIFRoZSBvcmRlciBpbiB3aGljaCB3ZSBkaXNwYXRjaCB0aGUgdGFza3MKKyAgICAg ICAgaXMgcmFuZG9tIGFzIHdlIGl0ZXJhdGUgb3ZlciBhbiBIYXNoU2V0IGJ1dCBpdCBzaG91bGQg YmUgZmluZSBhcyB3ZSBhcmUgY2FyZWZ1bCBpbgorICAgICAgICBleGVjdXRlUHJlTGF5b3V0VHJl ZU11dGF0aW5nVGFza3Mgbm90IHRvIHJlYWQgZnJlZSdkIG1lbW9yeS4KKworICAgICAgICBSZWZh Y3RvcmluZywgbm8gZXhwZWN0ZWQgY2hhbmdlIGluIGJlaGF2aW9yIChhcGFydCBmcm9tIGNvdW50 ZXIgbm90IG11dGF0aW5nIHRoZSB0cmVlIGR1cmluZyBsYXlvdXQpLgorCisgICAgICAgICogcGFn ZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpsYXlvdXQpOgor ICAgICAgICBDaGFuZ2VkIHRvIGNhbGwgUmVuZGVyVmlldzo6ZXhlY3V0ZVByZUxheW91dFRyZWVN dXRhdGluZ1Rhc2tzLgorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6UmVuZGVyQ291bnRlcik6CisgICAgICAg IChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjp3aWxsQmVEZXN0cm95ZWQpOgorICAgICAgICBVcGRh dGVkIHRvIHJlZ2lzdGVyIC8gdW5yZWdpc3RlciB0aGlzIHJlbmRlcmVyIGFzIG5lZWRpbmcgYSBw cmUtbGF5b3V0IHRhc2suCisKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50ZXI6OnVwZGF0 ZVRleHQpOgorICAgICAgICBNZXJnZSBjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocyBjb2Rl IGhlcmUgc28gdGhhdCBjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocworICAgICAgICBub3cg ZG9lc24ndCBtdXRhdGUgdGhlIHRyZWUuCisKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50 ZXI6OmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKToKKyAgICAgICAgQWRkZWQgYSBj YWxsIHRvIHVwZGF0ZVRleHRJZk5lZWRlZCBzbyB0aGF0IHRoZSB0ZXh0IGlzIHVwLXRvLWRhdGUg Zm9yIGxheW91dC4KKworICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmg6CisgICAg ICAgIFJlbW92ZWQgY29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0aHMsIGFkZGVkIGV4ZWN1dGVQ cmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrLgorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9i amVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OndpbGxCZURlc3Ryb3ll ZCk6CisgICAgICAgIEFkZGVkIGFuIEFTU0VSVCB0byBjYXRjaCBhbnkgcmVuZGVyZXIgdGhhdCB3 b3VsZCBmb3JnZXQgdG8gdW5yZWdpc3RlciBpdHNlbGYgZHVyaW5nIGRlc3RydWN0aW9uLgorCisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6UmVu ZGVyT2JqZWN0OjpleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayk6CisgICAgICAgIE5v LW9wIGJhc2UgaW1wbGVtZW50YXRpb24gKEFTU0VSVCdpbmcgZm9yIHBlcmZvcm1hbmNlIHJlYXNv bikuCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVmlldy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSZW5kZXJWaWV3Ojppc1JlZ2lzdGVyZWRGb3JQcmVMYXlvdXRUYXNrKToKKyAgICAgICAg SGVscGVyIGZ1bmN0aW9uIGZvciBBU1NFUlRzLgorCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJW aWV3OjpyZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2spOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyVmlldzo6dW5yZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2spOgorICAg ICAgICBSZWdpc3RlciAvIHVucmVnaXN0ZXIgbWV0aG9kcy4KKworICAgICAgICAoV2ViQ29yZTo6 UmVuZGVyVmlldzo6ZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzKToKKyAgICAgICAg VGhpcyBmdW5jdGlvbiBpdGVyYXRlcyBvdmVyIHRoZSBmcm96ZW4gc2V0IG9mIHJlbmRlcmVycywg Y2FsbGluZyBleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaworICAgICAgICBvbiB0aGVt LiBOb3RlIHRoYXQgYmVjYXVzZSB0aGUgdHJlZSBpcyBtdXRhdGVkLCB0aGlzIGl0ZXJhdGlvbiBo YXMgdG8gYmUgZGVsZXRpb24gYXdhcmUuCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVmll dy5oOgorICAgICAgICBBZGRlZCB0aGUgcHJldmlvdXMgbmV3IGZ1bmN0aW9ucywgYWxvbmcgd2l0 aCBhIEhhc2hTZXQgdG8gaG9sZCB0aGUgcmVuZGVyZXJzIGFzIHRoZSBkaXNwYXRjaCBvcmRlcgor ICAgICAgICBzaG91bGRuJ3QgbWF0dGVyLgorCiAyMDEzLTAxLTE1ICBaYW4gRG9iZXJzZWsgIDx6 YW5kb2JlcnNla0BnbWFpbC5jb20+CiAKICAgICAgICAgW0dUS10gRW5hYmxlIFBlcmZvcm1hbmNl IFRpbWVsaW5lLCBSZXNvdXJjZSBUaW1pbmcsIE5hdmlnYXRpb24gVGltaW5nIGZlYXR1cmVzCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKaW5kZXggYzIwYjAzODcwMzdmODM4NGQ3OGM2Y2MwNGJj ZjMyMzljY2MyYThlYy4uMmViZDg3MTYxYjcxNmUyZTU2MWE2OGM2MTJjMGEyMjgyNWUwNzA3OCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApAQCAtMTIxMCw2ICsxMjEwLDcgQEAgdm9pZCBG cmFtZVZpZXc6OmxheW91dChib29sIGFsbG93U3VidHJlZSkKICAgICAgICAgICAgIG1faW5MYXlv dXQgPSB0cnVlOwogICAgICAgICAgICAgYmVnaW5EZWZlcnJlZFJlcGFpbnRzKCk7CiAgICAgICAg ICAgICBmb3JjZUxheW91dFBhcmVudFZpZXdJZk5lZWRlZCgpOworICAgICAgICAgICAgcm9vdC0+ dmlldygpLT5leGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MoKTsKICAgICAgICAgICAg IHJvb3QtPmxheW91dCgpOwogI2lmIEVOQUJMRShURVhUX0FVVE9TSVpJTkcpCiAgICAgICAgICAg ICBib29sIGF1dG9zaXplZCA9IGRvY3VtZW50LT50ZXh0QXV0b3NpemVyKCktPnByb2Nlc3NTdWJ0 cmVlKHJvb3QpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCmlu ZGV4IGVlY2Y1ZjY5MGI0YTZiODdlOTkxMzJkYzMwMTBiYmYxMTQ1YzAyZDAuLjE4NGE0NTUyN2E4 MTY3ZmQ0ODNjZTdiOTk0YzE0OWI3OGZhOGNjYTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQ291bnRlci5jcHAKQEAgLTQ1MCw2ICs0NTAsNyBAQCBSZW5kZXJDb3VudGVyOjpS ZW5kZXJDb3VudGVyKERvY3VtZW50KiBub2RlLCBjb25zdCBDb3VudGVyQ29udGVudCYgY291bnRl cikKICAgICAsIG1fbmV4dEZvclNhbWVDb3VudGVyKDApCiB7CiAgICAgdmlldygpLT5hZGRSZW5k ZXJDb3VudGVyKCk7CisgICAgdmlldygpLT5yZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rh c2sodGhpcyk7CiB9CiAKIFJlbmRlckNvdW50ZXI6On5SZW5kZXJDb3VudGVyKCkKQEAgLTQ2Miw4 ICs0NjMsMTAgQEAgUmVuZGVyQ291bnRlcjo6flJlbmRlckNvdW50ZXIoKQogCiB2b2lkIFJlbmRl ckNvdW50ZXI6OndpbGxCZURlc3Ryb3llZCgpCiB7Ci0gICAgaWYgKHZpZXcoKSkKKyAgICBpZiAo dmlldygpKSB7CiAgICAgICAgIHZpZXcoKS0+cmVtb3ZlUmVuZGVyQ291bnRlcigpOworICAgICAg ICB2aWV3KCktPnVucmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKHRoaXMpOworICAg IH0KICAgICBSZW5kZXJUZXh0Ojp3aWxsQmVEZXN0cm95ZWQoKTsKIH0KIApAQCAtNTE0LDEzICs1 MTcsMTMgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBSZW5kZXJDb3VudGVyOjpvcmlnaW5hbFRl eHQoKSBjb25zdAogCiB2b2lkIFJlbmRlckNvdW50ZXI6OnVwZGF0ZVRleHQoKQogeworICAgIHNl dFRleHRJbnRlcm5hbChvcmlnaW5hbFRleHQoKSk7CiAgICAgY29tcHV0ZVByZWZlcnJlZExvZ2lj YWxXaWR0aHMoMCk7CiB9CiAKLXZvaWQgUmVuZGVyQ291bnRlcjo6Y29tcHV0ZVByZWZlcnJlZExv Z2ljYWxXaWR0aHMoZmxvYXQgbGVhZCkKK3ZvaWQgUmVuZGVyQ291bnRlcjo6ZXhlY3V0ZVByZUxh eW91dFRyZWVNdXRhdGluZ1Rhc2soKQogewotICAgIHNldFRleHRJbnRlcm5hbChvcmlnaW5hbFRl eHQoKSk7Ci0gICAgUmVuZGVyVGV4dDo6Y29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0aHMobGVh ZCk7CisgICAgdXBkYXRlVGV4dElmTmVlZGVkKCk7CiB9CiAKIHZvaWQgUmVuZGVyQ291bnRlcjo6 aW52YWxpZGF0ZSgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy Q291bnRlci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAppbmRl eCA1NDg4Mjg2NDc5MjRlZGFhODVhNmQzMDkyMGZkMmY0YTVlMWEwODk4Li44M2RlZGNlODk1NmFm NGRlZGJjNjdhZTE2N2Y2YWRhZWQ4NmEyYTFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJDb3VudGVyLmgKQEAgLTQ3LDkgKzQ3LDkgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVy KCkgY29uc3Q7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IG9yaWdpbmFsVGV4 dCgpIGNvbnN0OwotICAgIAorCiAgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVRleHQoKSBPVkVSUklE RTsKLSAgICB2aXJ0dWFsIHZvaWQgY29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0aHMoZmxvYXQg bGVhZFdpZHRoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGlu Z1Rhc2soKSBPVkVSUklERTsKIAogICAgIC8vIFJlbW92ZXMgdGhlIHJlZmVyZW5jZSB0byB0aGUg Q291bnRlck5vZGUgYXNzb2NpYXRlZCB3aXRoIHRoaXMgcmVuZGVyZXIuCiAgICAgLy8gVGhpcyBp cyB1c2VkIHRvIGNhdXNlIGEgY291bnRlciBkaXNwbGF5IHVwZGF0ZSB3aGVuIHRoZSBDb3VudGVy Tm9kZSB0cmVlIGNoYW5nZXMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3Qu Y3BwCmluZGV4IDBhMmU2MDYzYTQ5MWQzYjU5OTZlNWE4ZTZiMDlkOTMzMmEyYjA5OTIuLmFmOWNm N2JlZTBlMjU3MWUzMTMyYjYwYjlkMjdjMDJkYWNlMTQxMjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCkBAIC0yMzU2LDYgKzIzNTYsOCBAQCBpbmxpbmUgdm9p ZCBSZW5kZXJPYmplY3Q6OmNsZWFyTGF5b3V0Um9vdElmTmVlZGVkKCkgY29uc3QKIAogdm9pZCBS ZW5kZXJPYmplY3Q6OndpbGxCZURlc3Ryb3llZCgpCiB7CisgICAgQVNTRVJUKCF2aWV3KCkgfHwg IXZpZXcoKS0+aXNSZWdpc3RlcmVkRm9yUHJlTGF5b3V0VGFzayh0aGlzKSk7CisKICAgICAvLyBE ZXN0cm95IGFueSBsZWZ0b3ZlciBhbm9ueW1vdXMgY2hpbGRyZW4uCiAgICAgUmVuZGVyT2JqZWN0 Q2hpbGRMaXN0KiBjaGlsZHJlbiA9IHZpcnR1YWxDaGlsZHJlbigpOwogICAgIGlmIChjaGlsZHJl bikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaCBi L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAppbmRleCBiODY0YzQ4MzIy NmMwZTgzNGQwYmNhNmYxODM1NjIwMzFmMGM2YjU2Li43NDk4ZDUxZDcyZGZmOTQyYjUyNzQzOGM0 MmVkZmJjNDc4MWRjYmUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5o CkBAIC0yNjIsNiArMjYyLDggQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHJlcG9ydE1l bW9yeVVzYWdlKE1lbW9yeU9iamVjdEluZm8qKSBjb25zdDsKIAorICAgIHZpcnR1YWwgdm9pZCBl eGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygpIHsgQVNTRVJUX05PVF9SRUFDSEVEKCk7 IH0KKwogcHJvdGVjdGVkOgogICAgIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8v Ly8vLy8vLwogICAgIC8vIEhlbHBlciBmdW5jdGlvbnMuIERhbmdlcm91cyB0byB1c2UhCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5jcHAKaW5kZXggYTE1MmE3YzJiZDQyMDJmZDBk OWZmOGYwMjczM2U3Y2EyZjg5YTUxNS4uOWI4YTM0NGMxODdhZjg1ODE1YWZmMWM4YWI1ZDFjZmJi MDhlMmUxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJWaWV3LmNwcApAQCAtMjA3 LDYgKzIwNyw0MSBAQCB2b2lkIFJlbmRlclZpZXc6OmxheW91dCgpCiAgICAgc2V0TmVlZHNMYXlv dXQoZmFsc2UpOwogfQogCitib29sIFJlbmRlclZpZXc6OmlzUmVnaXN0ZXJlZEZvclByZUxheW91 dFRhc2soUmVuZGVyT2JqZWN0KiBvYmplY3QpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHJlTGF5 b3V0VHJlZU11dGF0aW5nVGFza3MgJiYgbV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy0+Y29u dGFpbnMob2JqZWN0KTsKK30KKwordm9pZCBSZW5kZXJWaWV3OjpyZWdpc3RlclByZUxheW91dFRy ZWVNdXRhdGluZ1Rhc2soUmVuZGVyT2JqZWN0KiBvYmplY3QpCit7CisgICAgaWYgKCFtX3ByZUxh eW91dFRyZWVNdXRhdGluZ1Rhc2tzKQorICAgICAgICBtX3ByZUxheW91dFRyZWVNdXRhdGluZ1Rh c2tzID0gYWRvcHRQdHIobmV3IEhhc2hTZXQ8UmVuZGVyT2JqZWN0Kj4oKSk7CisgICAgSGFzaFNl dDxSZW5kZXJPYmplY3QqPjo6QWRkUmVzdWx0IHJlc3VsdCA9IG1fcHJlTGF5b3V0VHJlZU11dGF0 aW5nVGFza3MtPmFkZChvYmplY3QpOworICAgIEFTU0VSVF9VTlVTRUQocmVzdWx0LCByZXN1bHQu aXNOZXdFbnRyeSk7Cit9CisKK3ZvaWQgUmVuZGVyVmlldzo6dW5yZWdpc3RlclByZUxheW91dFRy ZWVNdXRhdGluZ1Rhc2soUmVuZGVyT2JqZWN0KiBvYmplY3QpCit7CisgICAgQVNTRVJUKGlzUmVn aXN0ZXJlZEZvclByZUxheW91dFRhc2sob2JqZWN0KSk7CisgICAgbV9wcmVMYXlvdXRUcmVlTXV0 YXRpbmdUYXNrcy0+cmVtb3ZlKG9iamVjdCk7Cit9CisKK3ZvaWQgUmVuZGVyVmlldzo6ZXhlY3V0 ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzKCkgY29uc3QKK3sKKyAgICBpZiAoIW1fcHJlTGF5 b3V0VHJlZU11dGF0aW5nVGFza3MpCisgICAgICAgIHJldHVybjsKKworICAgIFZlY3RvcjxSZW5k ZXJPYmplY3QqPiByZW5kZXJlcnM7CisgICAgY29weVRvVmVjdG9yKCptX3ByZUxheW91dFRyZWVN dXRhdGluZ1Rhc2tzLCByZW5kZXJlcnMpOworICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgcmVu ZGVyZXJzLnNpemUoKTsgKytpKSB7CisgICAgICAgIFJlbmRlck9iamVjdCogY3VycmVudFJlbmRl cmVyID0gcmVuZGVyZXJzW2ldOworICAgICAgICAvLyB8Y3VycmVudFJlbmRlcmVyfCBjYW4gaGF2 ZSBiZWVuIGZyZWUnZCBieSBhIHByZXZpb3VzIHByZS1sYXlvdXQgdGFzaworICAgICAgICAvLyBz byB3ZSBuZWVkIHRvIGNoZWNrIHRoYXQgaXQncyBzdGlsbCBhbGl2ZS4KKyAgICAgICAgaWYgKG1f cHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MtPmNvbnRhaW5zKGN1cnJlbnRSZW5kZXJlcikpCisg ICAgICAgICAgICBjdXJyZW50UmVuZGVyZXItPmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdU YXNrKCk7CisgICAgfQorfQorCiB2b2lkIFJlbmRlclZpZXc6Om1hcExvY2FsVG9Db250YWluZXIo Y29uc3QgUmVuZGVyTGF5ZXJNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lciwgVHJhbnNmb3Jt U3RhdGUmIHRyYW5zZm9ybVN0YXRlLCBNYXBDb29yZGluYXRlc0ZsYWdzIG1vZGUsIGJvb2wqIHdh c0ZpeGVkKSBjb25zdAogewogICAgIC8vIElmIGEgY29udGFpbmVyIHdhcyBzcGVjaWZpZWQsIGFu ZCB3YXMgbm90IDAgb3IgdGhlIFJlbmRlclZpZXcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl clZpZXcuaAppbmRleCBjNjYyZWM5ZjM0ZTYxZTY0NDNiMDZlNWJmNTA1NzdmODE0NDQ3ZDI1Li4w NDQ2ZTM1NTVmNmIxN2E4MGM4NGVjMjIyMmY5NTE3MjJmNjc3ODUwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJWaWV3LmgKQEAgLTIyNiw2ICsyMjYsMTEgQEAgcHVibGljOgogICAgIHZv aWQgcmVtb3ZlUmVuZGVyQ291bnRlcigpIHsgQVNTRVJUKG1fcmVuZGVyQ291bnRlckNvdW50ID4g MCk7IG1fcmVuZGVyQ291bnRlckNvdW50LS07IH0KICAgICBib29sIGhhc1JlbmRlckNvdW50ZXJz KCkgeyByZXR1cm4gbV9yZW5kZXJDb3VudGVyQ291bnQ7IH0KIAorICAgIGJvb2wgaXNSZWdpc3Rl cmVkRm9yUHJlTGF5b3V0VGFzayhSZW5kZXJPYmplY3QqKSBjb25zdDsKKyAgICB2b2lkIHJlZ2lz dGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayhSZW5kZXJPYmplY3QqKTsKKyAgICB2b2lkIHVu cmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKFJlbmRlck9iamVjdCopOworICAgIHZv aWQgZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzKCkgY29uc3Q7CisKIHByb3RlY3Rl ZDoKICAgICB2aXJ0dWFsIHZvaWQgbWFwTG9jYWxUb0NvbnRhaW5lcihjb25zdCBSZW5kZXJMYXll ck1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyLCBUcmFuc2Zvcm1TdGF0ZSYsIE1hcENvb3Jk aW5hdGVzRmxhZ3MgPSBBcHBseUNvbnRhaW5lckZsaXAsIGJvb2wqIHdhc0ZpeGVkID0gMCkgY29u c3QgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBjb25zdCBSZW5kZXJPYmplY3QqIHB1c2hNYXBwaW5n VG9Db250YWluZXIoY29uc3QgUmVuZGVyTGF5ZXJNb2RlbE9iamVjdCogYW5jZXN0b3JUb1N0b3BB dCwgUmVuZGVyR2VvbWV0cnlNYXAmKSBjb25zdCBPVkVSUklERTsKQEAgLTMzNCw2ICszMzksOCBA QCBwcml2YXRlOgogICAgIFJlbmRlclF1b3RlKiBtX3JlbmRlclF1b3RlSGVhZDsKICAgICB1bnNp Z25lZCBtX3JlbmRlckNvdW50ZXJDb3VudDsKICAgICBSZW5kZXJWaWV3TGF5b3V0UGhhc2UgbV9s YXlvdXRQaGFzZTsKKworICAgIE93blB0cjxIYXNoU2V0PFJlbmRlck9iamVjdCo+ID4gbV9wcmVM YXlvdXRUcmVlTXV0YXRpbmdUYXNrczsKIH07CiAKIGlubGluZSBSZW5kZXJWaWV3KiB0b1JlbmRl clZpZXcoUmVuZGVyT2JqZWN0KiBvYmplY3QpCg== 182883 2013-01-15 17:30:06 -0800 2013-02-21 20:05:04 -0800 Patch v5: Rebaselined for the EWS. bug-104829-20130115172708.patch text/plain 10311 jchaffraix U3VidmVyc2lvbiBSZXZpc2lvbjogMTM5ODExCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjRjZDNhZGJjNGIyZTI1 ZWI4NzEwMWQ0NjQ4MGM2OGRlYjRkZGY2Ny4uMmM3MTY0ZDE1NWNhZTcxNTlkZjBjNzE1MTM2ZDYw ODI0YzBmNGVjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYwIEBACisyMDEzLTAxLTE1ICBKdWxp ZW4gQ2hhZmZyYWl4ICA8amNoYWZmcmFpeEB3ZWJraXQub3JnPgorCisgICAgICAgIEludHJvZHVj ZSBhIG1lY2hhbmlzbSB0byBydW4gYSB0YXNrIGJlZm9yZSBsYXlvdXQgYW5kIG1pZ3JhdGUgUmVu ZGVyQ291bnRlciB0byB1c2luZyBpdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTA0ODI5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGhlIHByZS1sYXlvdXQgdGFza3MgYXJlIHJlZ2lzdGVyZWQgYW5kIGtl cHQgYnkgdGhlIFJlbmRlclZpZXcuIFRoaXMgYXZvaWRzIGhhdmluZyB0byBtYWludGFpbiB0aGUK KyAgICAgICAgaW5mb3JtYXRpb24gaW4gdGhlIHJlbmRlcmVyIGFzIGl0IGlzIHN1cHBvc2VkIHRv IGJlIHJhcmUuIFRoZSBvcmRlciBpbiB3aGljaCB3ZSBkaXNwYXRjaCB0aGUgdGFza3MKKyAgICAg ICAgaXMgcmFuZG9tIGFzIHdlIGl0ZXJhdGUgb3ZlciBhbiBIYXNoU2V0IGJ1dCBpdCBzaG91bGQg YmUgZmluZSBhcyB3ZSBhcmUgY2FyZWZ1bCBpbgorICAgICAgICBleGVjdXRlUHJlTGF5b3V0VHJl ZU11dGF0aW5nVGFza3Mgbm90IHRvIHJlYWQgZnJlZSdkIG1lbW9yeS4KKworICAgICAgICBSZWZh Y3RvcmluZywgbm8gZXhwZWN0ZWQgY2hhbmdlIGluIGJlaGF2aW9yIChhcGFydCBmcm9tIGNvdW50 ZXIgbm90IG11dGF0aW5nIHRoZSB0cmVlIGR1cmluZyBsYXlvdXQpLgorCisgICAgICAgICogcGFn ZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpsYXlvdXQpOgor ICAgICAgICBDaGFuZ2VkIHRvIGNhbGwgUmVuZGVyVmlldzo6ZXhlY3V0ZVByZUxheW91dFRyZWVN dXRhdGluZ1Rhc2tzLgorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6UmVuZGVyQ291bnRlcik6CisgICAgICAg IChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjp3aWxsQmVEZXN0cm95ZWQpOgorICAgICAgICBVcGRh dGVkIHRvIHJlZ2lzdGVyIC8gdW5yZWdpc3RlciB0aGlzIHJlbmRlcmVyIGFzIG5lZWRpbmcgYSBw cmUtbGF5b3V0IHRhc2suCisKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50ZXI6OnVwZGF0 ZVRleHQpOgorICAgICAgICBNZXJnZSBjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocyBjb2Rl IGhlcmUgc28gdGhhdCBjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocworICAgICAgICBub3cg ZG9lc24ndCBtdXRhdGUgdGhlIHRyZWUuCisKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50 ZXI6OmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKToKKyAgICAgICAgQWRkZWQgYSBj YWxsIHRvIHVwZGF0ZVRleHRJZk5lZWRlZCBzbyB0aGF0IHRoZSB0ZXh0IGlzIHVwLXRvLWRhdGUg Zm9yIGxheW91dC4KKworICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmg6CisgICAg ICAgIFJlbW92ZWQgY29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0aHMsIGFkZGVkIGV4ZWN1dGVQ cmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrLgorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9i amVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OndpbGxCZURlc3Ryb3ll ZCk6CisgICAgICAgIEFkZGVkIGFuIEFTU0VSVCB0byBjYXRjaCBhbnkgcmVuZGVyZXIgdGhhdCB3 b3VsZCBmb3JnZXQgdG8gdW5yZWdpc3RlciBpdHNlbGYgZHVyaW5nIGRlc3RydWN0aW9uLgorCisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6UmVu ZGVyT2JqZWN0OjpleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayk6CisgICAgICAgIE5v LW9wIGJhc2UgaW1wbGVtZW50YXRpb24gKEFTU0VSVCdpbmcgZm9yIHBlcmZvcm1hbmNlIHJlYXNv bikuCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVmlldy5jcHA6CisgICAgICAgIChXZWJD b3JlOjpSZW5kZXJWaWV3Ojppc1JlZ2lzdGVyZWRGb3JQcmVMYXlvdXRUYXNrKToKKyAgICAgICAg SGVscGVyIGZ1bmN0aW9uIGZvciBBU1NFUlRzLgorCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJW aWV3OjpyZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2spOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyVmlldzo6dW5yZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2spOgorICAg ICAgICBSZWdpc3RlciAvIHVucmVnaXN0ZXIgbWV0aG9kcy4KKworICAgICAgICAoV2ViQ29yZTo6 UmVuZGVyVmlldzo6ZXhlY3V0ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzKToKKyAgICAgICAg VGhpcyBmdW5jdGlvbiBpdGVyYXRlcyBvdmVyIHRoZSBmcm96ZW4gc2V0IG9mIHJlbmRlcmVycywg Y2FsbGluZyBleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaworICAgICAgICBvbiB0aGVt LiBOb3RlIHRoYXQgYmVjYXVzZSB0aGUgdHJlZSBpcyBtdXRhdGVkLCB0aGlzIGl0ZXJhdGlvbiBo YXMgdG8gYmUgZGVsZXRpb24gYXdhcmUuCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVmll dy5oOgorICAgICAgICBBZGRlZCB0aGUgcHJldmlvdXMgbmV3IGZ1bmN0aW9ucywgYWxvbmcgd2l0 aCBhIEhhc2hTZXQgdG8gaG9sZCB0aGUgcmVuZGVyZXJzIGFzIHRoZSBkaXNwYXRjaCBvcmRlcgor ICAgICAgICBzaG91bGRuJ3QgbWF0dGVyLgorCiAyMDEzLTAxLTE1ICBBbnR0aSBLb2l2aXN0byAg PGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBBU1NFUlQoIW1fcXVldWUua2lsbGVkKCkgJiYg bV90aHJlYWRJRCkgaGl0IGluIFN0b3JhZ2VUaHJlYWQ6OnNjaGVkdWxlVGFzayBvbiBsb3cgbWVt b3J5IHdhcm5pbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAppbmRleCBjMjBiMDM4NzAzN2Y4 Mzg0ZDc4YzZjYzA0YmNmMzIzOWNjYzJhOGVjLi4yZWJkODcxNjFiNzE2ZTJlNTYxYTY4YzYxMmMw YTIyODI1ZTA3MDc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC0xMjEwLDYgKzEy MTAsNyBAQCB2b2lkIEZyYW1lVmlldzo6bGF5b3V0KGJvb2wgYWxsb3dTdWJ0cmVlKQogICAgICAg ICAgICAgbV9pbkxheW91dCA9IHRydWU7CiAgICAgICAgICAgICBiZWdpbkRlZmVycmVkUmVwYWlu dHMoKTsKICAgICAgICAgICAgIGZvcmNlTGF5b3V0UGFyZW50Vmlld0lmTmVlZGVkKCk7CisgICAg ICAgICAgICByb290LT52aWV3KCktPmV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcygp OwogICAgICAgICAgICAgcm9vdC0+bGF5b3V0KCk7CiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJWklO RykKICAgICAgICAgICAgIGJvb2wgYXV0b3NpemVkID0gZG9jdW1lbnQtPnRleHRBdXRvc2l6ZXIo KS0+cHJvY2Vzc1N1YnRyZWUocm9vdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQ291bnRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy Q291bnRlci5jcHAKaW5kZXggZWVjZjVmNjkwYjRhNmI4N2U5OTEzMmRjMzAxMGJiZjExNDVjMDJk MC4uMTg0YTQ1NTI3YTgxNjdmZDQ4M2NlN2I5OTRjMTQ5Yjc4ZmE4Y2NhNiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcApAQCAtNDUwLDYgKzQ1MCw3IEBAIFJl bmRlckNvdW50ZXI6OlJlbmRlckNvdW50ZXIoRG9jdW1lbnQqIG5vZGUsIGNvbnN0IENvdW50ZXJD b250ZW50JiBjb3VudGVyKQogICAgICwgbV9uZXh0Rm9yU2FtZUNvdW50ZXIoMCkKIHsKICAgICB2 aWV3KCktPmFkZFJlbmRlckNvdW50ZXIoKTsKKyAgICB2aWV3KCktPnJlZ2lzdGVyUHJlTGF5b3V0 VHJlZU11dGF0aW5nVGFzayh0aGlzKTsKIH0KIAogUmVuZGVyQ291bnRlcjo6flJlbmRlckNvdW50 ZXIoKQpAQCAtNDYyLDggKzQ2MywxMCBAQCBSZW5kZXJDb3VudGVyOjp+UmVuZGVyQ291bnRlcigp CiAKIHZvaWQgUmVuZGVyQ291bnRlcjo6d2lsbEJlRGVzdHJveWVkKCkKIHsKLSAgICBpZiAodmll dygpKQorICAgIGlmICh2aWV3KCkpIHsKICAgICAgICAgdmlldygpLT5yZW1vdmVSZW5kZXJDb3Vu dGVyKCk7CisgICAgICAgIHZpZXcoKS0+dW5yZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rh c2sodGhpcyk7CisgICAgfQogICAgIFJlbmRlclRleHQ6OndpbGxCZURlc3Ryb3llZCgpOwogfQog CkBAIC01MTQsMTMgKzUxNywxMyBAQCBQYXNzUmVmUHRyPFN0cmluZ0ltcGw+IFJlbmRlckNvdW50 ZXI6Om9yaWdpbmFsVGV4dCgpIGNvbnN0CiAKIHZvaWQgUmVuZGVyQ291bnRlcjo6dXBkYXRlVGV4 dCgpCiB7CisgICAgc2V0VGV4dEludGVybmFsKG9yaWdpbmFsVGV4dCgpKTsKICAgICBjb21wdXRl UHJlZmVycmVkTG9naWNhbFdpZHRocygwKTsKIH0KIAotdm9pZCBSZW5kZXJDb3VudGVyOjpjb21w dXRlUHJlZmVycmVkTG9naWNhbFdpZHRocyhmbG9hdCBsZWFkKQordm9pZCBSZW5kZXJDb3VudGVy OjpleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygpCiB7Ci0gICAgc2V0VGV4dEludGVy bmFsKG9yaWdpbmFsVGV4dCgpKTsKLSAgICBSZW5kZXJUZXh0Ojpjb21wdXRlUHJlZmVycmVkTG9n aWNhbFdpZHRocyhsZWFkKTsKKyAgICB1cGRhdGVUZXh0SWZOZWVkZWQoKTsKIH0KIAogdm9pZCBS ZW5kZXJDb3VudGVyOjppbnZhbGlkYXRlKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJDb3VudGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy Q291bnRlci5oCmluZGV4IGIxZTJjZTQ2MDQzMDAwYTNjY2FiNzA1YzNkM2RiODNkMzA3ZGZhYmQu LjgzZGVkY2U4OTU2YWY0ZGVkYmM2N2FlMTY3ZjZhZGFlZDg2YTJhMWEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaApAQCAtNDcsOSArNDcsOSBAQCBwcml2YXRlOgog ICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVuZGVyTmFtZSgpIGNvbnN0OwogICAgIHZpcnR1YWwg Ym9vbCBpc0NvdW50ZXIoKSBjb25zdDsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8U3RyaW5nSW1w bD4gb3JpZ2luYWxUZXh0KCkgY29uc3Q7Ci0gICAgCisKICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRl VGV4dCgpIE9WRVJSSURFOwotICAgIHZpcnR1YWwgdm9pZCBjb21wdXRlUHJlZmVycmVkTG9naWNh bFdpZHRocyhmbG9hdCBsZWFkV2lkdGgpIE9WRVJSSURFOworICAgIHZpcnR1YWwgdm9pZCBleGVj dXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzaygpIE9WRVJSSURFOwogCiAgICAgLy8gUmVtb3Zl cyB0aGUgcmVmZXJlbmNlIHRvIHRoZSBDb3VudGVyTm9kZSBhc3NvY2lhdGVkIHdpdGggdGhpcyBy ZW5kZXJlci4KICAgICAvLyBUaGlzIGlzIHVzZWQgdG8gY2F1c2UgYSBjb3VudGVyIGRpc3BsYXkg dXBkYXRlIHdoZW4gdGhlIENvdW50ZXJOb2RlIHRyZWUgY2hhbmdlcy4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXggMGEyZTYwNjNhNDkxZDNiNTk5NmU1YThl NmIwOWQ5MzMyYTJiMDk5Mi4uYWY5Y2Y3YmVlMGUyNTcxZTMxMzJiNjBiOWQyN2MwMmRhY2UxNDEy MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKQEAgLTIzNTYs NiArMjM1Niw4IEBAIGlubGluZSB2b2lkIFJlbmRlck9iamVjdDo6Y2xlYXJMYXlvdXRSb290SWZO ZWVkZWQoKSBjb25zdAogCiB2b2lkIFJlbmRlck9iamVjdDo6d2lsbEJlRGVzdHJveWVkKCkKIHsK KyAgICBBU1NFUlQoIXZpZXcoKSB8fCAhdmlldygpLT5pc1JlZ2lzdGVyZWRGb3JQcmVMYXlvdXRU YXNrKHRoaXMpKTsKKwogICAgIC8vIERlc3Ryb3kgYW55IGxlZnRvdmVyIGFub255bW91cyBjaGls ZHJlbi4KICAgICBSZW5kZXJPYmplY3RDaGlsZExpc3QqIGNoaWxkcmVuID0gdmlydHVhbENoaWxk cmVuKCk7CiAgICAgaWYgKGNoaWxkcmVuKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9i amVjdC5oCmluZGV4IGI4NjRjNDgzMjI2YzBlODM0ZDBiY2E2ZjE4MzU2MjAzMWYwYzZiNTYuLjc0 OThkNTFkNzJkZmY5NDJiNTI3NDM4YzQyZWRmYmM0NzgxZGNiZTEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKQEAgLTI2Miw2ICsyNjIsOCBAQCBwdWJsaWM6CiAKICAg ICB2aXJ0dWFsIHZvaWQgcmVwb3J0TWVtb3J5VXNhZ2UoTWVtb3J5T2JqZWN0SW5mbyopIGNvbnN0 OwogCisgICAgdmlydHVhbCB2b2lkIGV4ZWN1dGVQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKCkg eyBBU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQorCiBwcm90ZWN0ZWQ6CiAgICAgLy8vLy8vLy8vLy8v Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vCiAgICAgLy8gSGVscGVyIGZ1bmN0aW9ucy4g RGFuZ2Vyb3VzIHRvIHVzZSEKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJWaWV3LmNwcApp bmRleCBhMTUyYTdjMmJkNDIwMmZkMGQ5ZmY4ZjAyNzMzZTdjYTJmODlhNTE1Li45YjhhMzQ0YzE4 N2FmODU4MTVhZmYxYzhhYjVkMWNmYmIwOGUyZTE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlclZpZXcuY3BwCkBAIC0yMDcsNiArMjA3LDQxIEBAIHZvaWQgUmVuZGVyVmlldzo6bGF5 b3V0KCkKICAgICBzZXROZWVkc0xheW91dChmYWxzZSk7CiB9CiAKK2Jvb2wgUmVuZGVyVmlldzo6 aXNSZWdpc3RlcmVkRm9yUHJlTGF5b3V0VGFzayhSZW5kZXJPYmplY3QqIG9iamVjdCkgY29uc3QK K3sKKyAgICByZXR1cm4gbV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcyAmJiBtX3ByZUxheW91 dFRyZWVNdXRhdGluZ1Rhc2tzLT5jb250YWlucyhvYmplY3QpOworfQorCit2b2lkIFJlbmRlclZp ZXc6OnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayhSZW5kZXJPYmplY3QqIG9iamVj dCkKK3sKKyAgICBpZiAoIW1fcHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MpCisgICAgICAgIG1f cHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MgPSBhZG9wdFB0cihuZXcgSGFzaFNldDxSZW5kZXJP YmplY3QqPigpKTsKKyAgICBIYXNoU2V0PFJlbmRlck9iamVjdCo+OjpBZGRSZXN1bHQgcmVzdWx0 ID0gbV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy0+YWRkKG9iamVjdCk7CisgICAgQVNTRVJU X1VOVVNFRChyZXN1bHQsIHJlc3VsdC5pc05ld0VudHJ5KTsKK30KKwordm9pZCBSZW5kZXJWaWV3 Ojp1bnJlZ2lzdGVyUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFzayhSZW5kZXJPYmplY3QqIG9iamVj dCkKK3sKKyAgICBBU1NFUlQoaXNSZWdpc3RlcmVkRm9yUHJlTGF5b3V0VGFzayhvYmplY3QpKTsK KyAgICBtX3ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzLT5yZW1vdmUob2JqZWN0KTsKK30KKwor dm9pZCBSZW5kZXJWaWV3OjpleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MoKSBjb25z dAoreworICAgIGlmICghbV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcykKKyAgICAgICAgcmV0 dXJuOworCisgICAgVmVjdG9yPFJlbmRlck9iamVjdCo+IHJlbmRlcmVyczsKKyAgICBjb3B5VG9W ZWN0b3IoKm1fcHJlTGF5b3V0VHJlZU11dGF0aW5nVGFza3MsIHJlbmRlcmVycyk7CisgICAgZm9y IChzaXplX3QgaSA9IDA7IGkgPCByZW5kZXJlcnMuc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgUmVu ZGVyT2JqZWN0KiBjdXJyZW50UmVuZGVyZXIgPSByZW5kZXJlcnNbaV07CisgICAgICAgIC8vIHxj dXJyZW50UmVuZGVyZXJ8IGNhbiBoYXZlIGJlZW4gZnJlZSdkIGJ5IGEgcHJldmlvdXMgcHJlLWxh eW91dCB0YXNrCisgICAgICAgIC8vIHNvIHdlIG5lZWQgdG8gY2hlY2sgdGhhdCBpdCdzIHN0aWxs IGFsaXZlLgorICAgICAgICBpZiAobV9wcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrcy0+Y29udGFp bnMoY3VycmVudFJlbmRlcmVyKSkKKyAgICAgICAgICAgIGN1cnJlbnRSZW5kZXJlci0+ZXhlY3V0 ZVByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2soKTsKKyAgICB9Cit9CisKIHZvaWQgUmVuZGVyVmll dzo6bWFwTG9jYWxUb0NvbnRhaW5lcihjb25zdCBSZW5kZXJMYXllck1vZGVsT2JqZWN0KiByZXBh aW50Q29udGFpbmVyLCBUcmFuc2Zvcm1TdGF0ZSYgdHJhbnNmb3JtU3RhdGUsIE1hcENvb3JkaW5h dGVzRmxhZ3MgbW9kZSwgYm9vbCogd2FzRml4ZWQpIGNvbnN0CiB7CiAgICAgLy8gSWYgYSBjb250 YWluZXIgd2FzIHNwZWNpZmllZCwgYW5kIHdhcyBub3QgMCBvciB0aGUgUmVuZGVyVmlldywKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJWaWV3LmggYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVmlldy5oCmluZGV4IGM2NjJlYzlmMzRlNjFlNjQ0M2Iw NmU1YmY1MDU3N2Y4MTQ0NDdkMjUuLjA0NDZlMzU1NWY2YjE3YTgwYzg0ZWMyMjIyZjk1MTcyMmY2 Nzc4NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJWaWV3LmgK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclZpZXcuaApAQCAtMjI2LDYgKzIy NiwxMSBAQCBwdWJsaWM6CiAgICAgdm9pZCByZW1vdmVSZW5kZXJDb3VudGVyKCkgeyBBU1NFUlQo bV9yZW5kZXJDb3VudGVyQ291bnQgPiAwKTsgbV9yZW5kZXJDb3VudGVyQ291bnQtLTsgfQogICAg IGJvb2wgaGFzUmVuZGVyQ291bnRlcnMoKSB7IHJldHVybiBtX3JlbmRlckNvdW50ZXJDb3VudDsg fQogCisgICAgYm9vbCBpc1JlZ2lzdGVyZWRGb3JQcmVMYXlvdXRUYXNrKFJlbmRlck9iamVjdCop IGNvbnN0OworICAgIHZvaWQgcmVnaXN0ZXJQcmVMYXlvdXRUcmVlTXV0YXRpbmdUYXNrKFJlbmRl ck9iamVjdCopOworICAgIHZvaWQgdW5yZWdpc3RlclByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2so UmVuZGVyT2JqZWN0Kik7CisgICAgdm9pZCBleGVjdXRlUHJlTGF5b3V0VHJlZU11dGF0aW5nVGFz a3MoKSBjb25zdDsKKwogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgdm9pZCBtYXBMb2NhbFRvQ29u dGFpbmVyKGNvbnN0IFJlbmRlckxheWVyTW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIsIFRy YW5zZm9ybVN0YXRlJiwgTWFwQ29vcmRpbmF0ZXNGbGFncyA9IEFwcGx5Q29udGFpbmVyRmxpcCwg Ym9vbCogd2FzRml4ZWQgPSAwKSBjb25zdCBPVkVSUklERTsKICAgICB2aXJ0dWFsIGNvbnN0IFJl bmRlck9iamVjdCogcHVzaE1hcHBpbmdUb0NvbnRhaW5lcihjb25zdCBSZW5kZXJMYXllck1vZGVs T2JqZWN0KiBhbmNlc3RvclRvU3RvcEF0LCBSZW5kZXJHZW9tZXRyeU1hcCYpIGNvbnN0IE9WRVJS SURFOwpAQCAtMzM0LDYgKzMzOSw4IEBAIHByaXZhdGU6CiAgICAgUmVuZGVyUXVvdGUqIG1fcmVu ZGVyUXVvdGVIZWFkOwogICAgIHVuc2lnbmVkIG1fcmVuZGVyQ291bnRlckNvdW50OwogICAgIFJl bmRlclZpZXdMYXlvdXRQaGFzZSBtX2xheW91dFBoYXNlOworCisgICAgT3duUHRyPEhhc2hTZXQ8 UmVuZGVyT2JqZWN0Kj4gPiBtX3ByZUxheW91dFRyZWVNdXRhdGluZ1Rhc2tzOwogfTsKIAogaW5s aW5lIFJlbmRlclZpZXcqIHRvUmVuZGVyVmlldyhSZW5kZXJPYmplY3QqIG9iamVjdCkK