46733 2010-09-28 10:02:27 -0700 REGRESSION (r67261): Middle-mouse-release opens links regardless of "press" location 2011-01-24 17:37:07 -0800 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) PC All RESOLVED FIXED InRadar, Regression P1 Normal --- 22382 1 pkasting pkasting abarth adele ap bksening commit-queue darin dglazkov gustavo mkterra webkit webkit-ews webkit.review.bot xan.lopez oldest_to_newest 286315 0 pkasting 2010-09-28 10:02:27 -0700 Click and hold the middle mouse button on a blank portion of a page. Move over a link. Release. The link opens, when it shouldn't. This is a regression from r67261, the patch to not fire onclick for middle-clicks. I could use help fixing this. 286320 1 darin 2010-09-28 10:05:29 -0700 (In reply to comment #0) > I could use help fixing this. What kind of help would you like? 286323 2 darin 2010-09-28 10:08:31 -0700 I think the first step is to make sure it’s correct to deliver a mouseup event to an element you just happen to be over when letting up on the mouse. I’d expect that event to instead be delivered to the element that got the mousedown event. If it is not correct to deliver these events, then the fix is probably in EventHandler and not specific to link clicks. If it is correct to deliver these events, then the fix is more likely in the isLinkClick function, which may need additional arguments. 286330 3 69064 pkasting 2010-09-28 10:14:35 -0700 Created attachment 69064 onmouseup target testcase I grabbed this testcase online. According to it, onmouseup fires on the element the mouse is over during release regardless of the mousedown element, in at least Fx and IE. 286337 4 darin 2010-09-28 10:22:06 -0700 It’s not clear exactly what to do. In theory, this should all work when the mousedown and mouseup events are created by script, and so it seems the elements themselves somehow need to keep track of whether the mousedown was on the same element. But a script can create a mousedown without ever sending a mouseup later, so there may be something fundamentally flawed in that thinking. It’s not clear what level of the software can answer the question: “Is this a mouseup that corresponds to a mousedown on the same element?” More experiments with other browsers and research might establish whether the abstract model is state in the element, state in the browser, or hidden state in the event itself. 286341 5 pkasting 2010-09-28 10:24:55 -0700 I'll speculate that if script fires mousedown, mouseup on a link, it's not going to open at all in other browsers, meaning that the link clicking and state tracking stuff is all tied to user input. Now to try and test that hypothesis... 286344 6 darin 2010-09-28 10:27:09 -0700 (In reply to comment #5) > I'll speculate that if script fires mousedown, mouseup on a link, it's not going to open at all in other browsers, meaning that the link clicking and state tracking stuff is all tied to user input. Probably obvious to you, but you’ll also want to see if preventDefault or the other ways of preventing event handling on the mousedown or mouseup have any effect and whether the link is followed before or after the mouseup event handler is run. 286346 7 darin 2010-09-28 10:27:40 -0700 It may turn out that the link following is driven by a completely internal process unrelated to DOM event handling. If so, we can add code to do that. 286348 8 pkasting 2010-09-28 10:30:01 -0700 (In reply to comment #6) > Probably obvious to you, but you’ll also want to see if preventDefault or the other ways of preventing event handling on the mousedown or mouseup have any effect and whether the link is followed before or after the mouseup event handler is run. Not obvious to me. I was never a web developer, so I haven't written HTML and JS in general. I do a lot of web searching and copy-and-pasting :) (In reply to comment #7) > It may turn out that the link following is driven by a completely internal process unrelated to DOM event handling. If so, we can add code to do that. If you think about other events, generally an event fired by some action won't in turn cause the action if you fake it up and fire it. For example, firing onfocus on an element doesn't actually cause the browser to give it focus. Or at least, that's what some reference on DOM events I'm reading is telling me... 286401 9 69077 pkasting 2010-09-28 11:34:08 -0700 Created attachment 69077 opening links on events testcase I wrote this testcase to see what would happen on artificially-created events. Unmodified testcase: * In WebKit trunk (tested in Chrome Dev channel), mousing over link 2 will open two background tabs displaying bing.com (link 3). * In Opera, mousing over link 2 will navigate the current tab to bing.com. * In Firefox, neither mousing over link 2, nor mousing over link 1 and link 2, will open anything. Changing the mouse button from "1" to "0": * In WebKit trunk and Opera, mousing over link 2 will navigate the current tab to bing.com. * In Firefox, neither mousing over link 2, nor mousing over link 1 and link 2, will open anything. Uncommenting the preventDefault() call in displayEventName(): * In WebKit trunk, neither left- nor middle-clicking link 3 will open anything. * In Firefox and Opera, left-clicking link 3 will not open anything, while middle-clicking will open one background tab displaying bing.com. Uncommenting the preventDefault() call in the link 3 click listener: * In all three browsers, left-clicking link 3 will not open anything, while middle-clicking will open one background tab displaying bing.com. Personally, I think Firefox' handling is the most sane. 286420 10 darin 2010-09-28 11:54:42 -0700 Thanks for doing the testing. I wasn’t able to understand the pattern given your list of test results. I can help you figure out how to implement a change once you describe the behavior you think we want. Generally speaking, if preventDefault needs to prevent something, but that something should not be done in response to that event if it is DOM-created, then we need to either: 1) Put some hidden state on the “real” event so that the defaultEventHandler function can tell what to do. 2) Put the code to implement the behavior at the call site that sends the event rather than in the defaultEventHandler function. But to prevent EventHandler from becoming a giant god class we still may want to involve some virtual functions on the element involved. There may possibly be a way to construct tests that could tell the difference between (1) and (2). 286431 11 pkasting 2010-09-28 12:07:59 -0700 (In reply to comment #9) > Personally, I think Firefox' handling is the most sane. I talked some to Erik Arvidsson (JS hacker extraordinaire) about this and after some reflection he agreed that Firefox' behavior is the best route to go. * For maximum web compat, we probably want to match Gecko. It's far more likely people rely on its behavior than on Opera's, and because IE has historically had such different event handling, authors are likely to have separate codepaths for IE and everyone else for cases where behaviors differ. * Gecko's behavior is the most consistent with other types of events. Textareas don't add text when given artificial keydown/keyup/keypress events; focus doesn't change by firing an artificial focus event. In general, as I noted in comment 8, having a behavior that causes an event doesn't mean you can create that event to cause that behavior. * Opera's behavior is buggy anyway. Even if we wanted to match them, they're not checking the button number on artificially-created click events. So we'd need to change our behavior as such: * Links are not opened in response to DOM click events. Instead, they're opened directly in response to UI actions such as clicks and keypresses. * For left-clicks, we need to process the DOM click event first, so that if it is default-prevented, we do not open the link. (In reply to comment #10) > Generally speaking, if preventDefault needs to prevent something, but that something should not be done in response to that event if it is DOM-created, then we need to either: > > 1) Put some hidden state on the “real” event so that the defaultEventHandler function can tell what to do. > > 2) Put the code to implement the behavior at the call site that sends the event rather than in the defaultEventHandler function. But to prevent EventHandler from becoming a giant god class we still may want to involve some virtual functions on the element involved. I initially thought of #2, but you're right, #1 would work too. We can't use the existing fromUserGesture() function because that just tells us whether we're in the chain of functionality triggered by a user event, meaning a click on one element could call a handler function that generates a click on a different element, and we'd go ahead and navigate. I tested Firefox to make sure that in this case it still doesn't navigate links. > There may possibly be a way to construct tests that could tell the difference between (1) and (2). If we do it right, I can't imagine any way. But as I said, JS is far from my strong suit. 287405 12 webkit 2010-09-30 00:18:59 -0700 This is a regression. Whatever you guys had before worked awesome (except, apparently, for the @onclick bug that r67261 resolved). Allowing DOM events to trigger native handlers would make the Web an even more powerful platform, as it would allow JavaScript authors to have finer control over the page. With both Chrome and Safari now supporting extensions, as well as the innovations going on in input devices, I'm sure there are use cases where someone could build something really cool by dispatching phantom MouseEvents. That said, I really don't see the point in contesting this. If you guys want to mimic Firefox's separation of DOM and native handling, I won't complain. I would, however, like middle-mouse events to have the same level of control as left-mouse events. Specifically, just as preventDefault() can interrupt the native handler for an onLeftClick, it should be able to block the native handling of an onMiddleClick. It's easier make accurate predictions and expectations of the browser when there are fewer special cases (for instance, when the middle-click API behaves just like the left-click API). Also, extension authors often provide custom functionality in response to middle-clicks, and mouseEvent.preventDefault() is an important tool to that end. If I misunderstood your remarks about preventDefault, I apologize. This sounds like it's more than just a quick fix. Any chance that the r67261 patch can be rolled-back and reapplied when it includes a fix for this issue? I use an extension that is bound to middle-click. The constant spawning of links I didn't click is getting annoying. Thanks as always for your constant work to improve the Web. 287666 13 pkasting 2010-09-30 11:03:19 -0700 (In reply to comment #12) > I would, however, like middle-mouse events to have the same level of control as left-mouse events. Specifically, just as preventDefault() can interrupt the native handler for an onLeftClick, it should be able to block the native handling of an onMiddleClick. There is no click event to preventDefault() on. Re-adding one breaks numerous sites across the web (as we know from years of having it). > It's easier make accurate predictions and expectations of the browser when there are fewer special cases (for instance, when the middle-click API behaves just like the left-click API). That ship has sailed (sadly). Regardless of what would logically make sense, "click" is a de facto euphemism for "left click". If we want more programmatic control of middle-clicks, we need to invent a new event for them. > Also, extension authors often provide custom functionality in response to middle-clicks, and mouseEvent.preventDefault() is an important tool to that end. I am much more concerned about compatibility across the web than convenience for extension authors when the two conflict with each other. But as I noted, it might be possible to invent a new, dedicated event for middle clicks, which would re-add this ability without the web compat headaches. Perhaps you would like to raise the issue with the DOM folks? > This sounds like it's more than just a quick fix. Any chance that the r67261 patch can be rolled-back and reapplied when it includes a fix for this issue? I have to find someone to fix this soon since it's a blocker for Chrome 7, which has passed feature freeze a while back. 287697 14 webkit 2010-09-30 11:34:08 -0700 So, you just recently pulled the click event with a button value of 1 after years of having it? I've never heard of middle click events causing an issue, but the Web is a big place. I've been using mousedown event.preventDefault() to block smooth-scrolling and contexual menus. Will I still be able to do that? Making changes to the way a browser behaves seems like a dangerous move. Any apps designed around the old behavior (which as you've said is also the logical one) will now be broken. I'm honestly considering switching away from Chrome as my main browser as it seems to be breaking things quite often. Perhaps I should move off the dev channel, but if I do that, it's even more likely that the broken bits will make it downstream. I don't have time to debug my projects against every single Chrome release, but it seems I need to start doing so or else broken functionality will creep into a major browser. Is there some sort of resource where you guys publish major changes? I'm afraid that you're going to change the way two major browsers behave in a given situation and nobody is going to know until they realize their apps are now misbehaving. In the last couple months, my extension has gone vacillated between working perfectly, partially working, and not working at all depending on the Chrome build installed. 287698 15 pkasting 2010-09-30 11:38:25 -0700 (In reply to comment #14) > So, you just recently pulled the click event with a button value of 1 after years of having it? I've never heard of middle click events causing an issue, but the Web is a big place. Politely: you're getting off-track for this bug. This is not a bug about whether middle clicks should send click events. > Making changes to the way a browser behaves seems like a dangerous move. Welcome to the web. > Is there some sort of resource where you guys publish major changes? This is not a bug (or even a bug tracker) about Chrome and its release policies. Please go look at the chromium.org website for information about Chrome. 287699 16 darin 2010-09-30 11:42:22 -0700 I think we should start here by adding tests to LayoutTests that cover everything we care about here. Next step would be to land the tests with the expected results showing the current problems and failures. Then we can consider implementation strategy without confusion about the desired behavior -- the test cases will make that clear. To test the difference between DOM-created events and user-created ones we will need to use eventSender. 287701 17 pkasting 2010-09-30 11:45:53 -0700 (In reply to comment #16) > Next step would be to land the tests with the expected results showing the current problems and failures. Do you mean, make the expected results be what we want to eventually happen, as opposed to what happens now? And then put the tests on the skipped lists? 287702 18 darin 2010-09-30 11:47:54 -0700 (In reply to comment #17) > (In reply to comment #16) > > Next step would be to land the tests with the expected results showing the current problems and failures. > > Do you mean, make the expected results be what we want to eventually happen, as opposed to what happens now? And then put the tests on the skipped lists? What I mean is that the test should be written so that “PASS” is what we want to eventually happen. Then we should land expected results that show the current failures. Then the patch to fix the bug starts with a patch to the expected results to show expected PASS, and we add all the code changes needed to make that happen. No use of skipped lists, except perhaps for platforms with insufficient eventSender support. A benefit of this approach is that the preparation stage does not require any expertise at making the code changes -- the early step is entirely about embodying our research results and plans in test form. 287705 19 webkit 2010-09-30 11:51:50 -0700 I didn't mean to deviate from the issue. I saw this regression was caused by a change in the way middle-mouse events are handled and, as a potentially-affected party, wanted to discuss that change. Also, I realize this is not the Chrome bug tracker, but Chrome releases the latest WebKit builds rapidly, and most of the compatibility issues Chrome releases introduce are sourced in WebKit changes. I don't know where to learn about WebKit changes that could potentially affect my existing apps, and I'm not sure that others do either. As you pointed out, that issue affects more than just this bug and there are probably better venues for it to be addressed. If you feel I've wasted your time, I apologize. 287712 20 pkasting 2010-09-30 11:58:24 -0700 (In reply to comment #19) > I saw this regression was caused by a change in the way middle-mouse events are handled and, as a potentially-affected party, wanted to discuss that change. A better context for that would probably be either a separate bug or a concrete proposal mailed to the webkit-dev mailing list. If you want a more informal discussion you might try the IRC #webkit channel. > Also, I realize this is not the Chrome bug tracker, but Chrome releases the latest WebKit builds rapidly, and most of the compatibility issues Chrome releases introduce are sourced in WebKit changes. I don't know where to learn about WebKit changes that could potentially affect my existing apps, and I'm not sure that others do either. trac.webkit.org shows all changes as they go in. Chrome has googlechromereleases.blogspot.com ; there is also a tool at http://omahaproxy.appspot.com/cl?os=win&channel=canary which will show you the changelist for the latest release (substitute your choice of OS and channel). 287766 21 pkasting 2010-09-30 13:19:55 -0700 Dimitri, do you know anyone who could help work on this? 287805 22 69381 pkasting 2010-09-30 14:07:01 -0700 Created attachment 69381 middle-mouse autoscroll testcase Here's another test. This one calls preventDefault() on mouse down/up/click events on the body. If you resize your window small enough to get scrollbars, then middle-click, in Firefox the autoscroll (or "pan scroll") cursor appears, but in WebKit, it doesn't. This is because, similarly to link-middle-clicks, we trigger autoscrolling off a default event handler: in this case, Node::defaultEventHandler(). I think middle-mouse autoscroll, even more than middle-click to open links, should be triggered in parallel to event handling (i.e. like Firefox) as opposed to because of it. 287810 23 webkit 2010-09-30 14:11:23 -0700 (In reply to comment #22) > Here's another test. This one calls preventDefault() on mouse down/up/click events on the body. If you resize your window small enough to get scrollbars, then middle-click, in Firefox the autoscroll (or "pan scroll") cursor appears, but in WebKit, it doesn't. This is because, similarly to link-middle-clicks, we trigger autoscrolling off a default event handler: in this case, Node::defaultEventHandler(). We explicitly fixed this (e.g. made autoScroll preventable) in December: https://bugs.webkit.org/show_bug.cgi?id=32303 287813 24 pkasting 2010-09-30 14:16:44 -0700 (In reply to comment #23) > We explicitly fixed this (e.g. made autoScroll preventable) in December: > > https://bugs.webkit.org/show_bug.cgi?id=32303 The primary problem there -- that middle-clicks weren't firing events when autoscroll triggered -- was clearly a bug that needed to be fixed. Making autoscroll preventable at the same time was a mistake. It doesn't match Firefox, it doesn't match our desired behavior here for middle-clicks, and it doesn't make a lot of sense in the abstract (we actively don't want web pages to be able to prevent autoscroll). 287826 25 webkit 2010-09-30 14:28:56 -0700 I disagree. Isn't the whole point of preventDefault to give authors the ability to provide custom handlers for events that would otherwise trigger native ones? Google and Apple both frequently grandstand about the web as a platform, where JavaScript apps can supplant desktop ones. HTML 5 is supposed to enable us to do so much that we'll stop using platforms like Flash or Cocoa and start targeting the browser. If you bind a native handler to the middle-mouse button that app creators cannot interrupt, that keeps them from using the middle-mouse button to trigger custom functionality. Worse yet, auto-scroll only happens occasionally - if you are not on Windows or if the page is shorter than the window height, auto-scroll will not spawn. If a creator is using another OS or a giant monitor, he can write an app that listens for middle-mouse events and not realize that Windows users are seeing auto-scroll. If your proposed changes are implemented, he won't be able to do anything about it other than scrapping middle-mouse handling and finding a different way to implement the feature. What you are proposing will break mouse gestures extensions. 287844 26 pkasting 2010-09-30 14:42:44 -0700 (In reply to comment #25) > Isn't the whole point of preventDefault to give authors the ability to provide custom handlers for events that would otherwise trigger native ones? Not all native events can be prevented this way. It's important for browsers to match each other's behavior so authors can write code that behaves the same on all browsers. And it's secondarily important for there to be at least some kind of consistency in how mouse events are handled on one platform. > If your proposed changes are implemented, he won't be able to do anything about it Not quite true. Autoscroll never triggers when nothing under the mouse is scrollable. Many apps do their scrolling internally or are not scrollable at all, and in these situations there's no conflict. I realize that's not all situations, but things are not as apocalyptic as you imply. > What you are proposing will break mouse gestures extensions. Other browsers (e.g. Firefox) implement this behavior and still have mouse gestures. Chrome had mouse gesture extensions in the gallery before the patch you linked was checked into WebKit. So I don't buy this argument. And again, making the web platform behave equivalently across browsers is more important than what extension authors can or cannot do with the current set of APIs. If we need to enable extension authors to do something, we'll find a way. 287860 27 webkit 2010-09-30 14:51:43 -0700 I agree with you in principle about web browsers behaving similarly to one another, but I'm not sure regressing WebKit's functionality to match Gecko's is the right way to go about it. (Honestly, it makes me wonder what the point of WebKit is if you are trying to mimic Gecko.) Firefox's extensions used their own custom platform (I believe XUL). Chrome started the trend of DOM-based extensions. The Dec 09 patch came about because Chrome mouse gestures extensions that were triggered with the middle-mouse button weren't behaving on Windows. The auto-scroll was getting in the way. 287941 28 pkasting 2010-09-30 17:02:07 -0700 (In reply to comment #26) > (In reply to comment #25) > > Isn't the whole point of preventDefault to give authors the ability to provide custom handlers for events that would otherwise trigger native ones? > > Not all native events can be prevented this way. It's important for browsers to match each other's behavior so authors can write code that behaves the same on all browsers. After consulting with a bunch of different web developers, I'm inclined to reverse course and say this is still true, but maybe Gecko should change instead of WebKit. There are other arguments for changing this I haven't mentioned but I'm not convinced they're strong enough. 287944 29 webkit 2010-09-30 17:08:48 -0700 (In reply to comment #28) > After consulting with a bunch of different web developers, I'm inclined to reverse course and say this is still true, but maybe Gecko should change instead of WebKit. There are other arguments for changing this I haven't mentioned but I'm not convinced they're strong enough. I appreciate that. I try not to be overly persistent about these things, but as a web developer, I have strong feelings about the way browsers handle my code. =) Where does that leave us regarding this bug and the way WebKit handles middle-mouse events? 287946 30 pkasting 2010-09-30 17:11:31 -0700 (In reply to comment #29) > Where does that leave us regarding this bug and the way WebKit handles middle-mouse events? As things stood before comment 22. 312201 31 pkasting 2010-11-21 19:19:09 -0800 I still have not had time to try and fix this. If anyone else has time to at least sketch out a fix by firing navigations after running middle click handlers, as opposed to during the default handler, that would be helpful. 312462 32 ap 2010-11-22 12:24:30 -0800 Why don't we just revert r67261 for now? The bug it fixed was minor compared to this regression. 337708 33 ap 2011-01-20 16:42:34 -0800 <rdar://problem/8895856> 338224 34 adele 2011-01-21 11:53:01 -0800 I agree with Alexey. I think we should roll out the original change for now. 338227 35 darin 2011-01-21 11:53:58 -0800 (In reply to comment #34) > I agree with Alexey. I think we should roll out the original change for now. I concur. 338228 36 pkasting 2011-01-21 11:55:11 -0800 Me too. 338257 37 79775 pkasting 2011-01-21 12:23:46 -0800 Created attachment 79775 Roll back r67261 (needs real review) Here's an attempted rollback. I'd like Darin or someone else who understands HTMLInputElement.cpp to review as that file has been significantly refactored in the meantime and I'm not sure whether my attempted change is right. 338266 38 webkit.review.bot 2011-01-21 12:32:05 -0800 Attachment 79775 did not build on gtk: Build output: http://queues.webkit.org/results/7627245 338274 39 webkit-ews 2011-01-21 12:37:40 -0800 Attachment 79775 did not build on qt: Build output: http://queues.webkit.org/results/7496269 338286 40 79778 pkasting 2011-01-21 13:20:45 -0800 Created attachment 79778 Roll back r67261 (needs real review), v2 Try to fix compile errors 338302 41 webkit.review.bot 2011-01-21 13:43:22 -0800 Attachment 79775 did not build on mac: Build output: http://queues.webkit.org/results/7634117 338706 42 79778 darin 2011-01-23 10:53:16 -0800 Comment on attachment 79778 Roll back r67261 (needs real review), v2 View in context: https://bugs.webkit.org/attachment.cgi?id=79778&action=review > Source/WebCore/html/HTMLInputElement.cpp:945 > - if (event->type() != eventNames().clickEvent) > + if (!event->isMouseEvent() || event->type() != eventNames().clickEvent || static_cast<MouseEvent*>(event)->button() != LeftButton) > return 0; We could put the re-added code in a separate return statement. That way it can more easily be removed when we redo this change later. I think it’s unnecessarily confusing to have the isMouseEvent check separated from the code that casts the event to a MouseEvent. Putting the new check into a separate if statement would fix that as well. If we thought the code was going to be like this longer term, we’d want to either pass the event in to the input type and let it judge if it wants to handle the click event or rename willDispatchClick to willDispatchLeftClick. But I supposed for now it’s OK to leave the button check here. > Source/WebCore/html/HTMLInputElement.cpp:954 > - if (event->type() != eventNames().clickEvent) > + if (!event->isMouseEvent() || event->type() != eventNames().clickEvent || static_cast<MouseEvent*>(event)->button() != LeftButton) > return; This change isn’t needed. In fact, the if statement that checks the event type is unnecessary as well. We’re guaranteed that state will be 0 unless the preDispatchEventHandler returned something, so we don’t need to redo the checks it did. > Source/WebCore/html/HTMLInputElement.cpp:963 > - if (evt->isMouseEvent() && evt->type() == eventNames().clickEvent) { > + if (evt->isMouseEvent() && evt->type() == eventNames().clickEvent && static_cast<MouseEvent*>(evt)->button() == LeftButton) { > m_inputType->handleClickEvent(static_cast<MouseEvent*>(evt)); If we thought the code was going to be like this longer term, we’d want to either let RadioButtonType::handleClickEvent do the checking for the left button or rename the InputType function to handleLeftClickEvent. But I suppose for now it’s OK to have this match HTMLInputElement::preDispatchEventHandler; both have the same issue. > Source/WebCore/page/EventHandler.cpp:1428 > - bool swallowClickEvent = mouseEvent.button() == LeftButton && mev.targetNode() == m_clickNode && dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true); > + bool swallowClickEvent = false; > + // Don't ever dispatch click events for right clicks > + if (mouseEvent.button() != RightButton && mev.targetNode() == m_clickNode) > + swallowClickEvent = dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true); I don’t think we should add back the comment. The code says != right button; a comment that says the same thing just creates confusion about what the rest of what the code does and why the rest of the code is there. I don’t think we need to roll back the coding style change we made in the original patch. We can just change the condition back from == LeftButton to != RightButton. That was the substantive change. The rest was coding style only and there is no good reason to keep changing it back and forth. > Source/WebCore/page/EventHandler.cpp:1435 > - > - bool swallowMouseReleaseEvent = !swallowMouseUpEvent && handleMouseReleaseEvent(mev); > + > + bool swallowMouseReleaseEvent = false; > + if (!swallowMouseUpEvent) > + swallowMouseReleaseEvent = handleMouseReleaseEvent(mev); There’s no need to roll this out. It was a coding style change that has no effect on behavior. > Source/WebCore/page/EventHandler.cpp:1624 > - bool swallowClickEvent = m_clickCount > 0 && mouseEvent.button() == LeftButton && mev.targetNode() == m_clickNode && dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true); > + // Don't ever dispatch click events for right clicks > + bool swallowClickEvent = false; > + if (m_clickCount > 0 && mouseEvent.button() != RightButton && mev.targetNode() == m_clickNode) > + swallowClickEvent = dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true); As above, I suggest rolling out the substantive change, and not the style change. And, as above, I suggest leaving the comment out. 339378 43 79778 pkasting 2011-01-24 16:56:47 -0800 Comment on attachment 79778 Roll back r67261 (needs real review), v2 Will upload new patch for commit momentarily. View in context: https://bugs.webkit.org/attachment.cgi?id=79778&action=review >> Source/WebCore/html/HTMLInputElement.cpp:945 > > We could put the re-added code in a separate return statement. That way it can more easily be removed when we redo this change later. > > I think it’s unnecessarily confusing to have the isMouseEvent check separated from the code that casts the event to a MouseEvent. Putting the new check into a separate if statement would fix that as well. Changed to place the new conditional in a separate statement. >> Source/WebCore/html/HTMLInputElement.cpp:954 >> return; > > This change isn’t needed. In fact, the if statement that checks the event type is unnecessary as well. We’re guaranteed that state will be 0 unless the preDispatchEventHandler returned something, so we don’t need to redo the checks it did. Removed the entire statement. >> Source/WebCore/page/EventHandler.cpp:1428 >> + swallowClickEvent = dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true); > > I don’t think we should add back the comment. The code says != right button; a comment that says the same thing just creates confusion about what the rest of what the code does and why the rest of the code is there. > > I don’t think we need to roll back the coding style change we made in the original patch. We can just change the condition back from == LeftButton to != RightButton. That was the substantive change. The rest was coding style only and there is no good reason to keep changing it back and forth. Changed this change to only convert "== LeftButton" to "!= RightButton". >> Source/WebCore/page/EventHandler.cpp:1435 >> + swallowMouseReleaseEvent = handleMouseReleaseEvent(mev); > > There’s no need to roll this out. It was a coding style change that has no effect on behavior. Removed. >> Source/WebCore/page/EventHandler.cpp:1624 >> + swallowClickEvent = dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true); > > As above, I suggest rolling out the substantive change, and not the style change. And, as above, I suggest leaving the comment out. Changed this change to only convert "== LeftButton" to "!= RightButton". 339380 44 79992 pkasting 2011-01-24 16:59:01 -0800 Created attachment 79992 Roll back r67261, for commit 339398 45 commit-queue 2011-01-24 17:36:17 -0800 The commit-queue encountered the following flaky tests while processing attachment 79992: http/tests/xmlhttprequest/cross-origin-no-authorization.html bug 33357 (author: ap@webkit.org) The commit-queue is continuing to process your patch. 339399 46 79992 commit-queue 2011-01-24 17:36:59 -0800 Comment on attachment 79992 Roll back r67261, for commit Clearing flags on attachment: 79992 Committed r76557: <http://trac.webkit.org/changeset/76557> 339400 47 commit-queue 2011-01-24 17:37:07 -0800 All reviewed patches have been landed. Closing bug. 69064 2010-09-28 10:14:35 -0700 2010-09-28 10:14:35 -0700 onmouseup target testcase foo.html text/html 534 pkasting PGh0bWw+DQo8aGVhZD4NCjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NCmZ1bmN0aW9u IHdoaWNoRWxlbWVudChlKQ0Kew0KdmFyIHRhcmc7DQppZiAoIWUpIHZhciBlID0gd2luZG93LmV2 ZW50Ow0KaWYgKGUudGFyZ2V0KSB0YXJnID0gZS50YXJnZXQ7DQplbHNlIGlmIChlLnNyY0VsZW1l bnQpIHRhcmcgPSBlLnNyY0VsZW1lbnQ7DQppZiAodGFyZy5ub2RlVHlwZSA9PSAzKSAvLyBkZWZl YXQgU2FmYXJpIGJ1Zw0KdGFyZyA9IHRhcmcucGFyZW50Tm9kZTsNCnZhciB0bmFtZTsNCnRuYW1l PXRhcmcudGFnTmFtZTsNCmFsZXJ0KCJZb3UgY2xpY2tlZCBvbiBhICIgKyB0bmFtZSArICIgZWxl bWVudC4iKTsNCn0NCjwvc2NyaXB0Pg0KPC9oZWFkPg0KDQo8Ym9keSBvbm1vdXNldXA9IndoaWNo RWxlbWVudChldmVudCkiPg0KPGgyPlRoaXMgaXMgYSBoZWFkZXI8L2gyPg0KPHA+VGhpcyBpcyBh IHBhcmFncmFwaDwvcD4NCjxpbWcgYm9yZGVyPSIwIiBzcmM9ImJhbGwxNi5naWYiIGFsdD0iQmFs bCI+DQo8L2JvZHk+DQo8L2h0bWw+ 69077 2010-09-28 11:34:08 -0700 2010-09-28 11:34:08 -0700 opening links on events testcase foo.html text/html 1658 pkasting PGh0bWw+DQo8aGVhZD4NCjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NCmZ1bmN0aW9u IGZpcmVNb3VzZUV2ZW50KG5hbWUpIHsNCiAgdmFyIG1vdXNlRXZlbnQgPSBkb2N1bWVudC5jcmVh dGVFdmVudCgnTW91c2VFdmVudHMnKTsNCiAgbW91c2VFdmVudC5pbml0TW91c2VFdmVudCggbmFt ZSwgdHJ1ZSwgdHJ1ZSwgd2luZG93LCAwLCAwLCAwLCAwLCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNl LCBmYWxzZSwgMSwgbnVsbCApOw0KICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGluazMnKS5k aXNwYXRjaEV2ZW50KG1vdXNlRXZlbnQpOw0KfQ0KZnVuY3Rpb24gZGlzcGxheUV2ZW50TmFtZShl dmVudCkgew0KICB2YXIgb3V0cHV0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ291dHB1dCcp Ow0KICBvdXRwdXQuaW5uZXJIVE1MICs9IGV2ZW50LnR5cGUgKyAnPGJyPic7DQogIC8vZXZlbnQu cHJldmVudERlZmF1bHQoKTsNCn0NCmZ1bmN0aW9uIGluaXQoKSB7DQogIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCdsaW5rMScpLmFkZEV2ZW50TGlzdGVuZXIoJ21vdXNlb3ZlcicsIGZ1bmN0aW9u KCkgeyBmaXJlTW91c2VFdmVudCgnbW91c2Vkb3duJyk7IH0sIGZhbHNlKTsNCiAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2xpbmsyJykuYWRkRXZlbnRMaXN0ZW5lcignbW91c2VvdmVyJywgZnVu Y3Rpb24oKSB7IGZpcmVNb3VzZUV2ZW50KCdtb3VzZXVwJyk7IGZpcmVNb3VzZUV2ZW50KCdjbGlj aycsIGZpcmVUYXJnZXQpOyB9LCBmYWxzZSk7DQogIHZhciBmaXJlVGFyZ2V0ID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2xpbmszJyk7DQogIGZpcmVUYXJnZXQuYWRkRXZlbnRMaXN0ZW5lcign bW91c2Vkb3duJywgZnVuY3Rpb24oZXZlbnQpIHsgZGlzcGxheUV2ZW50TmFtZShldmVudCk7IH0s IGZhbHNlKTsNCiAgZmlyZVRhcmdldC5hZGRFdmVudExpc3RlbmVyKCdtb3VzZXVwJywgZnVuY3Rp b24oZXZlbnQpIHsgZGlzcGxheUV2ZW50TmFtZShldmVudCk7IH0sIGZhbHNlKTsNCiAgZmlyZVRh cmdldC5hZGRFdmVudExpc3RlbmVyKCdjbGljaycsIGZ1bmN0aW9uKGV2ZW50KSB7IGRpc3BsYXlF dmVudE5hbWUoZXZlbnQpOyAvKmV2ZW50LnByZXZlbnREZWZhdWx0KCk7Ki8gfSwgZmFsc2UpOw0K fQ0Kd2luZG93Lm9ubG9hZCA9IGluaXQ7DQo8L3NjcmlwdD4NCjwvaGVhZD4NCg0KPGJvZHk+DQo8 cD5Nb3VzaW5nIG92ZXIgbGluayAxIHdpbGwgZmlyZSAibW91c2Vkb3duIiBhdCBsaW5rIDMuICBN b3VzaW5nIG92ZXIgbGluayAyIHdpbGwgZmlyZSAibW91c2V1cCIgYW5kICJjbGljayIgYXQgbGlu ayAzLiAgQWxsIGV2ZW50cyBhcmUgc2V0IHRvIGJ1dHRvbiAxIChtaWRkbGUgYnV0dG9uKS48L3A+ DQo8cD5IZXJlIGlzIGxpbmsgMTogPGEgaHJlZj0iaHR0cDovL3d3dy5nb29nbGUuY29tIiBpZD0i bGluazEiPkdvb2dsZTwvYT48YnI+DQpIZXJlIGlzIGxpbmsgMjogPGEgaHJlZj0iaHR0cDovL3d3 dy55YWhvby5jb20iIGlkPSJsaW5rMiI+WWFob288L2E+PGJyPg0KSGVyZSBpcyBsaW5rIDM6IDxh IGhyZWY9Imh0dHA6Ly93d3cuYmluZy5jb20iIGlkPSJsaW5rMyI+QmluZzwvYT48YnI+PC9wPg0K PGRpdiBpZD0ib3V0cHV0IiB3aWR0aD01MDAgaGVpZ2h0PTUwMD48L2Rpdj4NCjwvYm9keT4NCjwv aHRtbD4= 69381 2010-09-30 14:07:01 -0700 2010-09-30 14:07:01 -0700 middle-mouse autoscroll testcase foo.html text/html 486 pkasting PGh0bWw+DQo8aGVhZD4NCjxzY3JpcHQ+DQogICAgZnVuY3Rpb24gaW5pdCgpIHsNCiAgICAgICAg ZG9jdW1lbnQuYm9keS5hZGRFdmVudExpc3RlbmVyKCdtb3VzZWRvd24nLCBmdW5jdGlvbihlKSB7 IGUucHJldmVudERlZmF1bHQoKTsgfSwgZmFsc2UpOw0KICAgICAgICBkb2N1bWVudC5ib2R5LmFk ZEV2ZW50TGlzdGVuZXIoJ21vdXNldXAnLCBmdW5jdGlvbihlKSB7IGUucHJldmVudERlZmF1bHQo KTsgfSwgZmFsc2UpOw0KICAgICAgICBkb2N1bWVudC5ib2R5LmFkZEV2ZW50TGlzdGVuZXIoJ2Ns aWNrJywgZnVuY3Rpb24oZSkgeyBlLnByZXZlbnREZWZhdWx0KCk7IH0sIGZhbHNlKTsNCiAgICB9 DQogICAgd2luZG93Lm9ubG9hZCA9IGluaXQ7DQo8L3NjcmlwdD4NCjwvaGVhZD4NCjxib2R5IHN0 eWxlPSJvdmVyZmxvdzphdXRvIj4NCjxkaXYgc3R5bGU9ImhlaWdodDoxMDAwcHg7d2lkdGg6MTAw MHB4OyI+PC9kaXY+DQo8L2JvZHk+DQo8L2h0bWw+ 79775 2011-01-21 12:23:46 -0800 2011-01-21 13:20:45 -0800 Roll back r67261 (needs real review) patch text/plain 8253 pkasting SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2Mzc3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDEtMjEgIFBldGVyIEth c3RpbmcgIDxwa2FzdGluZ0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJvbGwgYmFjayByNjcyNjEgKCJEb24ndCBmaXJlIG9uY2xp Y2sgb24gbWlkZGxlIGNsaWNrcyIpIGR1ZSB0bworICAgICAgICByZWdyZXNzaW9ucy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ2NzMzCisKKyAgICAg ICAgKiBodG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzTGlu a0NsaWNrKToKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cHJlRGlzcGF0Y2hFdmVudEhhbmRsZXIpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVy KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRs ZXIpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VEb3VibGVDbGlja0V2ZW50KToKKyAgICAgICAgKFdl YkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VSZWxlYXNlRXZlbnQpOgorCiAyMDExLTAx LTIxICBEYXJpbiBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBGaXggTGVvcGFy ZCBidWlsZC4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3Bw CShyZXZpc2lvbiA3NjM3MSkKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1l bnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NDEsNyArNTQxLDcgQEAgYm9vbCBpc01pZGRsZU1v dXNlQnV0dG9uRXZlbnQoRXZlbnQqIGV2ZQogCiBib29sIGlzTGlua0NsaWNrKEV2ZW50KiBldmVu dCkKIHsKLSAgICByZXR1cm4gZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVu dCB8fCAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkubW91c2V1cEV2ZW50ICYmIGlzTWlk ZGxlTW91c2VCdXR0b25FdmVudChldmVudCkpOworICAgIHJldHVybiBldmVudC0+dHlwZSgpID09 IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50ICYmICghZXZlbnQtPmlzTW91c2VFdmVudCgpIHx8IHN0 YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uKTsK IH0KIAogdm9pZCBoYW5kbGVMaW5rQ2xpY2soRXZlbnQqIGV2ZW50LCBEb2N1bWVudCogZG9jdW1l bnQsIGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJpbmcmIHRhcmdldCwgYm9vbCBoaWRlUmVm ZXJyZXIpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAJKHJl dmlzaW9uIDc2MzcxKQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNw cAkod29ya2luZyBjb3B5KQpAQCAtOTQwLDcgKzk0MCw3IEBAIHZvaWQgSFRNTElucHV0RWxlbWVu dDo6c2V0RmlsZUxpc3RGcm9tUmUKIAogdm9pZCogSFRNTElucHV0RWxlbWVudDo6cHJlRGlzcGF0 Y2hFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAgIGlmIChldmVudC0+dHlwZSgpICE9 IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KQorICAgIGlmICghZXZ0LT5pc01vdXNlRXZlbnQoKSB8 fCBldmVudC0+dHlwZSgpICE9IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50IHx8IHN0YXRpY19jYXN0 PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24oKSAhPSBMZWZ0QnV0dG9uKQogICAgICAgICByZXR1 cm4gMDsKICAgICAvLyBGSVhNRTogQ2hlY2sgd2hldGhlciB0aGVyZSBhcmUgYW55IGNhc2VzIHdo ZXJlIHRoaXMgYWN0dWFsbHkgZW5kcyB1cCBsZWFraW5nLgogICAgIHJldHVybiBtX2lucHV0VHlw ZS0+d2lsbERpc3BhdGNoQ2xpY2soKS5sZWFrUHRyKCk7CkBAIC05NDksNyArOTQ5LDcgQEAgdm9p ZCogSFRNTElucHV0RWxlbWVudDo6cHJlRGlzcGF0Y2hFdmVudAogdm9pZCBIVE1MSW5wdXRFbGVt ZW50Ojpwb3N0RGlzcGF0Y2hFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50LCB2b2lkKiBkYXRhRnJv bVByZURpc3BhdGNoKQogewogICAgIE93blB0cjxDbGlja0hhbmRsaW5nU3RhdGU+IHN0YXRlID0g YWRvcHRQdHIoc3RhdGljX2Nhc3Q8Q2xpY2tIYW5kbGluZ1N0YXRlKj4oZGF0YUZyb21QcmVEaXNw YXRjaCkpOwotICAgIGlmIChldmVudC0+dHlwZSgpICE9IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50 KQorICAgIGlmICghZXZ0LT5pc01vdXNlRXZlbnQoKSB8fCBldmVudC0+dHlwZSgpICE9IGV2ZW50 TmFtZXMoKS5jbGlja0V2ZW50IHx8IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0 b24oKSAhPSBMZWZ0QnV0dG9uKQogICAgICAgICByZXR1cm47CiAgICAgaWYgKCFzdGF0ZSkKICAg ICAgICAgcmV0dXJuOwpAQCAtOTU4LDcgKzk1OCw3IEBAIHZvaWQgSFRNTElucHV0RWxlbWVudDo6 cG9zdERpc3BhdGNoRXZlbnQKIAogdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRI YW5kbGVyKEV2ZW50KiBldnQpCiB7Ci0gICAgaWYgKGV2dC0+aXNNb3VzZUV2ZW50KCkgJiYgZXZ0 LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQpIHsKKyAgICBpZiAoZXZ0LT5pc01v dXNlRXZlbnQoKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCAmJiBz dGF0aWNfY2FzdDxNb3VzZUV2ZW50Kj4oZXZ0KS0+YnV0dG9uKCkgPT0gTGVmdEJ1dHRvbikgewog ICAgICAgICBtX2lucHV0VHlwZS0+aGFuZGxlQ2xpY2tFdmVudChzdGF0aWNfY2FzdDxNb3VzZUV2 ZW50Kj4oZXZ0KSk7CiAgICAgICAgIGlmIChldnQtPmRlZmF1bHRIYW5kbGVkKCkpCiAgICAgICAg ICAgICByZXR1cm47CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCShyZXZp c2lvbiA3NjM3MSkKKysrIFNvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAkod29y a2luZyBjb3B5KQpAQCAtMTQyMiwxMiArMTQyMiwxNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6aGFu ZGxlTW91c2VEb3VibGVDbGljCiAgICAgbV9jbGlja0NvdW50ID0gbW91c2VFdmVudC5jbGlja0Nv dW50KCk7CiAgICAgYm9vbCBzd2FsbG93TW91c2VVcEV2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50 KGV2ZW50TmFtZXMoKS5tb3VzZXVwRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1fY2xp Y2tDb3VudCwgbW91c2VFdmVudCwgZmFsc2UpOwogCi0gICAgYm9vbCBzd2FsbG93Q2xpY2tFdmVu dCA9IG1vdXNlRXZlbnQuYnV0dG9uKCkgPT0gTGVmdEJ1dHRvbiAmJiBtZXYudGFyZ2V0Tm9kZSgp ID09IG1fY2xpY2tOb2RlICYmIGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkuY2xpY2tF dmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCB0 cnVlKTsKKyAgICBib29sIHN3YWxsb3dDbGlja0V2ZW50ID0gZmFsc2U7CisgICAgLy8gRG9uJ3Qg ZXZlciBkaXNwYXRjaCBjbGljayBldmVudHMgZm9yIHJpZ2h0IGNsaWNrcworICAgIGlmIChtb3Vz ZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9j bGlja05vZGUpCisgICAgICAgIHN3YWxsb3dDbGlja0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50 KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNr Q291bnQsIG1vdXNlRXZlbnQsIHRydWUpOwogCiAgICAgaWYgKG1fbGFzdFNjcm9sbGJhclVuZGVy TW91c2UpCiAgICAgICAgIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBtX2xhc3RTY3JvbGxiYXJVbmRl ck1vdXNlLT5tb3VzZVVwKCk7Ci0KLSAgICBib29sIHN3YWxsb3dNb3VzZVJlbGVhc2VFdmVudCA9 ICFzd2FsbG93TW91c2VVcEV2ZW50ICYmIGhhbmRsZU1vdXNlUmVsZWFzZUV2ZW50KG1ldik7Cisg ICAgICAgICAgICAKKyAgICBib29sIHN3YWxsb3dNb3VzZVJlbGVhc2VFdmVudCA9IGZhbHNlOwor ICAgIGlmICghc3dhbGxvd01vdXNlVXBFdmVudCkKKyAgICAgICAgc3dhbGxvd01vdXNlUmVsZWFz ZUV2ZW50ID0gaGFuZGxlTW91c2VSZWxlYXNlRXZlbnQobWV2KTsKIAogICAgIGludmFsaWRhdGVD bGljaygpOwogCkBAIC0xNjEzLDcgKzE2MTgsMTAgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRs ZU1vdXNlUmVsZWFzZUV2ZQogCiAgICAgYm9vbCBzd2FsbG93TW91c2VVcEV2ZW50ID0gZGlzcGF0 Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5tb3VzZXVwRXZlbnQsIG1ldi50YXJnZXROb2RlKCks IHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgZmFsc2UpOwogCi0gICAgYm9vbCBzd2Fs bG93Q2xpY2tFdmVudCA9IG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVudC5idXR0b24oKSA9 PSBMZWZ0QnV0dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUgJiYgZGlzcGF0 Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0 cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOworICAgIC8vIERvbid0IGV2ZXIg ZGlzcGF0Y2ggY2xpY2sgZXZlbnRzIGZvciByaWdodCBjbGlja3MKKyAgICBib29sIHN3YWxsb3dD bGlja0V2ZW50ID0gZmFsc2U7CisgICAgaWYgKG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVu dC5idXR0b24oKSAhPSBSaWdodEJ1dHRvbiAmJiBtZXYudGFyZ2V0Tm9kZSgpID09IG1fY2xpY2tO b2RlKQorICAgICAgICBzd2FsbG93Q2xpY2tFdmVudCA9IGRpc3BhdGNoTW91c2VFdmVudChldmVu dE5hbWVzKCkuY2xpY2tFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50 LCBtb3VzZUV2ZW50LCB0cnVlKTsKIAogICAgIGlmIChtX3Jlc2l6ZUxheWVyKSB7CiAgICAgICAg IG1fcmVzaXplTGF5ZXItPnNldEluUmVzaXplTW9kZShmYWxzZSk7CkluZGV4OiBMYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lv biA3NjM3NykKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDE0IEBACisyMDExLTAxLTIxICBQZXRlciBLYXN0aW5nICA8cGthc3RpbmdAZ29vZ2xlLmNv bT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSb2xs IGJhY2sgcjY3MjYxICgiRG9uJ3QgZmlyZSBvbmNsaWNrIG9uIG1pZGRsZSBjbGlja3MiKSBkdWUg dG8KKyAgICAgICAgcmVncmVzc2lvbnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD00NjczMworCisgICAgICAgICogZmFzdC9ldmVudHMvbW91c2UtY2xp Y2stZXZlbnRzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JpcHQtdGVz dHMvbW91c2UtY2xpY2stZXZlbnRzLmpzOgorCiAyMDExLTAxLTIxICBBbnRvbiBNdWhpbiAgPGFu dG9ubUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTmF0ZSBDaGFwaW4uCklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQu dHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL21vdXNlLWNsaWNrLWV2 ZW50cy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDc2MzcxKQorKysgTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvbW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAt NiwxMSArNiwxMSBAQCBPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBCiBM ZWZ0IE1vdXNlIEJ1dHRvbgogUEFTUyBldmVudExvZyBpcyAibW91c2Vkb3duKDApIG1vdXNldXAo MCkgY2xpY2soMCkgbW91c2Vkb3duKDApIG1vdXNldXAoMCkgY2xpY2soMCkgZGJsY2xpY2soMCkg IgogTWlkZGxlIE1vdXNlIEJ1dHRvbgotUEFTUyBldmVudExvZyBpcyAibW91c2Vkb3duKDEpIG1v dXNldXAoMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgIgorUEFTUyBldmVudExvZyBpcyAibW91 c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xpY2soMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xp Y2soMSkgZGJsY2xpY2soMSkgIgogUmlnaHQgTW91c2UgQnV0dG9uCiBQQVNTIGV2ZW50TG9nIGlz ICJtb3VzZWRvd24oMikgbW91c2V1cCgyKSBtb3VzZWRvd24oMikgbW91c2V1cCgyKSAiCiA0dGgg TW91c2UgQnV0dG9uCi1QQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBt b3VzZWRvd24oMSkgbW91c2V1cCgxKSAiCitQQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMSkg bW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBkYmxj bGljaygxKSAiCiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCiAKIFRFU1QgQ09NUExF VEUKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1jbGlj ay1ldmVudHMuanMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0 LXRlc3RzL21vdXNlLWNsaWNrLWV2ZW50cy5qcwkocmV2aXNpb24gNzYzNzEpCisrKyBMYXlvdXRU ZXN0cy9mYXN0L2V2ZW50cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzCSh3b3Jr aW5nIGNvcHkpCkBAIC00OSw5ICs0OSw5IEBAIGZ1bmN0aW9uIHRlc3RFdmVudHMoZGVzY3JpcHRp b24sIGJ1dHRvbiwKIAogaWYgKHdpbmRvdy5ldmVudFNlbmRlcikgewogICAgIHRlc3RFdmVudHMo IkxlZnQgTW91c2UgQnV0dG9uIiwgMCwgIm1vdXNlZG93bigwKSBtb3VzZXVwKDApIGNsaWNrKDAp IG1vdXNlZG93bigwKSBtb3VzZXVwKDApIGNsaWNrKDApIGRibGNsaWNrKDApICIpOwotICAgIHRl c3RFdmVudHMoIk1pZGRsZSBNb3VzZSBCdXR0b24iLCAxLCAibW91c2Vkb3duKDEpIG1vdXNldXAo MSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgIik7CisgICAgdGVzdEV2ZW50cygiTWlkZGxlIE1v dXNlIEJ1dHRvbiIsIDEsICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRv d24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAiKTsKICAgICB0ZXN0RXZlbnRz KCJSaWdodCBNb3VzZSBCdXR0b24iLCAyLCAibW91c2Vkb3duKDIpIG1vdXNldXAoMikgbW91c2Vk b3duKDIpIG1vdXNldXAoMikgIik7Ci0gICAgdGVzdEV2ZW50cygiNHRoIE1vdXNlIEJ1dHRvbiIs IDMsICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiKTsK KyAgICB0ZXN0RXZlbnRzKCI0dGggTW91c2UgQnV0dG9uIiwgMywgIm1vdXNlZG93bigxKSBtb3Vz ZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNr KDEpICIpOwogfQogCiB2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsK 79778 2011-01-21 13:20:45 -0800 2011-01-24 16:59:01 -0800 Roll back r67261 (needs real review), v2 patch text/plain 8501 pkasting SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2Mzc3KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDEtMjEgIFBldGVyIEth c3RpbmcgIDxwa2FzdGluZ0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFJvbGwgYmFjayByNjcyNjEgKCJEb24ndCBmaXJlIG9uY2xp Y2sgb24gbWlkZGxlIGNsaWNrcyIpIGR1ZSB0bworICAgICAgICByZWdyZXNzaW9ucy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ2NzMzCisKKyAgICAg ICAgKiBodG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzTGlu a0NsaWNrKToKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cHJlRGlzcGF0Y2hFdmVudEhhbmRsZXIpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVy KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRs ZXIpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VEb3VibGVDbGlja0V2ZW50KToKKyAgICAgICAgKFdl YkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VSZWxlYXNlRXZlbnQpOgorCiAyMDExLTAx LTIxICBEYXJpbiBBZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBGaXggTGVvcGFy ZCBidWlsZC4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3Bw CShyZXZpc2lvbiA3NjM3MSkKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1l bnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NDEsNyArNTQxLDcgQEAgYm9vbCBpc01pZGRsZU1v dXNlQnV0dG9uRXZlbnQoRXZlbnQqIGV2ZQogCiBib29sIGlzTGlua0NsaWNrKEV2ZW50KiBldmVu dCkKIHsKLSAgICByZXR1cm4gZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVu dCB8fCAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkubW91c2V1cEV2ZW50ICYmIGlzTWlk ZGxlTW91c2VCdXR0b25FdmVudChldmVudCkpOworICAgIHJldHVybiBldmVudC0+dHlwZSgpID09 IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50ICYmICghZXZlbnQtPmlzTW91c2VFdmVudCgpIHx8IHN0 YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uKTsK IH0KIAogdm9pZCBoYW5kbGVMaW5rQ2xpY2soRXZlbnQqIGV2ZW50LCBEb2N1bWVudCogZG9jdW1l bnQsIGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJpbmcmIHRhcmdldCwgYm9vbCBoaWRlUmVm ZXJyZXIpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAJKHJl dmlzaW9uIDc2MzcxKQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNw cAkod29ya2luZyBjb3B5KQpAQCAtNDUsNiArNDUsNyBAQAogI2luY2x1ZGUgIktleWJvYXJkRXZl bnQuaCIKICNpbmNsdWRlICJMb2NhbGl6ZWRTdHJpbmdzLmgiCiAjaW5jbHVkZSAiTW91c2VFdmVu dC5oIgorI2luY2x1ZGUgIlBsYXRmb3JtTW91c2VFdmVudC5oIgogI2luY2x1ZGUgIlJlbmRlclRl eHRDb250cm9sU2luZ2xlTGluZS5oIgogI2luY2x1ZGUgIlJlbmRlclRoZW1lLmgiCiAjaW5jbHVk ZSAiUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIgpAQCAtOTQwLDcgKzk0MSw3IEBAIHZvaWQgSFRN TElucHV0RWxlbWVudDo6c2V0RmlsZUxpc3RGcm9tUmUKIAogdm9pZCogSFRNTElucHV0RWxlbWVu dDo6cHJlRGlzcGF0Y2hFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogewotICAgIGlmIChldmVu dC0+dHlwZSgpICE9IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KQorICAgIGlmICghZXZlbnQtPmlz TW91c2VFdmVudCgpIHx8IGV2ZW50LT50eXBlKCkgIT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQg fHwgc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2ZW50KS0+YnV0dG9uKCkgIT0gTGVmdEJ1dHRv bikKICAgICAgICAgcmV0dXJuIDA7CiAgICAgLy8gRklYTUU6IENoZWNrIHdoZXRoZXIgdGhlcmUg YXJlIGFueSBjYXNlcyB3aGVyZSB0aGlzIGFjdHVhbGx5IGVuZHMgdXAgbGVha2luZy4KICAgICBy ZXR1cm4gbV9pbnB1dFR5cGUtPndpbGxEaXNwYXRjaENsaWNrKCkubGVha1B0cigpOwpAQCAtOTQ5 LDcgKzk1MCw3IEBAIHZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3BhdGNoRXZlbnQKIHZv aWQgSFRNTElucHV0RWxlbWVudDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVyKEV2ZW50KiBldmVu dCwgdm9pZCogZGF0YUZyb21QcmVEaXNwYXRjaCkKIHsKICAgICBPd25QdHI8Q2xpY2tIYW5kbGlu Z1N0YXRlPiBzdGF0ZSA9IGFkb3B0UHRyKHN0YXRpY19jYXN0PENsaWNrSGFuZGxpbmdTdGF0ZSo+ KGRhdGFGcm9tUHJlRGlzcGF0Y2gpKTsKLSAgICBpZiAoZXZlbnQtPnR5cGUoKSAhPSBldmVudE5h bWVzKCkuY2xpY2tFdmVudCkKKyAgICBpZiAoIWV2ZW50LT5pc01vdXNlRXZlbnQoKSB8fCBldmVu dC0+dHlwZSgpICE9IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50IHx8IHN0YXRpY19jYXN0PE1vdXNl RXZlbnQqPihldmVudCktPmJ1dHRvbigpICE9IExlZnRCdXR0b24pCiAgICAgICAgIHJldHVybjsK ICAgICBpZiAoIXN0YXRlKQogICAgICAgICByZXR1cm47CkBAIC05NTgsNyArOTU5LDcgQEAgdm9p ZCBIVE1MSW5wdXRFbGVtZW50Ojpwb3N0RGlzcGF0Y2hFdmVudAogCiB2b2lkIEhUTUxJbnB1dEVs ZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2dCkKIHsKLSAgICBpZiAoZXZ0LT5p c01vdXNlRXZlbnQoKSAmJiBldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkg eworICAgIGlmIChldnQtPmlzTW91c2VFdmVudCgpICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFt ZXMoKS5jbGlja0V2ZW50ICYmIHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpLT5idXR0b24o KSA9PSBMZWZ0QnV0dG9uKSB7CiAgICAgICAgIG1faW5wdXRUeXBlLT5oYW5kbGVDbGlja0V2ZW50 KHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldnQpKTsKICAgICAgICAgaWYgKGV2dC0+ZGVmYXVs dEhhbmRsZWQoKSkKICAgICAgICAgICAgIHJldHVybjsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3Bh Z2UvRXZlbnRIYW5kbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wYWdlL0V2 ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDc2MzcxKQorKysgU291cmNlL1dlYkNvcmUvcGFnZS9F dmVudEhhbmRsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNDIyLDEyICsxNDIyLDE3IEBAIGJv b2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJsZUNsaWMKICAgICBtX2NsaWNrQ291bnQg PSBtb3VzZUV2ZW50LmNsaWNrQ291bnQoKTsKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQg PSBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdl dE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKLSAgICBi b29sIHN3YWxsb3dDbGlja0V2ZW50ID0gbW91c2VFdmVudC5idXR0b24oKSA9PSBMZWZ0QnV0dG9u ICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUgJiYgZGlzcGF0Y2hNb3VzZUV2ZW50 KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNr Q291bnQsIG1vdXNlRXZlbnQsIHRydWUpOworICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBm YWxzZTsKKyAgICAvLyBEb24ndCBldmVyIGRpc3BhdGNoIGNsaWNrIGV2ZW50cyBmb3IgcmlnaHQg Y2xpY2tzCisgICAgaWYgKG1vdXNlRXZlbnQuYnV0dG9uKCkgIT0gUmlnaHRCdXR0b24gJiYgbWV2 LnRhcmdldE5vZGUoKSA9PSBtX2NsaWNrTm9kZSkKKyAgICAgICAgc3dhbGxvd0NsaWNrRXZlbnQg PSBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXRO b2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CiAKICAgICBpZiAo bV9sYXN0U2Nyb2xsYmFyVW5kZXJNb3VzZSkKICAgICAgICAgc3dhbGxvd01vdXNlVXBFdmVudCA9 IG1fbGFzdFNjcm9sbGJhclVuZGVyTW91c2UtPm1vdXNlVXAoKTsKLQotICAgIGJvb2wgc3dhbGxv d01vdXNlUmVsZWFzZUV2ZW50ID0gIXN3YWxsb3dNb3VzZVVwRXZlbnQgJiYgaGFuZGxlTW91c2VS ZWxlYXNlRXZlbnQobWV2KTsKKyAgICAgICAgICAgIAorICAgIGJvb2wgc3dhbGxvd01vdXNlUmVs ZWFzZUV2ZW50ID0gZmFsc2U7CisgICAgaWYgKCFzd2FsbG93TW91c2VVcEV2ZW50KQorICAgICAg ICBzd2FsbG93TW91c2VSZWxlYXNlRXZlbnQgPSBoYW5kbGVNb3VzZVJlbGVhc2VFdmVudChtZXYp OwogCiAgICAgaW52YWxpZGF0ZUNsaWNrKCk7CiAKQEAgLTE2MTMsNyArMTYxOCwxMCBAQCBib29s IEV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VSZWxlYXNlRXZlCiAKICAgICBib29sIHN3YWxsb3dN b3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVu dCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxz ZSk7CiAKLSAgICBib29sIHN3YWxsb3dDbGlja0V2ZW50ID0gbV9jbGlja0NvdW50ID4gMCAmJiBt b3VzZUV2ZW50LmJ1dHRvbigpID09IExlZnRCdXR0b24gJiYgbWV2LnRhcmdldE5vZGUoKSA9PSBt X2NsaWNrTm9kZSAmJiBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQs IG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7 CisgICAgLy8gRG9uJ3QgZXZlciBkaXNwYXRjaCBjbGljayBldmVudHMgZm9yIHJpZ2h0IGNsaWNr cworICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBmYWxzZTsKKyAgICBpZiAobV9jbGlja0Nv dW50ID4gMCAmJiBtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJn ZXROb2RlKCkgPT0gbV9jbGlja05vZGUpCisgICAgICAgIHN3YWxsb3dDbGlja0V2ZW50ID0gZGlz cGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgp LCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOwogCiAgICAgaWYgKG1fcmVz aXplTGF5ZXIpIHsKICAgICAgICAgbV9yZXNpemVMYXllci0+c2V0SW5SZXNpemVNb2RlKGZhbHNl KTsKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2Mzc3KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3 b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDEtMjEgIFBldGVyIEthc3Rpbmcg IDxwa2FzdGluZ0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFJvbGwgYmFjayByNjcyNjEgKCJEb24ndCBmaXJlIG9uY2xpY2sgb24g bWlkZGxlIGNsaWNrcyIpIGR1ZSB0bworICAgICAgICByZWdyZXNzaW9ucy4KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ2NzMzCisKKyAgICAgICAgKiBm YXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0OgorICAgICAgICAqIGZh c3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1jbGljay1ldmVudHMuanM6CisKIDIwMTEtMDEt MjEgIEFudG9uIE11aGluICA8YW50b25tQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBOYXRlIENoYXBpbi4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL21vdXNlLWNs aWNrLWV2ZW50cy1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9l dmVudHMvbW91c2UtY2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gNzYzNzEpCisr KyBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0 CSh3b3JraW5nIGNvcHkpCkBAIC02LDExICs2LDExIEBAIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNl ZSBhIHNlcmllcyBvZiAiUEEKIExlZnQgTW91c2UgQnV0dG9uCiBQQVNTIGV2ZW50TG9nIGlzICJt b3VzZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBtb3VzZWRvd24oMCkgbW91c2V1cCgwKSBj bGljaygwKSBkYmxjbGljaygwKSAiCiBNaWRkbGUgTW91c2UgQnV0dG9uCi1QQVNTIGV2ZW50TG9n IGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiCitQ QVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRv d24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAiCiBSaWdodCBNb3VzZSBCdXR0 b24KIFBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigyKSBtb3VzZXVwKDIpIG1vdXNlZG93bigy KSBtb3VzZXVwKDIpICIKIDR0aCBNb3VzZSBCdXR0b24KLVBBU1MgZXZlbnRMb2cgaXMgIm1vdXNl ZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpICIKK1BBU1MgZXZlbnRM b2cgaXMgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3Vz ZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEpICIKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKIAogVEVTVCBDT01QTEVURQpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2Ny aXB0LXRlc3RzL21vdXNlLWNsaWNrLWV2ZW50cy5qcwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9mYXN0L2V2ZW50cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzCShyZXZpc2lv biA3NjM3MSkKKysrIExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1j bGljay1ldmVudHMuanMJKHdvcmtpbmcgY29weSkKQEAgLTQ5LDkgKzQ5LDkgQEAgZnVuY3Rpb24g dGVzdEV2ZW50cyhkZXNjcmlwdGlvbiwgYnV0dG9uLAogCiBpZiAod2luZG93LmV2ZW50U2VuZGVy KSB7CiAgICAgdGVzdEV2ZW50cygiTGVmdCBNb3VzZSBCdXR0b24iLCAwLCAibW91c2Vkb3duKDAp IG1vdXNldXAoMCkgY2xpY2soMCkgbW91c2Vkb3duKDApIG1vdXNldXAoMCkgY2xpY2soMCkgZGJs Y2xpY2soMCkgIik7Ci0gICAgdGVzdEV2ZW50cygiTWlkZGxlIE1vdXNlIEJ1dHRvbiIsIDEsICJt b3VzZWRvd24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiKTsKKyAgICB0 ZXN0RXZlbnRzKCJNaWRkbGUgTW91c2UgQnV0dG9uIiwgMSwgIm1vdXNlZG93bigxKSBtb3VzZXVw KDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEp ICIpOwogICAgIHRlc3RFdmVudHMoIlJpZ2h0IE1vdXNlIEJ1dHRvbiIsIDIsICJtb3VzZWRvd24o MikgbW91c2V1cCgyKSBtb3VzZWRvd24oMikgbW91c2V1cCgyKSAiKTsKLSAgICB0ZXN0RXZlbnRz KCI0dGggTW91c2UgQnV0dG9uIiwgMywgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93 bigxKSBtb3VzZXVwKDEpICIpOworICAgIHRlc3RFdmVudHMoIjR0aCBNb3VzZSBCdXR0b24iLCAz LCAibW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xpY2soMSkgbW91c2Vkb3duKDEpIG1vdXNldXAo MSkgY2xpY2soMSkgZGJsY2xpY2soMSkgIik7CiB9CiAKIHZhciBzdWNjZXNzZnVsbHlQYXJzZWQg PSB0cnVlOwo= 79992 2011-01-24 16:59:01 -0800 2011-01-24 17:36:59 -0800 Roll back r67261, for commit patch text/plain 7862 pkasting SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2NTU1KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDEtMjQgIFBldGVyIEth c3RpbmcgIDxwa2FzdGluZ0Bnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IERhcmlu IEFkbGVyLgorCisgICAgICAgIFJvbGwgYmFjayByNjcyNjEgKCJEb24ndCBmaXJlIG9uY2xpY2sg b24gbWlkZGxlIGNsaWNrcyIpIGR1ZSB0bworICAgICAgICByZWdyZXNzaW9ucy4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ2NzMzCisKKyAgICAgICAg KiBodG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzTGlua0Ns aWNrKToKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6SFRNTElucHV0RWxlbWVudDo6cHJlRGlzcGF0Y2hFdmVudEhhbmRsZXIpOgorICAgICAg ICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVyKToK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIp OgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2 ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VEb3VibGVDbGlja0V2ZW50KToKKyAgICAgICAgKFdlYkNv cmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VSZWxlYXNlRXZlbnQpOgorCiAyMDExLTAxLTI0 ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBFcmljIFNlaWRlbC4KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hv ckVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hv ckVsZW1lbnQuY3BwCShyZXZpc2lvbiA3NjU1MykKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TEFuY2hvckVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NDEsNyArNTQxLDcgQEAgYm9v bCBpc01pZGRsZU1vdXNlQnV0dG9uRXZlbnQoRXZlbnQqIGV2ZQogCiBib29sIGlzTGlua0NsaWNr KEV2ZW50KiBldmVudCkKIHsKLSAgICByZXR1cm4gZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVz KCkuY2xpY2tFdmVudCB8fCAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkubW91c2V1cEV2 ZW50ICYmIGlzTWlkZGxlTW91c2VCdXR0b25FdmVudChldmVudCkpOworICAgIHJldHVybiBldmVu dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50ICYmICghZXZlbnQtPmlzTW91c2VF dmVudCgpIHx8IHN0YXRpY19jYXN0PE1vdXNlRXZlbnQqPihldmVudCktPmJ1dHRvbigpICE9IFJp Z2h0QnV0dG9uKTsKIH0KIAogdm9pZCBoYW5kbGVMaW5rQ2xpY2soRXZlbnQqIGV2ZW50LCBEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJpbmcmIHRhcmdldCwg Ym9vbCBoaWRlUmVmZXJyZXIpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVs ZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxl bWVudC5jcHAJKHJldmlzaW9uIDc2NTUzKQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5w dXRFbGVtZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDUsNiArNDUsNyBAQAogI2luY2x1ZGUg IktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJMb2NhbGl6ZWRTdHJpbmdzLmgiCiAjaW5jbHVk ZSAiTW91c2VFdmVudC5oIgorI2luY2x1ZGUgIlBsYXRmb3JtTW91c2VFdmVudC5oIgogI2luY2x1 ZGUgIlJlbmRlclRleHRDb250cm9sU2luZ2xlTGluZS5oIgogI2luY2x1ZGUgIlJlbmRlclRoZW1l LmgiCiAjaW5jbHVkZSAiUnVudGltZUVuYWJsZWRGZWF0dXJlcy5oIgpAQCAtOTQyLDYgKzk0Myw4 IEBAIHZvaWQqIEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3BhdGNoRXZlbnQKIHsKICAgICBpZiAo ZXZlbnQtPnR5cGUoKSAhPSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkKICAgICAgICAgcmV0dXJu IDA7CisgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkgfHwgc3RhdGljX2Nhc3Q8TW91c2VF dmVudCo+KGV2ZW50KS0+YnV0dG9uKCkgIT0gTGVmdEJ1dHRvbikKKyAgICAgICAgcmV0dXJuIDA7 CiAgICAgLy8gRklYTUU6IENoZWNrIHdoZXRoZXIgdGhlcmUgYXJlIGFueSBjYXNlcyB3aGVyZSB0 aGlzIGFjdHVhbGx5IGVuZHMgdXAgbGVha2luZy4KICAgICByZXR1cm4gbV9pbnB1dFR5cGUtPndp bGxEaXNwYXRjaENsaWNrKCkubGVha1B0cigpOwogfQpAQCAtOTQ5LDggKzk1Miw2IEBAIHZvaWQq IEhUTUxJbnB1dEVsZW1lbnQ6OnByZURpc3BhdGNoRXZlbnQKIHZvaWQgSFRNTElucHV0RWxlbWVu dDo6cG9zdERpc3BhdGNoRXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCwgdm9pZCogZGF0YUZyb21Q cmVEaXNwYXRjaCkKIHsKICAgICBPd25QdHI8Q2xpY2tIYW5kbGluZ1N0YXRlPiBzdGF0ZSA9IGFk b3B0UHRyKHN0YXRpY19jYXN0PENsaWNrSGFuZGxpbmdTdGF0ZSo+KGRhdGFGcm9tUHJlRGlzcGF0 Y2gpKTsKLSAgICBpZiAoZXZlbnQtPnR5cGUoKSAhPSBldmVudE5hbWVzKCkuY2xpY2tFdmVudCkK LSAgICAgICAgcmV0dXJuOwogICAgIGlmICghc3RhdGUpCiAgICAgICAgIHJldHVybjsKICAgICBt X2lucHV0VHlwZS0+ZGlkRGlzcGF0Y2hDbGljayhldmVudCwgKnN0YXRlKTsKQEAgLTk1OCw3ICs5 NTksNyBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnBvc3REaXNwYXRjaEV2ZW50CiAKIHZvaWQg SFRNTElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZ0KQogewotICAg IGlmIChldnQtPmlzTW91c2VFdmVudCgpICYmIGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5j bGlja0V2ZW50KSB7CisgICAgaWYgKGV2dC0+aXNNb3VzZUV2ZW50KCkgJiYgZXZ0LT50eXBlKCkg PT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgJiYgc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2 dCktPmJ1dHRvbigpID09IExlZnRCdXR0b24pIHsKICAgICAgICAgbV9pbnB1dFR5cGUtPmhhbmRs ZUNsaWNrRXZlbnQoc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2dCkpOwogICAgICAgICBpZiAo ZXZ0LT5kZWZhdWx0SGFuZGxlZCgpKQogICAgICAgICAgICAgcmV0dXJuOwpJbmRleDogU291cmNl L1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJD b3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAkocmV2aXNpb24gNzY1NTMpCisrKyBTb3VyY2UvV2Vi Q29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE0MjIsNyArMTQy Miw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJsZUNsaWMKICAgICBtX2Ns aWNrQ291bnQgPSBtb3VzZUV2ZW50LmNsaWNrQ291bnQoKTsKICAgICBib29sIHN3YWxsb3dNb3Vz ZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwg bWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7 CiAKLSAgICBib29sIHN3YWxsb3dDbGlja0V2ZW50ID0gbW91c2VFdmVudC5idXR0b24oKSA9PSBM ZWZ0QnV0dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUgJiYgZGlzcGF0Y2hN b3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVl LCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOworICAgIGJvb2wgc3dhbGxvd0NsaWNr RXZlbnQgPSBtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJnZXRO b2RlKCkgPT0gbV9jbGlja05vZGUgJiYgZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5j bGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZl bnQsIHRydWUpOwogCiAgICAgaWYgKG1fbGFzdFNjcm9sbGJhclVuZGVyTW91c2UpCiAgICAgICAg IHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBtX2xhc3RTY3JvbGxiYXJVbmRlck1vdXNlLT5tb3VzZVVw KCk7CkBAIC0xNjEzLDcgKzE2MTMsNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VS ZWxlYXNlRXZlCiAKICAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNl RXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwg bV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKLSAgICBib29sIHN3YWxsb3dDbGlj a0V2ZW50ID0gbV9jbGlja0NvdW50ID4gMCAmJiBtb3VzZUV2ZW50LmJ1dHRvbigpID09IExlZnRC dXR0b24gJiYgbWV2LnRhcmdldE5vZGUoKSA9PSBtX2NsaWNrTm9kZSAmJiBkaXNwYXRjaE1vdXNl RXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXROb2RlKCksIHRydWUsIG1f Y2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CisgICAgYm9vbCBzd2FsbG93Q2xpY2tFdmVu dCA9IG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVudC5idXR0b24oKSAhPSBSaWdodEJ1dHRv biAmJiBtZXYudGFyZ2V0Tm9kZSgpID09IG1fY2xpY2tOb2RlICYmIGRpc3BhdGNoTW91c2VFdmVu dChldmVudE5hbWVzKCkuY2xpY2tFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlj a0NvdW50LCBtb3VzZUV2ZW50LCB0cnVlKTsKIAogICAgIGlmIChtX3Jlc2l6ZUxheWVyKSB7CiAg ICAgICAgIG1fcmVzaXplTGF5ZXItPnNldEluUmVzaXplTW9kZShmYWxzZSk7CkluZGV4OiBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShy ZXZpc2lvbiA3NjU1NSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpA QCAtMSwzICsxLDE0IEBACisyMDExLTAxLTI0ICBQZXRlciBLYXN0aW5nICA8cGthc3RpbmdAZ29v Z2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KKworICAgICAgICBS b2xsIGJhY2sgcjY3MjYxICgiRG9uJ3QgZmlyZSBvbmNsaWNrIG9uIG1pZGRsZSBjbGlja3MiKSBk dWUgdG8KKyAgICAgICAgcmVncmVzc2lvbnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD00NjczMworCisgICAgICAgICogZmFzdC9ldmVudHMvbW91c2Ut Y2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBmYXN0L2V2ZW50cy9zY3JpcHQt dGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzOgorCiAyMDExLTAxLTI0ICBNYXJ0aW4gUm9iaW5z b24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNl aWRlbC4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL21vdXNlLWNsaWNrLWV2ZW50cy1l eHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvbW91c2Ut Y2xpY2stZXZlbnRzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gNzY1NTMpCisrKyBMYXlvdXRUZXN0 cy9mYXN0L2V2ZW50cy9tb3VzZS1jbGljay1ldmVudHMtZXhwZWN0ZWQudHh0CSh3b3JraW5nIGNv cHkpCkBAIC02LDExICs2LDExIEBAIE9uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBv ZiAiUEEKIExlZnQgTW91c2UgQnV0dG9uCiBQQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRvd24oMCkg bW91c2V1cCgwKSBjbGljaygwKSBtb3VzZWRvd24oMCkgbW91c2V1cCgwKSBjbGljaygwKSBkYmxj bGljaygwKSAiCiBNaWRkbGUgTW91c2UgQnV0dG9uCi1QQVNTIGV2ZW50TG9nIGlzICJtb3VzZWRv d24oMSkgbW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiCitQQVNTIGV2ZW50TG9n IGlzICJtb3VzZWRvd24oMSkgbW91c2V1cCgxKSBjbGljaygxKSBtb3VzZWRvd24oMSkgbW91c2V1 cCgxKSBjbGljaygxKSBkYmxjbGljaygxKSAiCiBSaWdodCBNb3VzZSBCdXR0b24KIFBBU1MgZXZl bnRMb2cgaXMgIm1vdXNlZG93bigyKSBtb3VzZXVwKDIpIG1vdXNlZG93bigyKSBtb3VzZXVwKDIp ICIKIDR0aCBNb3VzZSBCdXR0b24KLVBBU1MgZXZlbnRMb2cgaXMgIm1vdXNlZG93bigxKSBtb3Vz ZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpICIKK1BBU1MgZXZlbnRMb2cgaXMgIm1vdXNl ZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNr KDEpIGRibGNsaWNrKDEpICIKIFBBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIAogVEVT VCBDT01QTEVURQpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvc2NyaXB0LXRlc3RzL21v dXNlLWNsaWNrLWV2ZW50cy5qcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2V2ZW50 cy9zY3JpcHQtdGVzdHMvbW91c2UtY2xpY2stZXZlbnRzLmpzCShyZXZpc2lvbiA3NjU1MykKKysr IExheW91dFRlc3RzL2Zhc3QvZXZlbnRzL3NjcmlwdC10ZXN0cy9tb3VzZS1jbGljay1ldmVudHMu anMJKHdvcmtpbmcgY29weSkKQEAgLTQ5LDkgKzQ5LDkgQEAgZnVuY3Rpb24gdGVzdEV2ZW50cyhk ZXNjcmlwdGlvbiwgYnV0dG9uLAogCiBpZiAod2luZG93LmV2ZW50U2VuZGVyKSB7CiAgICAgdGVz dEV2ZW50cygiTGVmdCBNb3VzZSBCdXR0b24iLCAwLCAibW91c2Vkb3duKDApIG1vdXNldXAoMCkg Y2xpY2soMCkgbW91c2Vkb3duKDApIG1vdXNldXAoMCkgY2xpY2soMCkgZGJsY2xpY2soMCkgIik7 Ci0gICAgdGVzdEV2ZW50cygiTWlkZGxlIE1vdXNlIEJ1dHRvbiIsIDEsICJtb3VzZWRvd24oMSkg bW91c2V1cCgxKSBtb3VzZWRvd24oMSkgbW91c2V1cCgxKSAiKTsKKyAgICB0ZXN0RXZlbnRzKCJN aWRkbGUgTW91c2UgQnV0dG9uIiwgMSwgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEp IG1vdXNlZG93bigxKSBtb3VzZXVwKDEpIGNsaWNrKDEpIGRibGNsaWNrKDEpICIpOwogICAgIHRl c3RFdmVudHMoIlJpZ2h0IE1vdXNlIEJ1dHRvbiIsIDIsICJtb3VzZWRvd24oMikgbW91c2V1cCgy KSBtb3VzZWRvd24oMikgbW91c2V1cCgyKSAiKTsKLSAgICB0ZXN0RXZlbnRzKCI0dGggTW91c2Ug QnV0dG9uIiwgMywgIm1vdXNlZG93bigxKSBtb3VzZXVwKDEpIG1vdXNlZG93bigxKSBtb3VzZXVw KDEpICIpOworICAgIHRlc3RFdmVudHMoIjR0aCBNb3VzZSBCdXR0b24iLCAzLCAibW91c2Vkb3du KDEpIG1vdXNldXAoMSkgY2xpY2soMSkgbW91c2Vkb3duKDEpIG1vdXNldXAoMSkgY2xpY2soMSkg ZGJsY2xpY2soMSkgIik7CiB9CiAKIHZhciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOwo=