17052 2008-01-28 17:18:38 -0800 Scrolling with arrow keys does not update cursor 2012-02-20 15:00:38 -0800 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) All All NEW http://googleblog.blogspot.com/ GoogleBug P2 Normal --- 1 anantha webkit-unassigned ap aroben darin ht990332 kevin.cs.oh mark mitz pkasting viettrungluu yuzo oldest_to_newest 68504 0 anantha 2008-01-28 17:18:38 -0800 Steps: Hover the mouse over an image and notice the cursor changes to hand with index finger pointing. Now hover just above the image and notice the cursor changes back to an 'I' Now (without moving the mouse) scroll down with the down arrow key until the picture is under the cursor. The cursor should change to a hand but it doesn't. It remains an 'I' Other Browsers: The cursor changes to handshape in all browsers except Safari. Webkit nightly tested: r29807 68513 1 eric 2008-01-28 17:48:48 -0800 IIRC this same issue affects scrolling with the space bar as well. 68559 2 ap 2008-01-29 01:00:34 -0800 In Mac Safari, the mouse cursor is hidden when scrolling - perhaps we should do the same on Windows? 74929 3 pkasting 2008-03-23 22:03:47 -0700 *** Bug 17959 has been marked as a duplicate of this bug. *** 74930 4 pkasting 2008-03-23 22:07:05 -0700 The cursor, the link target displayed in the status area, and the hover state of elements on the page are all affected (or should I say unaffected), and the problem also occurs with scrolling via the mousewheel. Hiding the cursor while scrolling would not be consistent with Windows platform conventions or other browsers on Windows. Instead we should probably just make sure the same sort of updates that happen after a mouse move event happen after a scroll event. (I suggest changing the bug summary to "Cursor/link target/hover state not updated during scroll", which I don't have the power to do.) 127619 5 yuzo 2009-06-23 04:16:29 -0700 Hi, I'm preparing a fix for this. Yuzo 127842 6 31772 yuzo 2009-06-24 00:33:50 -0700 Created attachment 31772 A proposed patch for this bug 127872 7 31772 oliver 2009-06-24 01:48:23 -0700 Comment on attachment 31772 A proposed patch for this bug Typo updateCurrentMousePoistions should be updateCurrentMousePositions I'm also really unhappy with the the addition of multiple #if PLATFORM(WIN) cases. There is no explanation of why these should be windows only. Sending a mouseMove event in response to a key board even t seems highly suspect and i'd want tests for that behaviour, and confirmation that other browsers do it I don't think we should be refreshing the cursor on every key event if we can avoid it -- in the general case we won't need to update, so updating every time seems incorrect. I would think a superior solution would be to update the mouse state if an element that is currently under the mouse scrolls, but i think hyatt would be the one to talk about that in general. 127888 8 31778 yuzo 2009-06-24 04:29:11 -0700 Created attachment 31778 A revised patch. Hi, Thank you for your review. I've addressed your comments. Can you take another look? Yuzo 127939 9 31778 eric 2009-06-24 10:39:59 -0700 Comment on attachment 31778 A revised patch. Conflict marker: +>>>>>>> .r45079 resolve-ChangeLogs script will fix ChangeLogs when you get conflicts updating. That way you wont have to do it manually (and thus worry about leaving conflict markers). Style: +void EventHandler::updateMousePositions(const PlatformMouseEvent& mouseEvent) { "view" is better than "v": + FrameView* v = m_frame->view(); Style: +void EventHandler::recordScrollPosition() { Style: (braces): +void EventHandler::simulateMouseMoveIfNecessary() { In general this looked fine, besides the nits. I'll need to look again for content. 128056 10 31822 yuzo 2009-06-24 18:28:45 -0700 Created attachment 31822 Addressed comments Hi, Thank you for the review. I've: - Removed the conflict mark - Renamed v view - Fixed braces starting functions Can you take another look? Yuzo 128775 11 yuzo 2009-06-28 21:18:38 -0700 (In reply to comment #10) > Created an attachment (id=31822) [review] > Addressed comments > > Hi, Thank you for the review. > > I've: > - Removed the conflict mark > - Renamed v view > - Fixed braces starting functions > > Can you take another look? > > Yuzo > Ping? 129569 12 eric 2009-07-02 14:23:08 -0700 Mac does not seem to have this bug. 129571 13 eric 2009-07-02 14:23:29 -0700 How does Mac avoid needing this code? 129572 14 31822 eric 2009-07-02 14:26:59 -0700 Comment on attachment 31822 Addressed comments Ok. What I need from you to r+ this patch, is I need explanation as to why this is the correct fix. The fix itself looks fine, but why is this the right way to fix this? Why does Mac not need this code for example? Try the example on a Mac with a scroll wheel mouse and you'll see cursor updates work as expected. 129574 15 eric 2009-07-02 14:27:41 -0700 Also, I will note that your current solution has observable side-effects. JavaScript could detect your simulated mouse move events using onmousemove handlers. 129644 16 yuzo 2009-07-02 18:12:32 -0700 Thank you for your review. onmousemove side effect is not good. I need to fix it. As to why Mac doesn't need this change: As far as I tested, Mac OS always sends a mouse move event after it sends a mouse wheel event. (So actually for Mac I should disable the simulated event that this patch will introduce.) As for scroll by key event, on Mac the mouse cursor is hidden when a key is pressed. Hence no need to update its shape. I'll - find a way to avoid onmousemove event - disable the simulated event for mac - add comments that explain why Mac works fine without this patch. and get back to you. Yuzo (In reply to comment #15) > Also, I will note that your current solution has observable side-effects. > JavaScript could detect your simulated mouse move events using onmousemove > handlers. > (In reply to comment #14) > (From update of attachment 31822 [review]) > Ok. What I need from you to r+ this patch, is I need explanation as to why > this is the correct fix. The fix itself looks fine, but why is this the right > way to fix this? Why does Mac not need this code for example? Try the example > on a Mac with a scroll wheel mouse and you'll see cursor updates work as > expected. > 129913 17 32291 yuzo 2009-07-06 02:49:00 -0700 Created attachment 32291 Added rationale. Hi, Eric, Thank you for the review. Can you take yet another look? On second thought, I come to believe that we should actually cause mousemove event after scrolling via wheel/keys because - MAC sends a mousemove event anyway, and - there seem to be no other easy ways to cause mouseover or mouseout events. I've added a comment to explain the above rationale and why MAC doesn't need this patch. Yuzo 130251 18 32291 mark 2009-07-07 11:58:09 -0700 Comment on attachment 32291 Added rationale. This patch will fix a Chromium bug if PLATFORM(CHROMIUM) is added to this line: 2419 #if PLATFORM(WIN) || PLATFORM(GTK) The bug question is http://crbug.com/15656, which is Mac-specific, but we do need this for our other platforms as well. 130320 19 32408 yuzo 2009-07-07 18:03:37 -0700 Created attachment 32408 Add CHROMIUM to the target platform. Mark, Thank you for your comment. I've added PLATFORM(CHROMIUM) to the #if. Yuzo 131265 20 yuzo 2009-07-13 00:49:45 -0700 Ping? 132263 21 32408 darin 2009-07-16 08:10:10 -0700 Comment on attachment 32408 Add CHROMIUM to the target platform. > + const bool result = handleWheelEventInternal(e); There are many local variables that could be marked const. Normally it is not our style in the WebKit project to do this just because the variable is not modified in the function. It seems an unnecessary stylistic difference in your new code. > + // For Windows and GTK, we need to simulate a mousemove event after scrolling by mouse wheel or up/down/space key. > + // For MAC, we don't need to, because the OS sends a mousemove event after a mousewheel event, and hides the mouse cursor while scrolling by keys. > + // TODO: Examine other platforms. The name of the platforms are Windows and Mac. Not Windows and MAC. This comment seems incorrect to me. An almost identical issue exists on the Mac. I think the issue is that the Mac has code in WebKit to handle this, and the other platforms don't. I don't think the difference is in the OS. You should patch the platforms to be the same instead of creating an unnecessary platform difference. Even if what you said was true about the wheel events, it's definitely not true about keyboard events. In fact, by leaving this code turned off for Mac you miss the opportunity to fix a bug I've seen where scrolling with arrow keys on Mac doesn't result in update of hover. Worse, by including PLATFORM(CHROMIUM), you'd fix the Mac version of Chrome but leave this broken in the Mac version of Safari. > + // Simulating a mousemove event has a side effect that onmousemove handler is invoked when the mouse doesn't actually move. Tiny language nitpick. Referring to the "onmousemove" handler is unnecessarily inaccurate. Setting an onmousemove attribute is only one of many ways to set up a handler for a mousemove event, and not one that needs to be emphasized in comments. > + bool keyEventInternal(const PlatformKeyboardEvent&); > + bool handleWheelEventInternal(PlatformWheelEvent&); Why does one of these functions have "handle" in its name, but not the other? I guess because they reflect the names of the original functions that you broke into two pieces. It's a little ugly to just add a level of function call so you can wrap the function in new code. If people find other similar requirements and go on repeating this pattern, then we will end up with Internal2, Internal3, versions of these functions. The names do nothing to tell programmers what should be in the outer and what should be in the inner version. I don't think it's a good design pattern for the long term, although I think it's OK here. It's strange that we will record scroll positions and simulate mouse move events even for keyboard events we choose not to handle. I think this patch really isn't tackling this at the right level. It's true that this is the easiest level to patch for someone who's not familiar with the code, but scrolling can also be triggered by scripts rather than by events, and the scripts could run based on a timer. It's not right to trigger the simulated events based on the real events. Instead I think the simulated mouse move events should be triggered more directly by the actual document scrolling. A good test case would be a timer that scrolls. The cursor should be updated each time the scroll happens even if there is not keyboard or mouse wheel events. > + void updateMousePositions(const PlatformMouseEvent& mouseEvent); We do not give names to arguments like mouseEvent in function declarations when the type already makes the argument's purpose clear. > + const IntPoint& globalPos() const { return m_globalPosition; } I know this is just following the standard of the original code, but I think globalPosition() would be a better name for this new function. I think it's unnecessary to have the simulated event have so much incorrect state, such as false for all the modifier keys. Instead we should make the simulated event reflect the real state as much as possible. I also think that the simulated event should not contain the same mouse position as the last real event. The mapping from a global position to a local one can be affected by things such as the window position, and that could have changed since the last real mouse event, for example if a script moved the window. The idea of this code is great, but I think it needs more work and to be less platform-specific. 132265 22 darin 2009-07-16 08:10:41 -0700 This is not platform-specific. It happens on all platforms. 132296 23 darin 2009-07-16 10:33:56 -0700 I thought further about the best way to address this issue. It seems to me that scrolling and elements moving is made real when we do layout, so we may want to hook tis detection into the layout timer and layout machinery. After layout we can check if the current mouse position is still over the same thing it was over before, and if not send the appropriate events. We'll have to check that layout covers all the scrolling cases. If not, then we can have a separate set of the same kind of code for scrolling. Moving windows is yet another similar case. In all cases, it seems having a record of where we previously reported the mouse over is helpful so we can see if the new location is different in any way. I'm thinking that we might want to keep the actual DOM event that was sent to see if it's at all different. Besides the DOM events, we're also interested in making sure the cursor has the correct shape in these various cases. One simple model for this might be to have a recheckMousePositionSoon function on EventHandler that could be called in all places where there was a change that might require re-communicating the mouse position to the web page. I don't think that a check on the way in and the way back out of event handlers is the right bottleneck for this. I think it's the actual changes to rendering, scrolling, and window position that are apropros. 132432 24 yuzo 2009-07-16 18:12:22 -0700 Thank you very much for the very careful and detailed review. I agree. The piece of code that scrolls the document should be responsible for triggering update for mouse cursor/hover/link status. My band-aid like approach could be worse for the project in a long run. Probably surgery is called for here. :) Yuzo 138897 25 viettrungluu 2009-08-10 21:08:56 -0700 Darin, Safari/Mac appears to generate extra mouse move events for lots of things (including, e.g., mouse downs/ups), thereby avoiding a host of bugs. When scrolling using the keyboard, in Safari/Mac, the cursor (and tooltip) disappear, thereby eliminating a bunch of problems; actually, now that Chromium/Mac also makes the cursor (and consequently the tooltip, apparently) disappear, those same problems go away. Now, unfortunately, the mouse moving code (EventHandler::mouseMoved()/handleMouseMoveEvent()) are very tightly coupled with PlatformMouseEvent. To handle "virtual mouse moves", we need to at least do either (1) send fake mouse move events (ugly, but expedient) or (2) decouple the aforementioned code so that it can handle such "virtual mouse moves" without a PlatformMouseEvent (make an "EventHandler::mouseMovedVirtually()" method or some such). In some sense, the difference between (1) and (2) is cosmetic. You could decouple so far as to push a lot of the logic down into the layout, but that would be drastic and you'd have to make the layout aware of the mouse position. My first instinct to fix the scrolling-related issues is to hook up (1) or (2) in FrameView::valueChanged() (probably inside the "if (offset != scrollOffset())"). Similarly, you could do the same in FrameView::performPostLayoutTasks() -- I think this would probably handle any possible resize-related issues. (There are also possible window-movement issues -- i.e., the window moves without the mouse moving -- though I don't know offhand where that would get hooked up.) Hooking up a fake mouse event is expedient, if a little repugnant; decoupling the code is a bit fragile and goes pretty deep. (E.g., on resize, the mouse may end up over a scrollbar, so you can't just ignore the scrollbars.) Maybe I'll come up with a patch which sends a fake mouse event, and see if it works. 138906 26 34540 viettrungluu 2009-08-10 22:26:12 -0700 Created attachment 34540 Quick and dirty patch, as per my comments. For commentary only; no changelog entries. Only tested on Chromium/Mac. Hmm. The effect seems to be different from what happens in Safari/Mac (not for scrolling with arrow keys, but with trackpad/mousewheel -- see <http://crbug.com/15656>). 139043 27 darin 2009-08-11 11:13:08 -0700 There are at least three distinct related questions in my opinion: a) How we detect that there's a change that requires some mouse position processing. There are many different types of changes that could trigger the need for this, such as an element moving that has a CSS cursor associated with it so that it's no longer under the mouse, any kind of scrolling, or even a change to the CSS cursor property without any geometry change at all. We need a good architecture so that the new processing gets done. I don't think it necessarily has to be done right away. We could use a zero duration or small duration timer to coalesce these so that multiple changes don't require multiple attempts to process things, and so that the processing can happen after layout has occurred. In fact, when it comes to status bar messages, even changes in the keyboard state are relevant. For example, if you press the option key on the Mac, we need to recompute the status message. I believe this is currently done by simulating a "mousemove" when there is change in the state of modifier keys, done in the Mac-specific WebKit code. b) What should be seen at the DOM level. For example, if an element moved and that changes the cursor, then presumably ideally we don't want DOM event handlers to see a DOM "mousemove" event since the mouse didn't move. Or maybe we do, but if so it's an intentional choice, not just a side effect of how our code works internally. We might be willing to live with an excess "mousemove" event, but it's probably not working as designed if we send one. On the other hand, if an element moves so it's no longer under the mouse, we probably *do* want to send that object a "mouseout" event even if we would not have sent a "mousemove" event. What do we want seen at the DOM level when the option key goes down? Probably not a "mouse move" event, so that's a minor bug on the Mac that would be nice to fix. Unless we decide it's a feature rather than a bug. c) Once we detect a change, how we trigger the additional processing. It may be expedient to use what looks like a "mousemove" event to minimize refactoring of the existing code. But I think that sort of lack of clarity and logic in the code is unnecessary. We should be willing to make some changes to make this logical unless it's so difficult that it makes the problem a lot harder to fix. (In reply to comment #25) > Safari/Mac appears to generate extra mouse move events for lots of things > (including, e.g., mouse downs/ups), thereby avoiding a host of bugs. It would be very useful to determine where those events come from. Is it the Mac OS X AppKit that is providing these events? Or is it the Mac-specific WebKit code that creates them? If the former, then we should just live with them as is. If it's the latter, maybe we can solve this in a platform independent way and get rid of the unneeded code. > When > scrolling using the keyboard, in Safari/Mac, the cursor (and tooltip) > disappear, thereby eliminating a bunch of problems; actually, now that > Chromium/Mac also makes the cursor (and consequently the tooltip, apparently) > disappear, those same problems go away. This is an interesting point. It hides some problems (cursor and tooltip) but doesn't affect others at all (status bar, DOM events as seen on the web page, hover effects in the page). Why don't other platforms have this behavior? Is this really a unique feature of Mac OS X, or is this something we'd want on Windows and Unix desktop systems too? > Now, unfortunately, the mouse moving code > (EventHandler::mouseMoved()/handleMouseMoveEvent()) are very tightly coupled > with PlatformMouseEvent. To handle "virtual mouse moves", we need to at least > do either (1) send fake mouse move events (ugly, but expedient) or (2) decouple > the aforementioned code so that it can handle such "virtual mouse moves" > without a PlatformMouseEvent (make an "EventHandler::mouseMovedVirtually()" > method or some such). In some sense, the difference between (1) and (2) is > cosmetic. You could decouple so far as to push a lot of the logic down into the > layout, but that would be drastic and you'd have to make the layout aware of > the mouse position. You're talking about my issue (c) here. But I think that my issue (b) also comes up. Do we want actual mouse moves to show up in the DOM or not? I don't think this refactoring and clean-up is particularly difficult, and I'd love to see it done for code clarity either before or after this bug is fixed. I agree that it doesn't have to be done to fix the bug. > My first instinct to fix the scrolling-related issues is to hook up (1) or (2) > in FrameView::valueChanged() (probably inside the "if (offset != > scrollOffset())"). Similarly, you could do the same in > FrameView::performPostLayoutTasks() -- I think this would probably handle any > possible resize-related issues. (There are also possible window-movement issues > -- i.e., the window moves without the mouse moving -- though I don't know > offhand where that would get hooked up.) This seems to cover only a tiny fraction of problem (a). It's true that a FrameView scrolling can move an element. But also, changes to the element's geometry can move it. And overflow area scrolling can also move it. I'd like to understand our general strategy to detecting when elements move out from under the mouse. It may be that once we cover the general case we don't need anything separate for FrameView. > Hooking up a fake mouse event is expedient, if a little repugnant; decoupling > the code is a bit fragile and goes pretty deep. (E.g., on resize, the mouse may > end up over a scrollbar, so you can't just ignore the scrollbars.) My main complaint about your initial patch was that making a fake mouse event in response to a real wheel event is wrong. The major way it's wrong is (a). It's wrong to say that a wheel event is causing this. It's the *response* to the wheel event that creates the need to update things like cursors and makes you want to send a simulated mouse move event. You're focusing on issue (c), which is whether a fake mouse event is the best way to trigger the new processing. We can be flexible on this, but ideally the code is clear and not full of "fake" anything. I really don't think it's all that difficult to clean this up and make it right. The degree to which updating cursors is tied to a PlatformEvent for a mouse move event is actually pretty small in my opinion. 139063 28 viettrungluu 2009-08-11 12:29:09 -0700 [Just for clarity, I'm not the originator of the original patch....] (In reply to comment #27) > a) How we detect that there's a change that requires some mouse position > processing. I guess there are two approaches to this (and intermediates between the two extremes): (i) Code which does anything which causes changes which require such processing initiate the processing. Advantages: efficient (no extra checking needed). Disadvantages: need to carefully wire up lots of code. (ii) Check whether such processing is needed very often (possibly prompted by code which does anything which remotely *may* cause such a need), and do the processing if necessary. Advantages: no need to wire up other code so carefully. Disadvantages: nontrivial processing and possibly inefficient. In my quick-and-dirty patch, I've taken route (i): EventHandler::mouseMovedVirtually() is a stub which tells the EventHandler that something happened which caused the mouse to move "virtually". Currently, this immediately fires off a fake mouse event (ugh), but upon decoupling the code it could do something better; it could also be set to start a timer (to coalesce), etc. > b) What should be seen at the DOM level. [...] Right. I (as opposed to the original patch's author) wired up a fake mouse move purely out of expediency -- it's clearly not right. It forces a policy decision (send mouse move events on "virtual" mouse moves), but we shouldn't let a hack make policy. That said, sending a DOM mouse move may be desired, after all. > What do we want seen at the DOM level when the option key goes down? Probably > not a "mouse move" event, so that's a minor bug on the Mac that would be nice > to fix. Unless we decide it's a feature rather than a bug. Seems unlikely that that's a feature! I wouldn't want the option key to be hooked up to virtual mouse moves either, so that processing should probably be separated. > It may be expedient to use what looks like a "mousemove" event to minimize > refactoring of the existing code. But I think that sort of lack of clarity and > logic in the code is unnecessary. We should be willing to make some changes to > make this logical unless it's so difficult that it makes the problem a lot > harder to fix. It's a little painful since we have ugly scrollbar, etc. code which would also need to be rewired, the details which are a bit painful to get right. Currently, a lot of code is wired up to take a PlatformMouseEvent, probably unnecessarily. > It would be very useful to determine where those events come from. Is it the > Mac OS X AppKit that is providing these events? Or is it the Mac-specific > WebKit code that creates them? If the former, then we should just live with > them as is. If it's the latter, maybe we can solve this in a platform > independent way and get rid of the unneeded code. I wouldn't want to bet my life on it, but I would guess the former, or actually code in Safari itself. I don't think I've seen code that does this in WebKit (and Chromium/Mac doesn't get extra events). > > When > > scrolling using the keyboard, in Safari/Mac, the cursor (and tooltip) > > disappear, thereby eliminating a bunch of problems; [...] > > This is an interesting point. It hides some problems (cursor and tooltip) but > doesn't affect others at all (status bar, DOM events as seen on the web page, > hover effects in the page). True, and of course it doesn't help with scrolling with trackpad/mousewheel/other either. > Why don't other platforms have this behavior? Is this really a unique feature > of Mac OS X, or is this something we'd want on Windows and Unix desktop systems > too? It's standard on Mac, doesn't happen on Windows (in any browser that I know of, at least). I don't know about Unix desktops.... > I don't think this refactoring and clean-up is particularly difficult, and I'd > love to see it done for code clarity either before or after this bug is fixed. > I agree that it doesn't have to be done to fix the bug. Agreed, which is why my (even quick-and-dirty) patch is written as it is. For the mouse-related stuff (I don't know about the option key, etc.), I would separate out the code in mouseMoved() and handleMouseMoveEvent(), and have them (and mouseMovedVirtually()) call down to the common code appropriately. > This seems to cover only a tiny fraction of problem (a). It's true that a > FrameView scrolling can move an element. But also, changes to the element's > geometry can move it. And overflow area scrolling can also move it. I'd like to > understand our general strategy to detecting when elements move out from under > the mouse. It may be that once we cover the general case we don't need anything > separate for FrameView. I suppose that, adopting my tactic (i), we'd have to wire up all these other things explicitly as well. Our "general strategy for detecting when elements move out from under the mouse" rests right now entirely in EventHandler (not so great, but everything else seems mostly unaware of the mouse!), and in handleMouseMoveEvent() in particular (at least that should be changed). A further possible issue is that we may need to know whenever the mouse moves relative to anything (leaving an element); this would be the case if we want to send DOM mouse moves when scrolling, for example. > My main complaint about your initial patch was that making a fake mouse event > in response to a real wheel event is wrong. The major way it's wrong is (a). > It's wrong to say that a wheel event is causing this. It's the *response* to > the wheel event that creates the need to update things like cursors and makes > you want to send a simulated mouse move event. [Not my original patch, which is why I wired up to the scrolling instead....] So what do you think of having a separate mouseMovedVirtually() method in EventHandler? As I said, it and mouseMoved()/etc. should be refactored, but the semantics of mouseMovedVirtually() are quite clear -- whenever the mouse moves relative to any elements (without the mouse actually moving -- i.e., the elements move!), it should be called. Currently, I call it from the scrolling code, but it should be called from elsewhere as well; it may need to be made more sophisticated to work correctly in those cases, but it's a start. 139070 29 darin 2009-08-11 12:52:08 -0700 Sorry for confusing you with the earlier person working on this bug! (In reply to comment #28) > So what do you think of having a separate mouseMovedVirtually() method in > EventHandler? I would name it simulateMouseMove() or simulateMouseMotion() since I don't really think "virtually" is quite as good a way of saying what the function does. > but the > semantics of mouseMovedVirtually() are quite clear -- whenever the mouse moves > relative to any elements (without the mouse actually moving -- i.e., the > elements move!), it should be called. If that’s true, then perhaps we should name it for when it should be called rather than for what it does. Maybe contentMovedUnderMouse() or something along those lines? > Currently, I call it from the scrolling > code, but it should be called from elsewhere as well; it may need to be made > more sophisticated to work correctly in those cases, but it's a start. Seems like a reasonable first step. Lets not set our sights too low though. Lets try to fix this all the way! 139146 30 viettrungluu 2009-08-11 15:39:28 -0700 (In reply to comment #29) > Sorry for confusing you with the earlier person working on this bug! No worries. :-) > If that’s true, then perhaps we should name it for when it should be called > rather than for what it does. Maybe contentMovedUnderMouse() or something along > those lines? That sounds like a good name. > Seems like a reasonable first step. Lets not set our sights too low though. > Lets try to fix this all the way! So an issue is that, as I said, the PlatformMouseEvent's go fairly deep. In particular, we need to tell our Scrollbar's that the mouse position has changed relative to them. (This isn't true for the window scrollbars for the scrolling case, but is needed for a resize; for example, if the resize causes the mouse to be over or to leave the scrollbar, it may need to update its hover state.) Now, the stuff in Scrollbar.cpp isn't a problem, but it calls down to ScrollbarTheme ... which involves code in many places. There's also the mouse event dispatch code (going down into the DOM code), though that looks more easily manageable. Possible solutions: (1) Refactor everything, ditching PlatformMouseEvent's where possible. (Seems a bit like overkill? This would affect code in many places, including platform code.) (2) Add methods which don't require PlatformMouseEvent's alongside the current ones. (Adds either hard-to-maintain redundancy -- or complexity, if code is refactored to make things common. Not really any better than (1), since it would also touch platform code.) (3) Add an event type to PlatformMouseEvent -- "MouseEventUpdatePosition" or some such; code which cares can look for it. (Possible bugs in code which assumes all data are valid, but that would happen with fake mouse moves anyway.) (4) Generate fake PlatformMouseEvent's (with a fake MouseEventMoved). Obviously "works", but it's a pack of lies. I'm kind of inclined towards (3). For things like keyboard flags, one could similarly have "MouseEventUpdateKeys". 560390 31 mrobinson 2012-02-20 15:00:38 -0800 *** Bug 26727 has been marked as a duplicate of this bug. *** 31772 2009-06-24 00:33:50 -0700 2009-06-24 04:29:11 -0700 A proposed patch for this bug scrollpatch.txt text/plain 7307 yuzo SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NTA2MykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzEgQEAKKzIwMDktMDYtMjMgIFl1em8gRnVqaXNoaW1hIDx5dXpvQGdvb2dsZS5j b20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4 IGZvciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTcwNTIKKworICAg ICAgICBUbyB1cGRhdGUgY3Vyc29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlIGR1cmlu ZyBzY3JvbGwgdmlhIG1vdXNlCisgICAgICAgIHdoZWVsIG9yIGtleXMgKHVwL2Rvd24vc3BhY2Up LCBzaW11bGF0ZSBhIG1vdXNlIG1vdmUgZXZlbnQgYWZ0ZXIKKyAgICAgICAgaGFuZGxpbmcgYSB3 aGVlbCBldmVudCBvciBhIGtleSB1cCBldmVudC4gVGhpcyBpcyBuZWNlc3NhcnkgZm9yIFdpbmRv d3MuCisKKyAgICAgICAgQWRkaW5nIGEgdGVzdCBmb3IgdGhpcyBpcyBkaWZmaWN1bHQsIGJlY2F1 c2UgaXQgaXMgaGFyZCB0byB0cmFjaywgZm9yCisgICAgICAgIGV4YW1wbGUsIHRoZSBtb3VzZSBj dXJzb3Igc2hhcGUgY2hhbmdlIGR1cmluZyBzY3JvbGwgaW5pdGlhdGVkIGJ5CisgICAgICAgIG1v dXNlIHdoZWVsIG9yIGtleXMuCisKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmNsZWFyKToKKyAgICAgICAgKFdlYkNvcmU6 OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6 OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VEb3VibGVDbGlja0V2ZW50KToKKyAgICAgICAgKFdl YkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VNb3ZlRXZlbnQpOgorICAgICAgICAoV2Vi Q29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmVudCk6CisgICAgICAgIChX ZWJDb3JlOjpFdmVudEhhbmRsZXI6OnVwZGF0ZUN1cnJlbnRNb3VzZVBvaXN0aW9ucyk6CisgICAg ICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZVdoZWVsRXZlbnQpOgorICAgICAgICAo V2ViQ29yZTo6RXZlbnRIYW5kbGVyOjprZXlFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVu dEhhbmRsZXI6OnNpbXVsYXRlTW91c2VNb3ZlKToKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxl ci5oOgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRmb3JtTW91c2VFdmVudC5oOgorICAgICAgICAo V2ViQ29yZTo6UGxhdGZvcm1Nb3VzZUV2ZW50OjpnbG9iYWxQb3MpOgorCiAyMDA5LTA2LTIzICBP bGl2ZXIgSHVudCAgPG9saXZlckBhcHBsZS5jb20+IGFuZCBFcmljIENhcmxzb24gIDxlcmljLmNh cmxzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcgYW5kIERh dmUgSHlhdHQuCkluZGV4OiBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAkocmV2aXNpb24gNDQ5ODUpCisrKyBX ZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTg5LDYgKzE4 OSw3IEBAIHZvaWQgRXZlbnRIYW5kbGVyOjpjbGVhcigpCiAgICAgbV9mcmFtZVNldEJlaW5nUmVz aXplZCA9IDA7CiAgICAgbV9kcmFnVGFyZ2V0ID0gMDsKICAgICBtX2N1cnJlbnRNb3VzZVBvc2l0 aW9uID0gSW50UG9pbnQoKTsKKyAgICBtX2N1cnJlbnRNb3VzZUdsb2JhbFBvc2l0aW9uID0gSW50 UG9pbnQoKTsKICAgICBtX21vdXNlUHJlc3NOb2RlID0gMDsKICAgICBtX21vdXNlUHJlc3NlZCA9 IGZhbHNlOwogICAgIG1fY2FwdHVyZXNEcmFnZ2luZyA9IGZhbHNlOwpAQCAtMTA2Niw3ICsxMDY3 LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUHJlc3NFdmVudAogCiAgICAgbV9t b3VzZVByZXNzZWQgPSB0cnVlOwogICAgIG1fY2FwdHVyZXNEcmFnZ2luZyA9IHRydWU7Ci0gICAg bV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1vdXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlQ3Vy cmVudE1vdXNlUG9pc3Rpb25zKG1vdXNlRXZlbnQpOwogICAgIG1fbW91c2VEb3duVGltZXN0YW1w ID0gbW91c2VFdmVudC50aW1lc3RhbXAoKTsKICAgICBtX21vdXNlRG93bk1heVN0YXJ0RHJhZyA9 IGZhbHNlOwogICAgIG1fbW91c2VEb3duTWF5U3RhcnRTZWxlY3QgPSBmYWxzZTsKQEAgLTEyMDEs NyArMTIwMiw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJsZUNsaWMKIAog ICAgIC8vIFdlIGdldCB0aGlzIGluc3RlYWQgb2YgYSBzZWNvbmQgbW91c2UtdXAgCiAgICAgbV9t b3VzZVByZXNzZWQgPSBmYWxzZTsKLSAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91c2VF dmVudC5wb3MoKTsKKyAgICB1cGRhdGVDdXJyZW50TW91c2VQb2lzdGlvbnMobW91c2VFdmVudCk7 CiAKICAgICBIaXRUZXN0UmVxdWVzdCByZXF1ZXN0KEhpdFRlc3RSZXF1ZXN0OjpBY3RpdmUpOwog ICAgIE1vdXNlRXZlbnRXaXRoSGl0VGVzdFJlc3VsdHMgbWV2ID0gcHJlcGFyZU1vdXNlRXZlbnQo cmVxdWVzdCwgbW91c2VFdmVudCk7CkBAIC0xMjU3LDcgKzEyNTgsNyBAQCBib29sIEV2ZW50SGFu ZGxlcjo6aGFuZGxlTW91c2VNb3ZlRXZlbnQoCiAgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAg IFJlZlB0cjxGcmFtZVZpZXc+IHByb3RlY3RvcihtX2ZyYW1lLT52aWV3KCkpOwotICAgIG1fY3Vy cmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIHVwZGF0ZUN1cnJlbnRN b3VzZVBvaXN0aW9ucyhtb3VzZUV2ZW50KTsKIAogICAgIGlmIChtX2hvdmVyVGltZXIuaXNBY3Rp dmUoKSkKICAgICAgICAgbV9ob3ZlclRpbWVyLnN0b3AoKTsKQEAgLTEzNTgsNyArMTM1OSw3IEBA IGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmUKICAgICBSZWZQdHI8RnJh bWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmlldygpKTsKIAogICAgIG1fbW91c2VQcmVzc2Vk ID0gZmFsc2U7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1vdXNlRXZlbnQucG9zKCk7 CisgICAgdXBkYXRlQ3VycmVudE1vdXNlUG9pc3Rpb25zKG1vdXNlRXZlbnQpOwogCiAjaWYgRU5B QkxFKFNWRykKICAgICBpZiAobV9zdmdQYW4pIHsKQEAgLTE1NDUsNiArMTU0NiwxMSBAQCBzdGF0 aWMgaW5saW5lIFNWR0VsZW1lbnRJbnN0YW5jZSogaW5zdGFuCiB9CiAjZW5kaWYKIAordm9pZCBF dmVudEhhbmRsZXI6OnVwZGF0ZUN1cnJlbnRNb3VzZVBvaXN0aW9ucyhjb25zdCBQbGF0Zm9ybU1v dXNlRXZlbnQmIG1vdXNlRXZlbnQpIHsKKyAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91 c2VFdmVudC5wb3MoKTsKKyAgICBtX2N1cnJlbnRNb3VzZUdsb2JhbFBvc2l0aW9uID0gbW91c2VF dmVudC5nbG9iYWxQb3MoKTsKK30KKwogdm9pZCBFdmVudEhhbmRsZXI6OnVwZGF0ZU1vdXNlRXZl bnRUYXJnZXROb2RlKE5vZGUqIHRhcmdldE5vZGUsIGNvbnN0IFBsYXRmb3JtTW91c2VFdmVudCYg bW91c2VFdmVudCwgYm9vbCBmaXJlTW91c2VPdmVyT3V0KQogewogICAgIE5vZGUqIHJlc3VsdCA9 IHRhcmdldE5vZGU7CkBAIC0xNzM2LDYgKzE3NDIsMTEgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZVdoZWVsRXZlbnQoUGxhdAogICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICB2aWV3LT53 aGVlbEV2ZW50KGUpOworCisjaWYgUExBVEZPUk0oV0lOKQorICAgIHNpbXVsYXRlTW91c2VNb3Zl KCk7CisjZW5kaWYKKwogICAgIHJldHVybiBlLmlzQWNjZXB0ZWQoKTsKIH0KIApAQCAtMTkxMCw4 ICsxOTIxLDE0IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjprZXlFdmVudChjb25zdCBQbGF0Zm8KICAg ICAgICAgbWF0Y2hlZEFuQWNjZXNzS2V5ID0gaGFuZGxlQWNjZXNzS2V5KGluaXRpYWxLZXlFdmVu dCk7CiAKICAgICAvLyBGSVhNRTogaXQgd291bGQgYmUgZmFpciB0byBsZXQgYW4gaW5wdXQgbWV0 aG9kIGhhbmRsZSBLZXlVcCBldmVudHMgYmVmb3JlIERPTSBkaXNwYXRjaC4KLSAgICBpZiAoaW5p dGlhbEtleUV2ZW50LnR5cGUoKSA9PSBQbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OktleVVwIHx8IGlu aXRpYWxLZXlFdmVudC50eXBlKCkgPT0gUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpDaGFyKQorICAg IGlmIChpbml0aWFsS2V5RXZlbnQudHlwZSgpID09IFBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6S2V5 VXAgfHwgaW5pdGlhbEtleUV2ZW50LnR5cGUoKSA9PSBQbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OkNo YXIpIHsKKworI2lmIFBMQVRGT1JNKFdJTikKKyAgICAgICAgc2ltdWxhdGVNb3VzZU1vdmUoKTsK KyNlbmRpZgorCiAgICAgICAgIHJldHVybiAhbm9kZS0+ZGlzcGF0Y2hLZXlFdmVudChpbml0aWFs S2V5RXZlbnQpOworICAgIH0KIAogICAgIGJvb2wgYmFja3dhcmRDb21wYXRpYmlsaXR5TW9kZSA9 IG5lZWRzS2V5Ym9hcmRFdmVudERpc2FtYmlndWF0aW9uUXVpcmtzKCk7CiAKQEAgLTE5MjYsNiAr MTk0MywxMSBAQCBib29sIEV2ZW50SGFuZGxlcjo6a2V5RXZlbnQoY29uc3QgUGxhdGZvCiAKICAg ICBpZiAoaW5pdGlhbEtleUV2ZW50LnR5cGUoKSA9PSBQbGF0Zm9ybUtleWJvYXJkRXZlbnQ6OlJh d0tleURvd24pIHsKICAgICAgICAgbm9kZS0+ZGlzcGF0Y2hFdmVudChrZXlkb3duLCBlYyk7CisK KyNpZiBQTEFURk9STShXSU4pCisgICAgICAgIHNpbXVsYXRlTW91c2VNb3ZlKCk7CisjZW5kaWYK KwogICAgICAgICByZXR1cm4ga2V5ZG93bi0+ZGVmYXVsdEhhbmRsZWQoKSB8fCBrZXlkb3duLT5k ZWZhdWx0UHJldmVudGVkKCk7CiAgICAgfQogCkBAIC0yMzcxLDQgKzIzOTMsMTQgQEAgYm9vbCBF dmVudEhhbmRsZXI6OnBhc3NNb3VzZVByZXNzRXZlbnRUbwogICAgIHJldHVybiBzY3JvbGxiYXIt Pm1vdXNlRG93bihtZXYuZXZlbnQoKSk7CiB9CiAKKyNpZiBQTEFURk9STShXSU4pCisvLyBTaW11 bGF0ZSBhIG1vdXNlIG1vdmUgdG8gdXBkYXRlIGN1cnNvciwgbGluayB0YXJnZXQsIGFuZCBob3Zl ciBzdGF0ZS4KK3ZvaWQgRXZlbnRIYW5kbGVyOjpzaW11bGF0ZU1vdXNlTW92ZSgpIHsKKyAgICBp ZiAobV9jdXJyZW50TW91c2VQb3NpdGlvbi54KCkgPCAwIHx8IG1fY3VycmVudE1vdXNlUG9zaXRp b24ueSgpIDwgMCkKKyAgICAgICAgcmV0dXJuOworICAgIFBsYXRmb3JtTW91c2VFdmVudCBzaW11 bGF0ZWRFdmVudChtX2N1cnJlbnRNb3VzZVBvc2l0aW9uLCBtX2N1cnJlbnRNb3VzZUdsb2JhbFBv c2l0aW9uLCBOb0J1dHRvbiwgTW91c2VFdmVudE1vdmVkLCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNl LCBmYWxzZSwgMCk7CisgICAgbW91c2VNb3ZlZChzaW11bGF0ZWRFdmVudCk7CisjZW5kaWYKK30K KwogfQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuaAkocmV2aXNpb24gNDQ5ODUpCisrKyBXZWJDb3JlL3Bh Z2UvRXZlbnRIYW5kbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTIyMCw2ICsyMjAsNyBAQCBwcml2 YXRlOgogCiAgICAgTm9kZSogbm9kZVVuZGVyTW91c2UoKSBjb25zdDsKICAgICAKKyAgICB2b2lk IHVwZGF0ZUN1cnJlbnRNb3VzZVBvaXN0aW9ucyhjb25zdCBQbGF0Zm9ybU1vdXNlRXZlbnQmIG1v dXNlRXZlbnQpOwogICAgIHZvaWQgdXBkYXRlTW91c2VFdmVudFRhcmdldE5vZGUoTm9kZSosIGNv bnN0IFBsYXRmb3JtTW91c2VFdmVudCYsIGJvb2wgZmlyZU1vdXNlT3Zlck91dCk7CiAgICAgdm9p ZCBmaXJlTW91c2VPdmVyT3V0KGJvb2wgZmlyZU1vdXNlT3ZlciA9IHRydWUsIGJvb2wgZmlyZU1v dXNlT3V0ID0gdHJ1ZSwgYm9vbCB1cGRhdGVMYXN0Tm9kZVVuZGVyTW91c2UgPSB0cnVlKTsKICAg ICAKQEAgLTI3NSw2ICsyNzYsMTAgQEAgcHJpdmF0ZToKICAgICBQbGF0Zm9ybU1vdXNlRXZlbnQg Y3VycmVudFBsYXRmb3JtTW91c2VFdmVudCgpIGNvbnN0OwogI2VuZGlmCiAKKyNpZiBQTEFURk9S TShXSU4pCisgICAgdm9pZCBzaW11bGF0ZU1vdXNlTW92ZSgpOworI2VuZGlmCisKICAgICBGcmFt ZSogbV9mcmFtZTsKIAogICAgIGJvb2wgbV9tb3VzZVByZXNzZWQ7CkBAIC0zMjQsNiArMzI5LDcg QEAgcHJpdmF0ZToKICAgICBJbnRTaXplIG1fb2Zmc2V0RnJvbVJlc2l6ZUNvcm5lcjsgICAvLyBp biB0aGUgY29vcmRzIG9mIG1fcmVzaXplTGF5ZXIKICAgICAKICAgICBJbnRQb2ludCBtX2N1cnJl bnRNb3VzZVBvc2l0aW9uOworICAgIEludFBvaW50IG1fY3VycmVudE1vdXNlR2xvYmFsUG9zaXRp b247CiAgICAgSW50UG9pbnQgbV9tb3VzZURvd25Qb3M7IC8vIGluIG91ciB2aWV3J3MgY29vcmRz CiAgICAgZG91YmxlIG1fbW91c2VEb3duVGltZXN0YW1wOwogICAgIFBsYXRmb3JtTW91c2VFdmVu dCBtX21vdXNlRG93bjsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1Nb3VzZUV2ZW50 LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybU1vdXNlRXZlbnQuaAko cmV2aXNpb24gNDQ5ODUpCisrKyBXZWJDb3JlL3BsYXRmb3JtL1BsYXRmb3JtTW91c2VFdmVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC05MCw2ICs5MCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgY29uc3QgSW50UG9pbnQmIHBvcygpIGNvbnN0IHsgcmV0dXJuIG1fcG9zaXRpb247IH0K ICAgICAgICAgaW50IHgoKSBjb25zdCB7IHJldHVybiBtX3Bvc2l0aW9uLngoKTsgfQogICAgICAg ICBpbnQgeSgpIGNvbnN0IHsgcmV0dXJuIG1fcG9zaXRpb24ueSgpOyB9CisgICAgICAgIGNvbnN0 IEludFBvaW50JiBnbG9iYWxQb3MoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbFBvc2l0aW9uOyB9 CiAgICAgICAgIGludCBnbG9iYWxYKCkgY29uc3QgeyByZXR1cm4gbV9nbG9iYWxQb3NpdGlvbi54 KCk7IH0KICAgICAgICAgaW50IGdsb2JhbFkoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbFBvc2l0 aW9uLnkoKTsgfQogICAgICAgICBNb3VzZUJ1dHRvbiBidXR0b24oKSBjb25zdCB7IHJldHVybiBt X2J1dHRvbjsgfQo= 31778 2009-06-24 04:29:11 -0700 2009-06-24 18:28:45 -0700 A revised patch. scrollpatch2.txt text/plain 8546 yuzo SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NTA3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzQgQEAKKzIwMDktMDYtMjQgIFl1em8gRnVqaXNoaW1hIDx5dXpvQGdvb2dsZS5j b20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4 IGZvciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTcwNTIKKworICAg ICAgICBUbyB1cGRhdGUgY3Vyc29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlIGR1cmlu ZyBzY3JvbGwgdmlhIG1vdXNlCisgICAgICAgIHdoZWVsIG9yIGtleXMgKHVwL2Rvd24vc3BhY2Up LCBzaW11bGF0ZSBhIG1vdXNlIG1vdmUgZXZlbnQgYWZ0ZXIKKyAgICAgICAgaGFuZGxpbmcgYSB3 aGVlbCBldmVudCBvciBhIGtleSB1cCBldmVudC4KKworICAgICAgICBBZGRpbmcgYSB0ZXN0IGZv ciB0aGlzIGlzIGRpZmZpY3VsdCwgYmVjYXVzZSBpdCBpcyBoYXJkIHRvIHRyYWNrLCBmb3IKKyAg ICAgICAgZXhhbXBsZSwgdGhlIG1vdXNlIGN1cnNvciBzaGFwZSBjaGFuZ2UgZHVyaW5nIHNjcm9s bCBpbml0aWF0ZWQgYnkKKyAgICAgICAgbW91c2Ugd2hlZWwgb3Iga2V5cy4KKworICAgICAgICAq IHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6 Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVByZXNz RXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJs ZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3Vz ZU1vdmVFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNl UmVsZWFzZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6dXBkYXRlTW91 c2VQb3NpdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVl bEV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVu dEludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6a2V5RXZlbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjprZXlFdmVudEludGVybmFsKToKKyAgICAg ICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpzaW11bGF0ZU1vdXNlTW92ZUlmTmVjZXNzYXJ5KToK KyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRm b3JtTW91c2VFdmVudC5oOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1Nb3VzZUV2ZW50Ojpn bG9iYWxQb3MpOgorCiAyMDA5LTA2LTI0ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5u QG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBUb3IgQXJuZSBWZXN0YsO4LgpAQCAt NjMsNiArOTQsNyBAQAogICAgICAgICAoV2ViQ29yZTo6RHJhZ0NvbnRyb2xsZXI6OnRyeURIVE1M RHJhZyk6CiAgICAgICAgICogcGFnZS9EcmFnQ29udHJvbGxlci5oOgogCis+Pj4+Pj4+IC5yNDUw NzkKIDIwMDktMDYtMjMgIE9saXZlciBIdW50ICA8b2xpdmVyQGFwcGxlLmNvbT4gYW5kIEVyaWMg Q2FybHNvbiAgPGVyaWMuY2FybHNvbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg U2FtIFdlaW5pZyBhbmQgRGF2ZSBIeWF0dC4KSW5kZXg6IFdlYkNvcmUvcGFnZS9FdmVudEhhbmRs ZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCShyZXZp c2lvbiA0NDk4NSkKKysrIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xODksNiArMTg5LDggQEAgdm9pZCBFdmVudEhhbmRsZXI6OmNsZWFyKCkKICAgICBt X2ZyYW1lU2V0QmVpbmdSZXNpemVkID0gMDsKICAgICBtX2RyYWdUYXJnZXQgPSAwOwogICAgIG1f Y3VycmVudE1vdXNlUG9zaXRpb24gPSBJbnRQb2ludCgpOworICAgIG1fY3VycmVudE1vdXNlR2xv YmFsUG9zaXRpb24gPSBJbnRQb2ludCgpOworICAgIG1fcmVjb3JkZWRTY3JvbGxQb3NpdGlvbiA9 IEludFBvaW50KCk7CiAgICAgbV9tb3VzZVByZXNzTm9kZSA9IDA7CiAgICAgbV9tb3VzZVByZXNz ZWQgPSBmYWxzZTsKICAgICBtX2NhcHR1cmVzRHJhZ2dpbmcgPSBmYWxzZTsKQEAgLTEwNjYsNyAr MTA2OCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVByZXNzRXZlbnQKIAogICAg IG1fbW91c2VQcmVzc2VkID0gdHJ1ZTsKICAgICBtX2NhcHR1cmVzRHJhZ2dpbmcgPSB0cnVlOwot ICAgIG1fY3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIHVwZGF0 ZU1vdXNlUG9zaXRpb25zKG1vdXNlRXZlbnQpOwogICAgIG1fbW91c2VEb3duVGltZXN0YW1wID0g bW91c2VFdmVudC50aW1lc3RhbXAoKTsKICAgICBtX21vdXNlRG93bk1heVN0YXJ0RHJhZyA9IGZh bHNlOwogICAgIG1fbW91c2VEb3duTWF5U3RhcnRTZWxlY3QgPSBmYWxzZTsKQEAgLTEyMDEsNyAr MTIwMyw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJsZUNsaWMKIAogICAg IC8vIFdlIGdldCB0aGlzIGluc3RlYWQgb2YgYSBzZWNvbmQgbW91c2UtdXAgCiAgICAgbV9tb3Vz ZVByZXNzZWQgPSBmYWxzZTsKLSAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91c2VFdmVu dC5wb3MoKTsKKyAgICB1cGRhdGVNb3VzZVBvc2l0aW9ucyhtb3VzZUV2ZW50KTsKIAogICAgIEhp dFRlc3RSZXF1ZXN0IHJlcXVlc3QoSGl0VGVzdFJlcXVlc3Q6OkFjdGl2ZSk7CiAgICAgTW91c2VF dmVudFdpdGhIaXRUZXN0UmVzdWx0cyBtZXYgPSBwcmVwYXJlTW91c2VFdmVudChyZXF1ZXN0LCBt b3VzZUV2ZW50KTsKQEAgLTEyNTcsNyArMTI1OSw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5k bGVNb3VzZU1vdmVFdmVudCgKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgUmVmUHRyPEZy YW1lVmlldz4gcHJvdGVjdG9yKG1fZnJhbWUtPnZpZXcoKSk7Ci0gICAgbV9jdXJyZW50TW91c2VQ b3NpdGlvbiA9IG1vdXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91 c2VFdmVudCk7CiAKICAgICBpZiAobV9ob3ZlclRpbWVyLmlzQWN0aXZlKCkpCiAgICAgICAgIG1f aG92ZXJUaW1lci5zdG9wKCk7CkBAIC0xMzU4LDcgKzEzNjAsNyBAQCBib29sIEV2ZW50SGFuZGxl cjo6aGFuZGxlTW91c2VSZWxlYXNlRXZlCiAgICAgUmVmUHRyPEZyYW1lVmlldz4gcHJvdGVjdG9y KG1fZnJhbWUtPnZpZXcoKSk7CiAKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwotICAgIG1f Y3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIHVwZGF0ZU1vdXNl UG9zaXRpb25zKG1vdXNlRXZlbnQpOwogCiAjaWYgRU5BQkxFKFNWRykKICAgICBpZiAobV9zdmdQ YW4pIHsKQEAgLTE1NDUsNiArMTU0NywxMSBAQCBzdGF0aWMgaW5saW5lIFNWR0VsZW1lbnRJbnN0 YW5jZSogaW5zdGFuCiB9CiAjZW5kaWYKIAordm9pZCBFdmVudEhhbmRsZXI6OnVwZGF0ZU1vdXNl UG9zaXRpb25zKGNvbnN0IFBsYXRmb3JtTW91c2VFdmVudCYgbW91c2VFdmVudCkgeworICAgIG1f Y3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIG1fY3VycmVudE1v dXNlR2xvYmFsUG9zaXRpb24gPSBtb3VzZUV2ZW50Lmdsb2JhbFBvcygpOworfQorCiB2b2lkIEV2 ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VFdmVudFRhcmdldE5vZGUoTm9kZSogdGFyZ2V0Tm9kZSwg Y29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3VzZUV2ZW50LCBib29sIGZpcmVNb3VzZU92ZXJP dXQpCiB7CiAgICAgTm9kZSogcmVzdWx0ID0gdGFyZ2V0Tm9kZTsKQEAgLTE2NzksNiArMTY4Niwx NCBAQCBib29sIEV2ZW50SGFuZGxlcjo6ZGlzcGF0Y2hNb3VzZUV2ZW50KGNvCiAKIGJvb2wgRXZl bnRIYW5kbGVyOjpoYW5kbGVXaGVlbEV2ZW50KFBsYXRmb3JtV2hlZWxFdmVudCYgZSkKIHsKKyAg ICByZWNvcmRTY3JvbGxQb3NpdGlvbigpOworICAgIGNvbnN0IGJvb2wgcmVzdWx0ID0gaGFuZGxl V2hlZWxFdmVudEludGVybmFsKGUpOworICAgIHNpbXVsYXRlTW91c2VNb3ZlSWZOZWNlc3Nhcnko KTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlV2hl ZWxFdmVudEludGVybmFsKFBsYXRmb3JtV2hlZWxFdmVudCYgZSkKK3sKICAgICBEb2N1bWVudCog ZG9jID0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKIAogICAgIFJlbmRlck9iamVjdCogZG9jUmVuZGVy ZXIgPSBkb2MtPnJlbmRlcmVyKCk7CkBAIC0xODczLDYgKzE4ODgsMTYgQEAgYm9vbCBFdmVudEhh bmRsZXI6Om5lZWRzS2V5Ym9hcmRFdmVudERpcwogCiBib29sIEV2ZW50SGFuZGxlcjo6a2V5RXZl bnQoY29uc3QgUGxhdGZvcm1LZXlib2FyZEV2ZW50JiBpbml0aWFsS2V5RXZlbnQpCiB7CisgICAg aWYgKGluaXRpYWxLZXlFdmVudC50eXBlKCkgPT0gUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpLZXlE b3duIHx8IGluaXRpYWxLZXlFdmVudC50eXBlKCkgPT0gUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpS YXdLZXlEb3duKQorICAgICAgICByZWNvcmRTY3JvbGxQb3NpdGlvbigpOworICAgIGNvbnN0IGJv b2wgcmVzdWx0ID0ga2V5RXZlbnRJbnRlcm5hbChpbml0aWFsS2V5RXZlbnQpOworICAgIGlmIChp bml0aWFsS2V5RXZlbnQudHlwZSgpID09IFBsYXRmb3JtS2V5Ym9hcmRFdmVudDo6S2V5VXApCisg ICAgICAgIHNpbXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0 OworfQorCitib29sIEV2ZW50SGFuZGxlcjo6a2V5RXZlbnRJbnRlcm5hbChjb25zdCBQbGF0Zm9y bUtleWJvYXJkRXZlbnQmIGluaXRpYWxLZXlFdmVudCkKK3sKICNpZiBFTkFCTEUoUEFOX1NDUk9M TElORykKICAgICBpZiAoUGFnZSogcGFnZSA9IG1fZnJhbWUtPnBhZ2UoKSkgewogICAgICAgICBp ZiAocGFnZS0+bWFpbkZyYW1lKCktPmV2ZW50SGFuZGxlcigpLT5wYW5TY3JvbGxJblByb2dyZXNz KCkgfHwgbV9hdXRvc2Nyb2xsSW5Qcm9ncmVzcykgewpAQCAtMjM3MSw0ICsyMzk2LDI0IEBAIGJv b2wgRXZlbnRIYW5kbGVyOjpwYXNzTW91c2VQcmVzc0V2ZW50VG8KICAgICByZXR1cm4gc2Nyb2xs YmFyLT5tb3VzZURvd24obWV2LmV2ZW50KCkpOwogfQogCit2b2lkIEV2ZW50SGFuZGxlcjo6cmVj b3JkU2Nyb2xsUG9zaXRpb24oKSB7CisgICAgRnJhbWVWaWV3KiB2ID0gbV9mcmFtZS0+dmlldygp OworICAgIGlmICghdikKKyAgICAgICAgcmV0dXJuOworICAgIG1fcmVjb3JkZWRTY3JvbGxQb3Np dGlvbiA9IHYtPnNjcm9sbFBvc2l0aW9uKCk7Cit9CisKKy8vIFNpbXVsYXRlIGEgbW91c2UgbW92 ZSB0byB1cGRhdGUgY3Vyc29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlLgordm9pZCBF dmVudEhhbmRsZXI6OnNpbXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKSB7CisgICAgaWYgKG1f Y3VycmVudE1vdXNlUG9zaXRpb24ueCgpIDwgMCB8fCBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uLnko KSA8IDApCisgICAgICAgIHJldHVybjsKKyAgICBGcmFtZVZpZXcqIHYgPSBtX2ZyYW1lLT52aWV3 KCk7CisgICAgaWYgKCF2KQorICAgICAgICByZXR1cm47CisgICAgaWYgKG1fcmVjb3JkZWRTY3Jv bGxQb3NpdGlvbiA9PSB2LT5zY3JvbGxQb3NpdGlvbigpKQorICAgICAgICByZXR1cm47CisgICAg UGxhdGZvcm1Nb3VzZUV2ZW50IHNpbXVsYXRlZEV2ZW50KG1fY3VycmVudE1vdXNlUG9zaXRpb24s IG1fY3VycmVudE1vdXNlR2xvYmFsUG9zaXRpb24sIE5vQnV0dG9uLCBNb3VzZUV2ZW50TW92ZWQs IDAsIGZhbHNlLCBmYWxzZSwgZmFsc2UsIGZhbHNlLCAwKTsKKyAgICBtb3VzZU1vdmVkKHNpbXVs YXRlZEV2ZW50KTsKK30KKwogfQpJbmRleDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuaAkocmV2aXNpb24gNDQ5ODUp CisrKyBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTIwMCw3 ICsyMDAsMTAgQEAgcHJpdmF0ZToKICAgICBib29sIGhhbmRsZU1vdXNlUmVsZWFzZUV2ZW50KGNv bnN0IE1vdXNlRXZlbnRXaXRoSGl0VGVzdFJlc3VsdHMmKTsKIAogICAgIHZvaWQgaGFuZGxlS2V5 Ym9hcmRTZWxlY3Rpb25Nb3ZlbWVudChLZXlib2FyZEV2ZW50Kik7Ci0gICAgCisKKyAgICBib29s IGtleUV2ZW50SW50ZXJuYWwoY29uc3QgUGxhdGZvcm1LZXlib2FyZEV2ZW50Jik7CisgICAgYm9v bCBoYW5kbGVXaGVlbEV2ZW50SW50ZXJuYWwoUGxhdGZvcm1XaGVlbEV2ZW50Jik7CisKICAgICBD dXJzb3Igc2VsZWN0Q3Vyc29yKGNvbnN0IE1vdXNlRXZlbnRXaXRoSGl0VGVzdFJlc3VsdHMmLCBT Y3JvbGxiYXIqKTsKICNpZiBFTkFCTEUoUEFOX1NDUk9MTElORykKICAgICB2b2lkIHNldFBhblNj cm9sbEN1cnNvcigpOwpAQCAtMjIwLDYgKzIyMyw3IEBAIHByaXZhdGU6CiAKICAgICBOb2RlKiBu b2RlVW5kZXJNb3VzZSgpIGNvbnN0OwogICAgIAorICAgIHZvaWQgdXBkYXRlTW91c2VQb3NpdGlv bnMoY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3VzZUV2ZW50KTsKICAgICB2b2lkIHVwZGF0 ZU1vdXNlRXZlbnRUYXJnZXROb2RlKE5vZGUqLCBjb25zdCBQbGF0Zm9ybU1vdXNlRXZlbnQmLCBi b29sIGZpcmVNb3VzZU92ZXJPdXQpOwogICAgIHZvaWQgZmlyZU1vdXNlT3Zlck91dChib29sIGZp cmVNb3VzZU92ZXIgPSB0cnVlLCBib29sIGZpcmVNb3VzZU91dCA9IHRydWUsIGJvb2wgdXBkYXRl TGFzdE5vZGVVbmRlck1vdXNlID0gdHJ1ZSk7CiAgICAgCkBAIC0yNjksNiArMjczLDkgQEAgcHJp dmF0ZToKIAogICAgIGJvb2wgY2FwdHVyZXNEcmFnZ2luZygpIGNvbnN0IHsgcmV0dXJuIG1fY2Fw dHVyZXNEcmFnZ2luZzsgfQogCisgICAgdm9pZCByZWNvcmRTY3JvbGxQb3NpdGlvbigpOworICAg IHZvaWQgc2ltdWxhdGVNb3VzZU1vdmVJZk5lY2Vzc2FyeSgpOworCiAjaWYgUExBVEZPUk0oTUFD KSAmJiBkZWZpbmVkKF9fT0JKQ19fKQogICAgIE5TVmlldyAqbW91c2VEb3duVmlld0lmU3RpbGxH b29kKCk7CiAKQEAgLTMyNCwxMCArMzMxLDEzIEBAIHByaXZhdGU6CiAgICAgSW50U2l6ZSBtX29m ZnNldEZyb21SZXNpemVDb3JuZXI7ICAgLy8gaW4gdGhlIGNvb3JkcyBvZiBtX3Jlc2l6ZUxheWVy CiAgICAgCiAgICAgSW50UG9pbnQgbV9jdXJyZW50TW91c2VQb3NpdGlvbjsKKyAgICBJbnRQb2lu dCBtX2N1cnJlbnRNb3VzZUdsb2JhbFBvc2l0aW9uOwogICAgIEludFBvaW50IG1fbW91c2VEb3du UG9zOyAvLyBpbiBvdXIgdmlldydzIGNvb3JkcwogICAgIGRvdWJsZSBtX21vdXNlRG93blRpbWVz dGFtcDsKICAgICBQbGF0Zm9ybU1vdXNlRXZlbnQgbV9tb3VzZURvd247CiAKKyAgICBJbnRQb2lu dCBtX3JlY29yZGVkU2Nyb2xsUG9zaXRpb247CisKICNpZiBQTEFURk9STShNQUMpCiAgICAgTlNW aWV3ICptX21vdXNlRG93blZpZXc7CiAgICAgYm9vbCBtX3NlbmRpbmdFdmVudFRvU3VidmlldzsK SW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1Nb3VzZUV2ZW50LmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybU1vdXNlRXZlbnQuaAkocmV2aXNpb24gNDQ5ODUp CisrKyBXZWJDb3JlL3BsYXRmb3JtL1BsYXRmb3JtTW91c2VFdmVudC5oCSh3b3JraW5nIGNvcHkp CkBAIC05MCw2ICs5MCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgY29uc3QgSW50 UG9pbnQmIHBvcygpIGNvbnN0IHsgcmV0dXJuIG1fcG9zaXRpb247IH0KICAgICAgICAgaW50IHgo KSBjb25zdCB7IHJldHVybiBtX3Bvc2l0aW9uLngoKTsgfQogICAgICAgICBpbnQgeSgpIGNvbnN0 IHsgcmV0dXJuIG1fcG9zaXRpb24ueSgpOyB9CisgICAgICAgIGNvbnN0IEludFBvaW50JiBnbG9i YWxQb3MoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbFBvc2l0aW9uOyB9CiAgICAgICAgIGludCBn bG9iYWxYKCkgY29uc3QgeyByZXR1cm4gbV9nbG9iYWxQb3NpdGlvbi54KCk7IH0KICAgICAgICAg aW50IGdsb2JhbFkoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbFBvc2l0aW9uLnkoKTsgfQogICAg ICAgICBNb3VzZUJ1dHRvbiBidXR0b24oKSBjb25zdCB7IHJldHVybiBtX2J1dHRvbjsgfQo= 31822 2009-06-24 18:28:45 -0700 2009-07-06 02:49:00 -0700 Addressed comments scrollpatch3.txt text/plain 8308 yuzo SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NTA3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzQgQEAKKzIwMDktMDYtMjQgIFl1em8gRnVqaXNoaW1hIDx5dXpvQGdvb2dsZS5j b20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4 IGZvciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTcwNTIKKworICAg ICAgICBUbyB1cGRhdGUgY3Vyc29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlIGR1cmlu ZyBzY3JvbGwgdmlhIG1vdXNlCisgICAgICAgIHdoZWVsIG9yIGtleXMgKHVwL2Rvd24vc3BhY2Up LCBzaW11bGF0ZSBhIG1vdXNlIG1vdmUgZXZlbnQgYWZ0ZXIKKyAgICAgICAgaGFuZGxpbmcgYSB3 aGVlbCBldmVudCBvciBhIGtleSB1cCBldmVudC4KKworICAgICAgICBBZGRpbmcgYSB0ZXN0IGZv ciB0aGlzIGlzIGRpZmZpY3VsdCwgYmVjYXVzZSBpdCBpcyBoYXJkIHRvIHRyYWNrLCBmb3IKKyAg ICAgICAgZXhhbXBsZSwgdGhlIG1vdXNlIGN1cnNvciBzaGFwZSBjaGFuZ2UgZHVyaW5nIHNjcm9s bCBpbml0aWF0ZWQgYnkKKyAgICAgICAgbW91c2Ugd2hlZWwgb3Iga2V5cy4KKworICAgICAgICAq IHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6 Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVByZXNz RXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJs ZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3Vz ZU1vdmVFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNl UmVsZWFzZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6dXBkYXRlTW91 c2VQb3NpdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVl bEV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVu dEludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6a2V5RXZlbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjprZXlFdmVudEludGVybmFsKToKKyAgICAg ICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpzaW11bGF0ZU1vdXNlTW92ZUlmTmVjZXNzYXJ5KToK KyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRm b3JtTW91c2VFdmVudC5oOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1Nb3VzZUV2ZW50Ojpn bG9iYWxQb3MpOgorCiAyMDA5LTA2LTI0ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5u QG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBUb3IgQXJuZSBWZXN0YsO4LgpJbmRl eDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDQ0OTg1KQorKysgV2ViQ29yZS9wYWdlL0V2 ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE4OSw2ICsxODksOCBAQCB2b2lkIEV2 ZW50SGFuZGxlcjo6Y2xlYXIoKQogICAgIG1fZnJhbWVTZXRCZWluZ1Jlc2l6ZWQgPSAwOwogICAg IG1fZHJhZ1RhcmdldCA9IDA7CiAgICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IEludFBvaW50 KCk7CisgICAgbV9jdXJyZW50TW91c2VHbG9iYWxQb3NpdGlvbiA9IEludFBvaW50KCk7CisgICAg bV9yZWNvcmRlZFNjcm9sbFBvc2l0aW9uID0gSW50UG9pbnQoKTsKICAgICBtX21vdXNlUHJlc3NO b2RlID0gMDsKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwogICAgIG1fY2FwdHVyZXNEcmFn Z2luZyA9IGZhbHNlOwpAQCAtMTA2Niw3ICsxMDY4LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlUHJlc3NFdmVudAogCiAgICAgbV9tb3VzZVByZXNzZWQgPSB0cnVlOwogICAgIG1f Y2FwdHVyZXNEcmFnZ2luZyA9IHRydWU7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1v dXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAg ICAgbV9tb3VzZURvd25UaW1lc3RhbXAgPSBtb3VzZUV2ZW50LnRpbWVzdGFtcCgpOwogICAgIG1f bW91c2VEb3duTWF5U3RhcnREcmFnID0gZmFsc2U7CiAgICAgbV9tb3VzZURvd25NYXlTdGFydFNl bGVjdCA9IGZhbHNlOwpAQCAtMTIwMSw3ICsxMjAzLDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlRG91YmxlQ2xpYwogCiAgICAgLy8gV2UgZ2V0IHRoaXMgaW5zdGVhZCBvZiBhIHNl Y29uZCBtb3VzZS11cCAKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwotICAgIG1fY3VycmVu dE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIHVwZGF0ZU1vdXNlUG9zaXRp b25zKG1vdXNlRXZlbnQpOwogCiAgICAgSGl0VGVzdFJlcXVlc3QgcmVxdWVzdChIaXRUZXN0UmVx dWVzdDo6QWN0aXZlKTsKICAgICBNb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRzIG1ldiA9IHBy ZXBhcmVNb3VzZUV2ZW50KHJlcXVlc3QsIG1vdXNlRXZlbnQpOwpAQCAtMTI1Nyw3ICsxMjU5LDcg QEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlTW92ZUV2ZW50KAogICAgICAgICByZXR1 cm4gZmFsc2U7CiAKICAgICBSZWZQdHI8RnJhbWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmll dygpKTsKLSAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91c2VFdmVudC5wb3MoKTsKKyAg ICB1cGRhdGVNb3VzZVBvc2l0aW9ucyhtb3VzZUV2ZW50KTsKIAogICAgIGlmIChtX2hvdmVyVGlt ZXIuaXNBY3RpdmUoKSkKICAgICAgICAgbV9ob3ZlclRpbWVyLnN0b3AoKTsKQEAgLTEzNTgsNyAr MTM2MCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmUKICAgICBS ZWZQdHI8RnJhbWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmlldygpKTsKIAogICAgIG1fbW91 c2VQcmVzc2VkID0gZmFsc2U7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1vdXNlRXZl bnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAKICNpZiBF TkFCTEUoU1ZHKQogICAgIGlmIChtX3N2Z1BhbikgewpAQCAtMTU0NSw2ICsxNTQ3LDEyIEBAIHN0 YXRpYyBpbmxpbmUgU1ZHRWxlbWVudEluc3RhbmNlKiBpbnN0YW4KIH0KICNlbmRpZgogCit2b2lk IEV2ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VQb3NpdGlvbnMoY29uc3QgUGxhdGZvcm1Nb3VzZUV2 ZW50JiBtb3VzZUV2ZW50KQoreworICAgIG1fY3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2 ZW50LnBvcygpOworICAgIG1fY3VycmVudE1vdXNlR2xvYmFsUG9zaXRpb24gPSBtb3VzZUV2ZW50 Lmdsb2JhbFBvcygpOworfQorCiB2b2lkIEV2ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VFdmVudFRh cmdldE5vZGUoTm9kZSogdGFyZ2V0Tm9kZSwgY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3Vz ZUV2ZW50LCBib29sIGZpcmVNb3VzZU92ZXJPdXQpCiB7CiAgICAgTm9kZSogcmVzdWx0ID0gdGFy Z2V0Tm9kZTsKQEAgLTE2NzksNiArMTY4NywxNCBAQCBib29sIEV2ZW50SGFuZGxlcjo6ZGlzcGF0 Y2hNb3VzZUV2ZW50KGNvCiAKIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVlbEV2ZW50KFBs YXRmb3JtV2hlZWxFdmVudCYgZSkKIHsKKyAgICByZWNvcmRTY3JvbGxQb3NpdGlvbigpOworICAg IGNvbnN0IGJvb2wgcmVzdWx0ID0gaGFuZGxlV2hlZWxFdmVudEludGVybmFsKGUpOworICAgIHNp bXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCiti b29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVudEludGVybmFsKFBsYXRmb3JtV2hlZWxF dmVudCYgZSkKK3sKICAgICBEb2N1bWVudCogZG9jID0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKIAog ICAgIFJlbmRlck9iamVjdCogZG9jUmVuZGVyZXIgPSBkb2MtPnJlbmRlcmVyKCk7CkBAIC0xODcz LDYgKzE4ODksMTYgQEAgYm9vbCBFdmVudEhhbmRsZXI6Om5lZWRzS2V5Ym9hcmRFdmVudERpcwog CiBib29sIEV2ZW50SGFuZGxlcjo6a2V5RXZlbnQoY29uc3QgUGxhdGZvcm1LZXlib2FyZEV2ZW50 JiBpbml0aWFsS2V5RXZlbnQpCiB7CisgICAgaWYgKGluaXRpYWxLZXlFdmVudC50eXBlKCkgPT0g UGxhdGZvcm1LZXlib2FyZEV2ZW50OjpLZXlEb3duIHx8IGluaXRpYWxLZXlFdmVudC50eXBlKCkg PT0gUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpSYXdLZXlEb3duKQorICAgICAgICByZWNvcmRTY3Jv bGxQb3NpdGlvbigpOworICAgIGNvbnN0IGJvb2wgcmVzdWx0ID0ga2V5RXZlbnRJbnRlcm5hbChp bml0aWFsS2V5RXZlbnQpOworICAgIGlmIChpbml0aWFsS2V5RXZlbnQudHlwZSgpID09IFBsYXRm b3JtS2V5Ym9hcmRFdmVudDo6S2V5VXApCisgICAgICAgIHNpbXVsYXRlTW91c2VNb3ZlSWZOZWNl c3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitib29sIEV2ZW50SGFuZGxlcjo6a2V5 RXZlbnRJbnRlcm5hbChjb25zdCBQbGF0Zm9ybUtleWJvYXJkRXZlbnQmIGluaXRpYWxLZXlFdmVu dCkKK3sKICNpZiBFTkFCTEUoUEFOX1NDUk9MTElORykKICAgICBpZiAoUGFnZSogcGFnZSA9IG1f ZnJhbWUtPnBhZ2UoKSkgewogICAgICAgICBpZiAocGFnZS0+bWFpbkZyYW1lKCktPmV2ZW50SGFu ZGxlcigpLT5wYW5TY3JvbGxJblByb2dyZXNzKCkgfHwgbV9hdXRvc2Nyb2xsSW5Qcm9ncmVzcykg ewpAQCAtMjM3MSw0ICsyMzk3LDI2IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpwYXNzTW91c2VQcmVz c0V2ZW50VG8KICAgICByZXR1cm4gc2Nyb2xsYmFyLT5tb3VzZURvd24obWV2LmV2ZW50KCkpOwog fQogCit2b2lkIEV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24oKQoreworICAgIEZy YW1lVmlldyogdmlldyA9IG1fZnJhbWUtPnZpZXcoKTsKKyAgICBpZiAoIXZpZXcpCisgICAgICAg IHJldHVybjsKKyAgICBtX3JlY29yZGVkU2Nyb2xsUG9zaXRpb24gPSB2aWV3LT5zY3JvbGxQb3Np dGlvbigpOworfQorCisvLyBTaW11bGF0ZSBhIG1vdXNlIG1vdmUgdG8gdXBkYXRlIGN1cnNvciwg bGluayB0YXJnZXQsIGFuZCBob3ZlciBzdGF0ZS4KK3ZvaWQgRXZlbnRIYW5kbGVyOjpzaW11bGF0 ZU1vdXNlTW92ZUlmTmVjZXNzYXJ5KCkKK3sKKyAgICBpZiAobV9jdXJyZW50TW91c2VQb3NpdGlv bi54KCkgPCAwIHx8IG1fY3VycmVudE1vdXNlUG9zaXRpb24ueSgpIDwgMCkKKyAgICAgICAgcmV0 dXJuOworICAgIEZyYW1lVmlldyogdmlldyA9IG1fZnJhbWUtPnZpZXcoKTsKKyAgICBpZiAoIXZp ZXcpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAobV9yZWNvcmRlZFNjcm9sbFBvc2l0aW9uID09 IHZpZXctPnNjcm9sbFBvc2l0aW9uKCkpCisgICAgICAgIHJldHVybjsKKyAgICBQbGF0Zm9ybU1v dXNlRXZlbnQgc2ltdWxhdGVkRXZlbnQobV9jdXJyZW50TW91c2VQb3NpdGlvbiwgbV9jdXJyZW50 TW91c2VHbG9iYWxQb3NpdGlvbiwgTm9CdXR0b24sIE1vdXNlRXZlbnRNb3ZlZCwgMCwgZmFsc2Us IGZhbHNlLCBmYWxzZSwgZmFsc2UsIDApOworICAgIG1vdXNlTW92ZWQoc2ltdWxhdGVkRXZlbnQp OworfQorCiB9CkluZGV4OiBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5oCShyZXZpc2lvbiA0NDk4NSkKKysrIFdlYkNv cmUvcGFnZS9FdmVudEhhbmRsZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMjAwLDcgKzIwMCwxMCBA QCBwcml2YXRlOgogICAgIGJvb2wgaGFuZGxlTW91c2VSZWxlYXNlRXZlbnQoY29uc3QgTW91c2VF dmVudFdpdGhIaXRUZXN0UmVzdWx0cyYpOwogCiAgICAgdm9pZCBoYW5kbGVLZXlib2FyZFNlbGVj dGlvbk1vdmVtZW50KEtleWJvYXJkRXZlbnQqKTsKLSAgICAKKworICAgIGJvb2wga2V5RXZlbnRJ bnRlcm5hbChjb25zdCBQbGF0Zm9ybUtleWJvYXJkRXZlbnQmKTsKKyAgICBib29sIGhhbmRsZVdo ZWVsRXZlbnRJbnRlcm5hbChQbGF0Zm9ybVdoZWVsRXZlbnQmKTsKKwogICAgIEN1cnNvciBzZWxl Y3RDdXJzb3IoY29uc3QgTW91c2VFdmVudFdpdGhIaXRUZXN0UmVzdWx0cyYsIFNjcm9sbGJhciop OwogI2lmIEVOQUJMRShQQU5fU0NST0xMSU5HKQogICAgIHZvaWQgc2V0UGFuU2Nyb2xsQ3Vyc29y KCk7CkBAIC0yMjAsNiArMjIzLDcgQEAgcHJpdmF0ZToKIAogICAgIE5vZGUqIG5vZGVVbmRlck1v dXNlKCkgY29uc3Q7CiAgICAgCisgICAgdm9pZCB1cGRhdGVNb3VzZVBvc2l0aW9ucyhjb25zdCBQ bGF0Zm9ybU1vdXNlRXZlbnQmIG1vdXNlRXZlbnQpOwogICAgIHZvaWQgdXBkYXRlTW91c2VFdmVu dFRhcmdldE5vZGUoTm9kZSosIGNvbnN0IFBsYXRmb3JtTW91c2VFdmVudCYsIGJvb2wgZmlyZU1v dXNlT3Zlck91dCk7CiAgICAgdm9pZCBmaXJlTW91c2VPdmVyT3V0KGJvb2wgZmlyZU1vdXNlT3Zl ciA9IHRydWUsIGJvb2wgZmlyZU1vdXNlT3V0ID0gdHJ1ZSwgYm9vbCB1cGRhdGVMYXN0Tm9kZVVu ZGVyTW91c2UgPSB0cnVlKTsKICAgICAKQEAgLTI2OSw2ICsyNzMsOSBAQCBwcml2YXRlOgogCiAg ICAgYm9vbCBjYXB0dXJlc0RyYWdnaW5nKCkgY29uc3QgeyByZXR1cm4gbV9jYXB0dXJlc0RyYWdn aW5nOyB9CiAKKyAgICB2b2lkIHJlY29yZFNjcm9sbFBvc2l0aW9uKCk7CisgICAgdm9pZCBzaW11 bGF0ZU1vdXNlTW92ZUlmTmVjZXNzYXJ5KCk7CisKICNpZiBQTEFURk9STShNQUMpICYmIGRlZmlu ZWQoX19PQkpDX18pCiAgICAgTlNWaWV3ICptb3VzZURvd25WaWV3SWZTdGlsbEdvb2QoKTsKIApA QCAtMzI0LDEwICszMzEsMTMgQEAgcHJpdmF0ZToKICAgICBJbnRTaXplIG1fb2Zmc2V0RnJvbVJl c2l6ZUNvcm5lcjsgICAvLyBpbiB0aGUgY29vcmRzIG9mIG1fcmVzaXplTGF5ZXIKICAgICAKICAg ICBJbnRQb2ludCBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uOworICAgIEludFBvaW50IG1fY3VycmVu dE1vdXNlR2xvYmFsUG9zaXRpb247CiAgICAgSW50UG9pbnQgbV9tb3VzZURvd25Qb3M7IC8vIGlu IG91ciB2aWV3J3MgY29vcmRzCiAgICAgZG91YmxlIG1fbW91c2VEb3duVGltZXN0YW1wOwogICAg IFBsYXRmb3JtTW91c2VFdmVudCBtX21vdXNlRG93bjsKIAorICAgIEludFBvaW50IG1fcmVjb3Jk ZWRTY3JvbGxQb3NpdGlvbjsKKwogI2lmIFBMQVRGT1JNKE1BQykKICAgICBOU1ZpZXcgKm1fbW91 c2VEb3duVmlldzsKICAgICBib29sIG1fc2VuZGluZ0V2ZW50VG9TdWJ2aWV3OwpJbmRleDogV2Vi Q29yZS9wbGF0Zm9ybS9QbGF0Zm9ybU1vdXNlRXZlbnQuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL1BsYXRmb3JtTW91c2VFdmVudC5oCShyZXZpc2lvbiA0NDk4NSkKKysrIFdlYkNv cmUvcGxhdGZvcm0vUGxhdGZvcm1Nb3VzZUV2ZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTkwLDYg KzkwLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBjb25zdCBJbnRQb2ludCYgcG9z KCkgY29uc3QgeyByZXR1cm4gbV9wb3NpdGlvbjsgfQogICAgICAgICBpbnQgeCgpIGNvbnN0IHsg cmV0dXJuIG1fcG9zaXRpb24ueCgpOyB9CiAgICAgICAgIGludCB5KCkgY29uc3QgeyByZXR1cm4g bV9wb3NpdGlvbi55KCk7IH0KKyAgICAgICAgY29uc3QgSW50UG9pbnQmIGdsb2JhbFBvcygpIGNv bnN0IHsgcmV0dXJuIG1fZ2xvYmFsUG9zaXRpb247IH0KICAgICAgICAgaW50IGdsb2JhbFgoKSBj b25zdCB7IHJldHVybiBtX2dsb2JhbFBvc2l0aW9uLngoKTsgfQogICAgICAgICBpbnQgZ2xvYmFs WSgpIGNvbnN0IHsgcmV0dXJuIG1fZ2xvYmFsUG9zaXRpb24ueSgpOyB9CiAgICAgICAgIE1vdXNl QnV0dG9uIGJ1dHRvbigpIGNvbnN0IHsgcmV0dXJuIG1fYnV0dG9uOyB9Cg== 32291 2009-07-06 02:49:00 -0700 2009-07-07 18:03:37 -0700 Added rationale. scrollpatch4.txt text/plain 9077 yuzo SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NTA3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzQgQEAKKzIwMDktMDYtMjQgIFl1em8gRnVqaXNoaW1hIDx5dXpvQGdvb2dsZS5j b20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4 IGZvciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTcwNTIKKworICAg ICAgICBUbyB1cGRhdGUgY3Vyc29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlIGR1cmlu ZyBzY3JvbGwgdmlhIG1vdXNlCisgICAgICAgIHdoZWVsIG9yIGtleXMgKHVwL2Rvd24vc3BhY2Up LCBzaW11bGF0ZSBhIG1vdXNlIG1vdmUgZXZlbnQgYWZ0ZXIKKyAgICAgICAgaGFuZGxpbmcgYSB3 aGVlbCBldmVudCBvciBhIGtleSB1cCBldmVudC4KKworICAgICAgICBBZGRpbmcgYSB0ZXN0IGZv ciB0aGlzIGlzIGRpZmZpY3VsdCwgYmVjYXVzZSBpdCBpcyBoYXJkIHRvIHRyYWNrLCBmb3IKKyAg ICAgICAgZXhhbXBsZSwgdGhlIG1vdXNlIGN1cnNvciBzaGFwZSBjaGFuZ2UgZHVyaW5nIHNjcm9s bCBpbml0aWF0ZWQgYnkKKyAgICAgICAgbW91c2Ugd2hlZWwgb3Iga2V5cy4KKworICAgICAgICAq IHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6 Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVByZXNz RXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJs ZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3Vz ZU1vdmVFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNl UmVsZWFzZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6dXBkYXRlTW91 c2VQb3NpdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVl bEV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVu dEludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6a2V5RXZlbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjprZXlFdmVudEludGVybmFsKToKKyAgICAg ICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpzaW11bGF0ZU1vdXNlTW92ZUlmTmVjZXNzYXJ5KToK KyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRm b3JtTW91c2VFdmVudC5oOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1Nb3VzZUV2ZW50Ojpn bG9iYWxQb3MpOgorCiAyMDA5LTA2LTI0ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5u QG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBUb3IgQXJuZSBWZXN0YsO4LgpJbmRl eDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDQ0OTg1KQorKysgV2ViQ29yZS9wYWdlL0V2 ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE4OSw2ICsxODksOCBAQCB2b2lkIEV2 ZW50SGFuZGxlcjo6Y2xlYXIoKQogICAgIG1fZnJhbWVTZXRCZWluZ1Jlc2l6ZWQgPSAwOwogICAg IG1fZHJhZ1RhcmdldCA9IDA7CiAgICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IEludFBvaW50 KCk7CisgICAgbV9jdXJyZW50TW91c2VHbG9iYWxQb3NpdGlvbiA9IEludFBvaW50KCk7CisgICAg bV9yZWNvcmRlZFNjcm9sbFBvc2l0aW9uID0gSW50UG9pbnQoKTsKICAgICBtX21vdXNlUHJlc3NO b2RlID0gMDsKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwogICAgIG1fY2FwdHVyZXNEcmFn Z2luZyA9IGZhbHNlOwpAQCAtMTA2Niw3ICsxMDY4LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlUHJlc3NFdmVudAogCiAgICAgbV9tb3VzZVByZXNzZWQgPSB0cnVlOwogICAgIG1f Y2FwdHVyZXNEcmFnZ2luZyA9IHRydWU7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1v dXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAg ICAgbV9tb3VzZURvd25UaW1lc3RhbXAgPSBtb3VzZUV2ZW50LnRpbWVzdGFtcCgpOwogICAgIG1f bW91c2VEb3duTWF5U3RhcnREcmFnID0gZmFsc2U7CiAgICAgbV9tb3VzZURvd25NYXlTdGFydFNl bGVjdCA9IGZhbHNlOwpAQCAtMTIwMSw3ICsxMjAzLDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlRG91YmxlQ2xpYwogCiAgICAgLy8gV2UgZ2V0IHRoaXMgaW5zdGVhZCBvZiBhIHNl Y29uZCBtb3VzZS11cCAKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwotICAgIG1fY3VycmVu dE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIHVwZGF0ZU1vdXNlUG9zaXRp b25zKG1vdXNlRXZlbnQpOwogCiAgICAgSGl0VGVzdFJlcXVlc3QgcmVxdWVzdChIaXRUZXN0UmVx dWVzdDo6QWN0aXZlKTsKICAgICBNb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRzIG1ldiA9IHBy ZXBhcmVNb3VzZUV2ZW50KHJlcXVlc3QsIG1vdXNlRXZlbnQpOwpAQCAtMTI1Nyw3ICsxMjU5LDcg QEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlTW92ZUV2ZW50KAogICAgICAgICByZXR1 cm4gZmFsc2U7CiAKICAgICBSZWZQdHI8RnJhbWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmll dygpKTsKLSAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91c2VFdmVudC5wb3MoKTsKKyAg ICB1cGRhdGVNb3VzZVBvc2l0aW9ucyhtb3VzZUV2ZW50KTsKIAogICAgIGlmIChtX2hvdmVyVGlt ZXIuaXNBY3RpdmUoKSkKICAgICAgICAgbV9ob3ZlclRpbWVyLnN0b3AoKTsKQEAgLTEzNTgsNyAr MTM2MCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmUKICAgICBS ZWZQdHI8RnJhbWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmlldygpKTsKIAogICAgIG1fbW91 c2VQcmVzc2VkID0gZmFsc2U7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1vdXNlRXZl bnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAKICNpZiBF TkFCTEUoU1ZHKQogICAgIGlmIChtX3N2Z1BhbikgewpAQCAtMTU0NSw2ICsxNTQ3LDEyIEBAIHN0 YXRpYyBpbmxpbmUgU1ZHRWxlbWVudEluc3RhbmNlKiBpbnN0YW4KIH0KICNlbmRpZgogCit2b2lk IEV2ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VQb3NpdGlvbnMoY29uc3QgUGxhdGZvcm1Nb3VzZUV2 ZW50JiBtb3VzZUV2ZW50KQoreworICAgIG1fY3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2 ZW50LnBvcygpOworICAgIG1fY3VycmVudE1vdXNlR2xvYmFsUG9zaXRpb24gPSBtb3VzZUV2ZW50 Lmdsb2JhbFBvcygpOworfQorCiB2b2lkIEV2ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VFdmVudFRh cmdldE5vZGUoTm9kZSogdGFyZ2V0Tm9kZSwgY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3Vz ZUV2ZW50LCBib29sIGZpcmVNb3VzZU92ZXJPdXQpCiB7CiAgICAgTm9kZSogcmVzdWx0ID0gdGFy Z2V0Tm9kZTsKQEAgLTE2NzksNiArMTY4NywxNCBAQCBib29sIEV2ZW50SGFuZGxlcjo6ZGlzcGF0 Y2hNb3VzZUV2ZW50KGNvCiAKIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVlbEV2ZW50KFBs YXRmb3JtV2hlZWxFdmVudCYgZSkKIHsKKyAgICByZWNvcmRTY3JvbGxQb3NpdGlvbigpOworICAg IGNvbnN0IGJvb2wgcmVzdWx0ID0gaGFuZGxlV2hlZWxFdmVudEludGVybmFsKGUpOworICAgIHNp bXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCiti b29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVudEludGVybmFsKFBsYXRmb3JtV2hlZWxF dmVudCYgZSkKK3sKICAgICBEb2N1bWVudCogZG9jID0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKIAog ICAgIFJlbmRlck9iamVjdCogZG9jUmVuZGVyZXIgPSBkb2MtPnJlbmRlcmVyKCk7CkBAIC0xODcz LDYgKzE4ODksMTYgQEAgYm9vbCBFdmVudEhhbmRsZXI6Om5lZWRzS2V5Ym9hcmRFdmVudERpcwog CiBib29sIEV2ZW50SGFuZGxlcjo6a2V5RXZlbnQoY29uc3QgUGxhdGZvcm1LZXlib2FyZEV2ZW50 JiBpbml0aWFsS2V5RXZlbnQpCiB7CisgICAgaWYgKGluaXRpYWxLZXlFdmVudC50eXBlKCkgPT0g UGxhdGZvcm1LZXlib2FyZEV2ZW50OjpLZXlEb3duIHx8IGluaXRpYWxLZXlFdmVudC50eXBlKCkg PT0gUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpSYXdLZXlEb3duKQorICAgICAgICByZWNvcmRTY3Jv bGxQb3NpdGlvbigpOworICAgIGNvbnN0IGJvb2wgcmVzdWx0ID0ga2V5RXZlbnRJbnRlcm5hbChp bml0aWFsS2V5RXZlbnQpOworICAgIGlmIChpbml0aWFsS2V5RXZlbnQudHlwZSgpID09IFBsYXRm b3JtS2V5Ym9hcmRFdmVudDo6S2V5VXApCisgICAgICAgIHNpbXVsYXRlTW91c2VNb3ZlSWZOZWNl c3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitib29sIEV2ZW50SGFuZGxlcjo6a2V5 RXZlbnRJbnRlcm5hbChjb25zdCBQbGF0Zm9ybUtleWJvYXJkRXZlbnQmIGluaXRpYWxLZXlFdmVu dCkKK3sKICNpZiBFTkFCTEUoUEFOX1NDUk9MTElORykKICAgICBpZiAoUGFnZSogcGFnZSA9IG1f ZnJhbWUtPnBhZ2UoKSkgewogICAgICAgICBpZiAocGFnZS0+bWFpbkZyYW1lKCktPmV2ZW50SGFu ZGxlcigpLT5wYW5TY3JvbGxJblByb2dyZXNzKCkgfHwgbV9hdXRvc2Nyb2xsSW5Qcm9ncmVzcykg ewpAQCAtMjM3MSw0ICsyMzk3LDM2IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpwYXNzTW91c2VQcmVz c0V2ZW50VG8KICAgICByZXR1cm4gc2Nyb2xsYmFyLT5tb3VzZURvd24obWV2LmV2ZW50KCkpOwog fQogCit2b2lkIEV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24oKQoreworICAgIEZy YW1lVmlldyogdmlldyA9IG1fZnJhbWUtPnZpZXcoKTsKKyAgICBpZiAoIXZpZXcpCisgICAgICAg IHJldHVybjsKKyAgICBtX3JlY29yZGVkU2Nyb2xsUG9zaXRpb24gPSB2aWV3LT5zY3JvbGxQb3Np dGlvbigpOworfQorCisvLyBTaW11bGF0ZSBhIG1vdXNlbW92ZSBldmVudCB0byB1cGRhdGUgY3Vy c29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlLgordm9pZCBFdmVudEhhbmRsZXI6OnNp bXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKQoreworICAgIC8vIEZvciBXaW5kb3dzIGFuZCBH VEssIHdlIG5lZWQgdG8gc2ltdWxhdGUgYSBtb3VzZW1vdmUgZXZlbnQgYWZ0ZXIgc2Nyb2xsaW5n IGJ5IG1vdXNlIHdoZWVsIG9yIHVwL2Rvd24vc3BhY2Uga2V5LgorICAgIC8vIEZvciBNQUMsIHdl IGRvbid0IG5lZWQgdG8sIGJlY2F1c2UgdGhlIE9TIHNlbmRzIGEgbW91c2Vtb3ZlIGV2ZW50IGFm dGVyIGEgbW91c2V3aGVlbCBldmVudCwgYW5kIGhpZGVzIHRoZSBtb3VzZSBjdXJzb3Igd2hpbGUg c2Nyb2xsaW5nIGJ5IGtleXMuCisgICAgLy8gVE9ETzogRXhhbWluZSBvdGhlciBwbGF0Zm9ybXMu CisgICAgLy8KKyAgICAvLyBTaW11bGF0aW5nIGEgbW91c2Vtb3ZlIGV2ZW50IGhhcyBhIHNpZGUg ZWZmZWN0IHRoYXQgb25tb3VzZW1vdmUgaGFuZGxlciBpcyBpbnZva2VkIHdoZW4gdGhlIG1vdXNl IGRvZXNuJ3QgYWN0dWFsbHkgbW92ZS4KKyAgICAvLyBUaGUgcmF0aW9uYWxlIGJlaGluZCBhY2Nl cHRpbmcgdGhpcyBzaWRlIGVmZmVjdCBpczoKKyAgICAvLyAtIE1BQyBzZW5kcyBhIG1vdXNlbW92 ZSBldmVudCBpbiB0aGlzIGNhc2UgYW55d2F5LCBhbmQgdGhlcmUgc2VlbSB0byBiZSBubyBzdHJv bmcgY29tcGxhaW50cyBhYm91dCBpdC4KKyAgICAvLyAtIFRoZXJlIHNlZW0gdG8gYmUgbm8gb3Ro ZXIgZWFzeSB3YXlzIHRvIGNhdXNlIG1vdXNlb3ZlciBvciBtb3VzZW91dCBldmVudHMgYWZ0ZXIg c2Nyb2xsaW5nLgorI2lmIFBMQVRGT1JNKFdJTikgfHwgUExBVEZPUk0oR1RLKQorICAgIGlmICht X2N1cnJlbnRNb3VzZVBvc2l0aW9uLngoKSA8IDAgfHwgbV9jdXJyZW50TW91c2VQb3NpdGlvbi55 KCkgPCAwKQorICAgICAgICByZXR1cm47CisgICAgRnJhbWVWaWV3KiB2aWV3ID0gbV9mcmFtZS0+ dmlldygpOworICAgIGlmICghdmlldykKKyAgICAgICAgcmV0dXJuOworICAgIGlmIChtX3JlY29y ZGVkU2Nyb2xsUG9zaXRpb24gPT0gdmlldy0+c2Nyb2xsUG9zaXRpb24oKSkKKyAgICAgICAgcmV0 dXJuOworICAgIFBsYXRmb3JtTW91c2VFdmVudCBzaW11bGF0ZWRFdmVudChtX2N1cnJlbnRNb3Vz ZVBvc2l0aW9uLCBtX2N1cnJlbnRNb3VzZUdsb2JhbFBvc2l0aW9uLCBOb0J1dHRvbiwgTW91c2VF dmVudE1vdmVkLCAwLCBmYWxzZSwgZmFsc2UsIGZhbHNlLCBmYWxzZSwgMCk7CisgICAgbW91c2VN b3ZlZChzaW11bGF0ZWRFdmVudCk7CisjZW5kaWYKK30KKwogfQpJbmRleDogV2ViQ29yZS9wYWdl L0V2ZW50SGFuZGxlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu aAkocmV2aXNpb24gNDQ5ODUpCisrKyBXZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmgJKHdvcmtp bmcgY29weSkKQEAgLTIwMCw3ICsyMDAsMTAgQEAgcHJpdmF0ZToKICAgICBib29sIGhhbmRsZU1v dXNlUmVsZWFzZUV2ZW50KGNvbnN0IE1vdXNlRXZlbnRXaXRoSGl0VGVzdFJlc3VsdHMmKTsKIAog ICAgIHZvaWQgaGFuZGxlS2V5Ym9hcmRTZWxlY3Rpb25Nb3ZlbWVudChLZXlib2FyZEV2ZW50Kik7 Ci0gICAgCisKKyAgICBib29sIGtleUV2ZW50SW50ZXJuYWwoY29uc3QgUGxhdGZvcm1LZXlib2Fy ZEV2ZW50Jik7CisgICAgYm9vbCBoYW5kbGVXaGVlbEV2ZW50SW50ZXJuYWwoUGxhdGZvcm1XaGVl bEV2ZW50Jik7CisKICAgICBDdXJzb3Igc2VsZWN0Q3Vyc29yKGNvbnN0IE1vdXNlRXZlbnRXaXRo SGl0VGVzdFJlc3VsdHMmLCBTY3JvbGxiYXIqKTsKICNpZiBFTkFCTEUoUEFOX1NDUk9MTElORykK ICAgICB2b2lkIHNldFBhblNjcm9sbEN1cnNvcigpOwpAQCAtMjIwLDYgKzIyMyw3IEBAIHByaXZh dGU6CiAKICAgICBOb2RlKiBub2RlVW5kZXJNb3VzZSgpIGNvbnN0OwogICAgIAorICAgIHZvaWQg dXBkYXRlTW91c2VQb3NpdGlvbnMoY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3VzZUV2ZW50 KTsKICAgICB2b2lkIHVwZGF0ZU1vdXNlRXZlbnRUYXJnZXROb2RlKE5vZGUqLCBjb25zdCBQbGF0 Zm9ybU1vdXNlRXZlbnQmLCBib29sIGZpcmVNb3VzZU92ZXJPdXQpOwogICAgIHZvaWQgZmlyZU1v dXNlT3Zlck91dChib29sIGZpcmVNb3VzZU92ZXIgPSB0cnVlLCBib29sIGZpcmVNb3VzZU91dCA9 IHRydWUsIGJvb2wgdXBkYXRlTGFzdE5vZGVVbmRlck1vdXNlID0gdHJ1ZSk7CiAgICAgCkBAIC0y NjksNiArMjczLDkgQEAgcHJpdmF0ZToKIAogICAgIGJvb2wgY2FwdHVyZXNEcmFnZ2luZygpIGNv bnN0IHsgcmV0dXJuIG1fY2FwdHVyZXNEcmFnZ2luZzsgfQogCisgICAgdm9pZCByZWNvcmRTY3Jv bGxQb3NpdGlvbigpOworICAgIHZvaWQgc2ltdWxhdGVNb3VzZU1vdmVJZk5lY2Vzc2FyeSgpOwor CiAjaWYgUExBVEZPUk0oTUFDKSAmJiBkZWZpbmVkKF9fT0JKQ19fKQogICAgIE5TVmlldyAqbW91 c2VEb3duVmlld0lmU3RpbGxHb29kKCk7CiAKQEAgLTMyNCwxMCArMzMxLDEzIEBAIHByaXZhdGU6 CiAgICAgSW50U2l6ZSBtX29mZnNldEZyb21SZXNpemVDb3JuZXI7ICAgLy8gaW4gdGhlIGNvb3Jk cyBvZiBtX3Jlc2l6ZUxheWVyCiAgICAgCiAgICAgSW50UG9pbnQgbV9jdXJyZW50TW91c2VQb3Np dGlvbjsKKyAgICBJbnRQb2ludCBtX2N1cnJlbnRNb3VzZUdsb2JhbFBvc2l0aW9uOwogICAgIElu dFBvaW50IG1fbW91c2VEb3duUG9zOyAvLyBpbiBvdXIgdmlldydzIGNvb3JkcwogICAgIGRvdWJs ZSBtX21vdXNlRG93blRpbWVzdGFtcDsKICAgICBQbGF0Zm9ybU1vdXNlRXZlbnQgbV9tb3VzZURv d247CiAKKyAgICBJbnRQb2ludCBtX3JlY29yZGVkU2Nyb2xsUG9zaXRpb247CisKICNpZiBQTEFU Rk9STShNQUMpCiAgICAgTlNWaWV3ICptX21vdXNlRG93blZpZXc7CiAgICAgYm9vbCBtX3NlbmRp bmdFdmVudFRvU3VidmlldzsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1Nb3VzZUV2 ZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybU1vdXNlRXZlbnQu aAkocmV2aXNpb24gNDQ5ODUpCisrKyBXZWJDb3JlL3BsYXRmb3JtL1BsYXRmb3JtTW91c2VFdmVu dC5oCSh3b3JraW5nIGNvcHkpCkBAIC05MCw2ICs5MCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgY29uc3QgSW50UG9pbnQmIHBvcygpIGNvbnN0IHsgcmV0dXJuIG1fcG9zaXRpb247 IH0KICAgICAgICAgaW50IHgoKSBjb25zdCB7IHJldHVybiBtX3Bvc2l0aW9uLngoKTsgfQogICAg ICAgICBpbnQgeSgpIGNvbnN0IHsgcmV0dXJuIG1fcG9zaXRpb24ueSgpOyB9CisgICAgICAgIGNv bnN0IEludFBvaW50JiBnbG9iYWxQb3MoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbFBvc2l0aW9u OyB9CiAgICAgICAgIGludCBnbG9iYWxYKCkgY29uc3QgeyByZXR1cm4gbV9nbG9iYWxQb3NpdGlv bi54KCk7IH0KICAgICAgICAgaW50IGdsb2JhbFkoKSBjb25zdCB7IHJldHVybiBtX2dsb2JhbFBv c2l0aW9uLnkoKTsgfQogICAgICAgICBNb3VzZUJ1dHRvbiBidXR0b24oKSBjb25zdCB7IHJldHVy biBtX2J1dHRvbjsgfQo= 32408 2009-07-07 18:03:37 -0700 2013-04-11 18:18:00 -0700 Add CHROMIUM to the target platform. scrollpatch5.txt text/plain 9099 yuzo SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NTA3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzQgQEAKKzIwMDktMDYtMjQgIFl1em8gRnVqaXNoaW1hIDx5dXpvQGdvb2dsZS5j b20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRml4 IGZvciBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTcwNTIKKworICAg ICAgICBUbyB1cGRhdGUgY3Vyc29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlIGR1cmlu ZyBzY3JvbGwgdmlhIG1vdXNlCisgICAgICAgIHdoZWVsIG9yIGtleXMgKHVwL2Rvd24vc3BhY2Up LCBzaW11bGF0ZSBhIG1vdXNlIG1vdmUgZXZlbnQgYWZ0ZXIKKyAgICAgICAgaGFuZGxpbmcgYSB3 aGVlbCBldmVudCBvciBhIGtleSB1cCBldmVudC4KKworICAgICAgICBBZGRpbmcgYSB0ZXN0IGZv ciB0aGlzIGlzIGRpZmZpY3VsdCwgYmVjYXVzZSBpdCBpcyBoYXJkIHRvIHRyYWNrLCBmb3IKKyAg ICAgICAgZXhhbXBsZSwgdGhlIG1vdXNlIGN1cnNvciBzaGFwZSBjaGFuZ2UgZHVyaW5nIHNjcm9s bCBpbml0aWF0ZWQgYnkKKyAgICAgICAgbW91c2Ugd2hlZWwgb3Iga2V5cy4KKworICAgICAgICAq IHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6 Y2xlYXIpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVByZXNz RXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZURvdWJs ZUNsaWNrRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3Vz ZU1vdmVFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNl UmVsZWFzZUV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6dXBkYXRlTW91 c2VQb3NpdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVl bEV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVu dEludGVybmFsKToKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6a2V5RXZlbnQpOgor ICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjprZXlFdmVudEludGVybmFsKToKKyAgICAg ICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpzaW11bGF0ZU1vdXNlTW92ZUlmTmVjZXNzYXJ5KToK KyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRm b3JtTW91c2VFdmVudC5oOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1Nb3VzZUV2ZW50Ojpn bG9iYWxQb3MpOgorCiAyMDA5LTA2LTI0ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5u QG5va2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBUb3IgQXJuZSBWZXN0YsO4LgpJbmRl eDogV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAJKHJldmlzaW9uIDQ0OTg1KQorKysgV2ViQ29yZS9wYWdlL0V2 ZW50SGFuZGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE4OSw2ICsxODksOCBAQCB2b2lkIEV2 ZW50SGFuZGxlcjo6Y2xlYXIoKQogICAgIG1fZnJhbWVTZXRCZWluZ1Jlc2l6ZWQgPSAwOwogICAg IG1fZHJhZ1RhcmdldCA9IDA7CiAgICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IEludFBvaW50 KCk7CisgICAgbV9jdXJyZW50TW91c2VHbG9iYWxQb3NpdGlvbiA9IEludFBvaW50KCk7CisgICAg bV9yZWNvcmRlZFNjcm9sbFBvc2l0aW9uID0gSW50UG9pbnQoKTsKICAgICBtX21vdXNlUHJlc3NO b2RlID0gMDsKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwogICAgIG1fY2FwdHVyZXNEcmFn Z2luZyA9IGZhbHNlOwpAQCAtMTA2Niw3ICsxMDY4LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlUHJlc3NFdmVudAogCiAgICAgbV9tb3VzZVByZXNzZWQgPSB0cnVlOwogICAgIG1f Y2FwdHVyZXNEcmFnZ2luZyA9IHRydWU7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1v dXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAg ICAgbV9tb3VzZURvd25UaW1lc3RhbXAgPSBtb3VzZUV2ZW50LnRpbWVzdGFtcCgpOwogICAgIG1f bW91c2VEb3duTWF5U3RhcnREcmFnID0gZmFsc2U7CiAgICAgbV9tb3VzZURvd25NYXlTdGFydFNl bGVjdCA9IGZhbHNlOwpAQCAtMTIwMSw3ICsxMjAzLDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6Omhh bmRsZU1vdXNlRG91YmxlQ2xpYwogCiAgICAgLy8gV2UgZ2V0IHRoaXMgaW5zdGVhZCBvZiBhIHNl Y29uZCBtb3VzZS11cCAKICAgICBtX21vdXNlUHJlc3NlZCA9IGZhbHNlOwotICAgIG1fY3VycmVu dE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygpOworICAgIHVwZGF0ZU1vdXNlUG9zaXRp b25zKG1vdXNlRXZlbnQpOwogCiAgICAgSGl0VGVzdFJlcXVlc3QgcmVxdWVzdChIaXRUZXN0UmVx dWVzdDo6QWN0aXZlKTsKICAgICBNb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRzIG1ldiA9IHBy ZXBhcmVNb3VzZUV2ZW50KHJlcXVlc3QsIG1vdXNlRXZlbnQpOwpAQCAtMTI1Nyw3ICsxMjU5LDcg QEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlTW92ZUV2ZW50KAogICAgICAgICByZXR1 cm4gZmFsc2U7CiAKICAgICBSZWZQdHI8RnJhbWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmll dygpKTsKLSAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91c2VFdmVudC5wb3MoKTsKKyAg ICB1cGRhdGVNb3VzZVBvc2l0aW9ucyhtb3VzZUV2ZW50KTsKIAogICAgIGlmIChtX2hvdmVyVGlt ZXIuaXNBY3RpdmUoKSkKICAgICAgICAgbV9ob3ZlclRpbWVyLnN0b3AoKTsKQEAgLTEzNTgsNyAr MTM2MCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmUKICAgICBS ZWZQdHI8RnJhbWVWaWV3PiBwcm90ZWN0b3IobV9mcmFtZS0+dmlldygpKTsKIAogICAgIG1fbW91 c2VQcmVzc2VkID0gZmFsc2U7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1vdXNlRXZl bnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAKICNpZiBF TkFCTEUoU1ZHKQogICAgIGlmIChtX3N2Z1BhbikgewpAQCAtMTU0NSw2ICsxNTQ3LDEyIEBAIHN0 YXRpYyBpbmxpbmUgU1ZHRWxlbWVudEluc3RhbmNlKiBpbnN0YW4KIH0KICNlbmRpZgogCit2b2lk IEV2ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VQb3NpdGlvbnMoY29uc3QgUGxhdGZvcm1Nb3VzZUV2 ZW50JiBtb3VzZUV2ZW50KQoreworICAgIG1fY3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2 ZW50LnBvcygpOworICAgIG1fY3VycmVudE1vdXNlR2xvYmFsUG9zaXRpb24gPSBtb3VzZUV2ZW50 Lmdsb2JhbFBvcygpOworfQorCiB2b2lkIEV2ZW50SGFuZGxlcjo6dXBkYXRlTW91c2VFdmVudFRh cmdldE5vZGUoTm9kZSogdGFyZ2V0Tm9kZSwgY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3Vz ZUV2ZW50LCBib29sIGZpcmVNb3VzZU92ZXJPdXQpCiB7CiAgICAgTm9kZSogcmVzdWx0ID0gdGFy Z2V0Tm9kZTsKQEAgLTE2NzksNiArMTY4NywxNCBAQCBib29sIEV2ZW50SGFuZGxlcjo6ZGlzcGF0 Y2hNb3VzZUV2ZW50KGNvCiAKIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVXaGVlbEV2ZW50KFBs YXRmb3JtV2hlZWxFdmVudCYgZSkKIHsKKyAgICByZWNvcmRTY3JvbGxQb3NpdGlvbigpOworICAg IGNvbnN0IGJvb2wgcmVzdWx0ID0gaGFuZGxlV2hlZWxFdmVudEludGVybmFsKGUpOworICAgIHNp bXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCiti b29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlV2hlZWxFdmVudEludGVybmFsKFBsYXRmb3JtV2hlZWxF dmVudCYgZSkKK3sKICAgICBEb2N1bWVudCogZG9jID0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKIAog ICAgIFJlbmRlck9iamVjdCogZG9jUmVuZGVyZXIgPSBkb2MtPnJlbmRlcmVyKCk7CkBAIC0xODcz LDYgKzE4ODksMTYgQEAgYm9vbCBFdmVudEhhbmRsZXI6Om5lZWRzS2V5Ym9hcmRFdmVudERpcwog CiBib29sIEV2ZW50SGFuZGxlcjo6a2V5RXZlbnQoY29uc3QgUGxhdGZvcm1LZXlib2FyZEV2ZW50 JiBpbml0aWFsS2V5RXZlbnQpCiB7CisgICAgaWYgKGluaXRpYWxLZXlFdmVudC50eXBlKCkgPT0g UGxhdGZvcm1LZXlib2FyZEV2ZW50OjpLZXlEb3duIHx8IGluaXRpYWxLZXlFdmVudC50eXBlKCkg PT0gUGxhdGZvcm1LZXlib2FyZEV2ZW50OjpSYXdLZXlEb3duKQorICAgICAgICByZWNvcmRTY3Jv bGxQb3NpdGlvbigpOworICAgIGNvbnN0IGJvb2wgcmVzdWx0ID0ga2V5RXZlbnRJbnRlcm5hbChp bml0aWFsS2V5RXZlbnQpOworICAgIGlmIChpbml0aWFsS2V5RXZlbnQudHlwZSgpID09IFBsYXRm b3JtS2V5Ym9hcmRFdmVudDo6S2V5VXApCisgICAgICAgIHNpbXVsYXRlTW91c2VNb3ZlSWZOZWNl c3NhcnkoKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCitib29sIEV2ZW50SGFuZGxlcjo6a2V5 RXZlbnRJbnRlcm5hbChjb25zdCBQbGF0Zm9ybUtleWJvYXJkRXZlbnQmIGluaXRpYWxLZXlFdmVu dCkKK3sKICNpZiBFTkFCTEUoUEFOX1NDUk9MTElORykKICAgICBpZiAoUGFnZSogcGFnZSA9IG1f ZnJhbWUtPnBhZ2UoKSkgewogICAgICAgICBpZiAocGFnZS0+bWFpbkZyYW1lKCktPmV2ZW50SGFu ZGxlcigpLT5wYW5TY3JvbGxJblByb2dyZXNzKCkgfHwgbV9hdXRvc2Nyb2xsSW5Qcm9ncmVzcykg ewpAQCAtMjM3MSw0ICsyMzk3LDM2IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpwYXNzTW91c2VQcmVz c0V2ZW50VG8KICAgICByZXR1cm4gc2Nyb2xsYmFyLT5tb3VzZURvd24obWV2LmV2ZW50KCkpOwog fQogCit2b2lkIEV2ZW50SGFuZGxlcjo6cmVjb3JkU2Nyb2xsUG9zaXRpb24oKQoreworICAgIEZy YW1lVmlldyogdmlldyA9IG1fZnJhbWUtPnZpZXcoKTsKKyAgICBpZiAoIXZpZXcpCisgICAgICAg IHJldHVybjsKKyAgICBtX3JlY29yZGVkU2Nyb2xsUG9zaXRpb24gPSB2aWV3LT5zY3JvbGxQb3Np dGlvbigpOworfQorCisvLyBTaW11bGF0ZSBhIG1vdXNlbW92ZSBldmVudCB0byB1cGRhdGUgY3Vy c29yLCBsaW5rIHRhcmdldCwgYW5kIGhvdmVyIHN0YXRlLgordm9pZCBFdmVudEhhbmRsZXI6OnNp bXVsYXRlTW91c2VNb3ZlSWZOZWNlc3NhcnkoKQoreworICAgIC8vIEZvciBXaW5kb3dzIGFuZCBH VEssIHdlIG5lZWQgdG8gc2ltdWxhdGUgYSBtb3VzZW1vdmUgZXZlbnQgYWZ0ZXIgc2Nyb2xsaW5n IGJ5IG1vdXNlIHdoZWVsIG9yIHVwL2Rvd24vc3BhY2Uga2V5LgorICAgIC8vIEZvciBNQUMsIHdl IGRvbid0IG5lZWQgdG8sIGJlY2F1c2UgdGhlIE9TIHNlbmRzIGEgbW91c2Vtb3ZlIGV2ZW50IGFm dGVyIGEgbW91c2V3aGVlbCBldmVudCwgYW5kIGhpZGVzIHRoZSBtb3VzZSBjdXJzb3Igd2hpbGUg c2Nyb2xsaW5nIGJ5IGtleXMuCisgICAgLy8gVE9ETzogRXhhbWluZSBvdGhlciBwbGF0Zm9ybXMu CisgICAgLy8KKyAgICAvLyBTaW11bGF0aW5nIGEgbW91c2Vtb3ZlIGV2ZW50IGhhcyBhIHNpZGUg ZWZmZWN0IHRoYXQgb25tb3VzZW1vdmUgaGFuZGxlciBpcyBpbnZva2VkIHdoZW4gdGhlIG1vdXNl IGRvZXNuJ3QgYWN0dWFsbHkgbW92ZS4KKyAgICAvLyBUaGUgcmF0aW9uYWxlIGJlaGluZCBhY2Nl cHRpbmcgdGhpcyBzaWRlIGVmZmVjdCBpczoKKyAgICAvLyAtIE1BQyBzZW5kcyBhIG1vdXNlbW92 ZSBldmVudCBpbiB0aGlzIGNhc2UgYW55d2F5LCBhbmQgdGhlcmUgc2VlbSB0byBiZSBubyBzdHJv bmcgY29tcGxhaW50cyBhYm91dCBpdC4KKyAgICAvLyAtIFRoZXJlIHNlZW0gdG8gYmUgbm8gb3Ro ZXIgZWFzeSB3YXlzIHRvIGNhdXNlIG1vdXNlb3ZlciBvciBtb3VzZW91dCBldmVudHMgYWZ0ZXIg c2Nyb2xsaW5nLgorI2lmIFBMQVRGT1JNKFdJTikgfHwgUExBVEZPUk0oR1RLKSB8fCBQTEFURk9S TShDSFJPTUlVTSkKKyAgICBpZiAobV9jdXJyZW50TW91c2VQb3NpdGlvbi54KCkgPCAwIHx8IG1f Y3VycmVudE1vdXNlUG9zaXRpb24ueSgpIDwgMCkKKyAgICAgICAgcmV0dXJuOworICAgIEZyYW1l VmlldyogdmlldyA9IG1fZnJhbWUtPnZpZXcoKTsKKyAgICBpZiAoIXZpZXcpCisgICAgICAgIHJl dHVybjsKKyAgICBpZiAobV9yZWNvcmRlZFNjcm9sbFBvc2l0aW9uID09IHZpZXctPnNjcm9sbFBv c2l0aW9uKCkpCisgICAgICAgIHJldHVybjsKKyAgICBQbGF0Zm9ybU1vdXNlRXZlbnQgc2ltdWxh dGVkRXZlbnQobV9jdXJyZW50TW91c2VQb3NpdGlvbiwgbV9jdXJyZW50TW91c2VHbG9iYWxQb3Np dGlvbiwgTm9CdXR0b24sIE1vdXNlRXZlbnRNb3ZlZCwgMCwgZmFsc2UsIGZhbHNlLCBmYWxzZSwg ZmFsc2UsIDApOworICAgIG1vdXNlTW92ZWQoc2ltdWxhdGVkRXZlbnQpOworI2VuZGlmCit9CisK IH0KSW5kZXg6IFdlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmgJKHJldmlzaW9uIDQ0OTg1KQorKysgV2ViQ29yZS9wYWdl L0V2ZW50SGFuZGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMDAsNyArMjAwLDEwIEBAIHByaXZh dGU6CiAgICAgYm9vbCBoYW5kbGVNb3VzZVJlbGVhc2VFdmVudChjb25zdCBNb3VzZUV2ZW50V2l0 aEhpdFRlc3RSZXN1bHRzJik7CiAKICAgICB2b2lkIGhhbmRsZUtleWJvYXJkU2VsZWN0aW9uTW92 ZW1lbnQoS2V5Ym9hcmRFdmVudCopOwotICAgIAorCisgICAgYm9vbCBrZXlFdmVudEludGVybmFs KGNvbnN0IFBsYXRmb3JtS2V5Ym9hcmRFdmVudCYpOworICAgIGJvb2wgaGFuZGxlV2hlZWxFdmVu dEludGVybmFsKFBsYXRmb3JtV2hlZWxFdmVudCYpOworCiAgICAgQ3Vyc29yIHNlbGVjdEN1cnNv cihjb25zdCBNb3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRzJiwgU2Nyb2xsYmFyKik7CiAjaWYg RU5BQkxFKFBBTl9TQ1JPTExJTkcpCiAgICAgdm9pZCBzZXRQYW5TY3JvbGxDdXJzb3IoKTsKQEAg LTIyMCw2ICsyMjMsNyBAQCBwcml2YXRlOgogCiAgICAgTm9kZSogbm9kZVVuZGVyTW91c2UoKSBj b25zdDsKICAgICAKKyAgICB2b2lkIHVwZGF0ZU1vdXNlUG9zaXRpb25zKGNvbnN0IFBsYXRmb3Jt TW91c2VFdmVudCYgbW91c2VFdmVudCk7CiAgICAgdm9pZCB1cGRhdGVNb3VzZUV2ZW50VGFyZ2V0 Tm9kZShOb2RlKiwgY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiwgYm9vbCBmaXJlTW91c2VPdmVy T3V0KTsKICAgICB2b2lkIGZpcmVNb3VzZU92ZXJPdXQoYm9vbCBmaXJlTW91c2VPdmVyID0gdHJ1 ZSwgYm9vbCBmaXJlTW91c2VPdXQgPSB0cnVlLCBib29sIHVwZGF0ZUxhc3ROb2RlVW5kZXJNb3Vz ZSA9IHRydWUpOwogICAgIApAQCAtMjY5LDYgKzI3Myw5IEBAIHByaXZhdGU6CiAKICAgICBib29s IGNhcHR1cmVzRHJhZ2dpbmcoKSBjb25zdCB7IHJldHVybiBtX2NhcHR1cmVzRHJhZ2dpbmc7IH0K IAorICAgIHZvaWQgcmVjb3JkU2Nyb2xsUG9zaXRpb24oKTsKKyAgICB2b2lkIHNpbXVsYXRlTW91 c2VNb3ZlSWZOZWNlc3NhcnkoKTsKKwogI2lmIFBMQVRGT1JNKE1BQykgJiYgZGVmaW5lZChfX09C SkNfXykKICAgICBOU1ZpZXcgKm1vdXNlRG93blZpZXdJZlN0aWxsR29vZCgpOwogCkBAIC0zMjQs MTAgKzMzMSwxMyBAQCBwcml2YXRlOgogICAgIEludFNpemUgbV9vZmZzZXRGcm9tUmVzaXplQ29y bmVyOyAgIC8vIGluIHRoZSBjb29yZHMgb2YgbV9yZXNpemVMYXllcgogICAgIAogICAgIEludFBv aW50IG1fY3VycmVudE1vdXNlUG9zaXRpb247CisgICAgSW50UG9pbnQgbV9jdXJyZW50TW91c2VH bG9iYWxQb3NpdGlvbjsKICAgICBJbnRQb2ludCBtX21vdXNlRG93blBvczsgLy8gaW4gb3VyIHZp ZXcncyBjb29yZHMKICAgICBkb3VibGUgbV9tb3VzZURvd25UaW1lc3RhbXA7CiAgICAgUGxhdGZv cm1Nb3VzZUV2ZW50IG1fbW91c2VEb3duOwogCisgICAgSW50UG9pbnQgbV9yZWNvcmRlZFNjcm9s bFBvc2l0aW9uOworCiAjaWYgUExBVEZPUk0oTUFDKQogICAgIE5TVmlldyAqbV9tb3VzZURvd25W aWV3OwogICAgIGJvb2wgbV9zZW5kaW5nRXZlbnRUb1N1YnZpZXc7CkluZGV4OiBXZWJDb3JlL3Bs YXRmb3JtL1BsYXRmb3JtTW91c2VFdmVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZv cm0vUGxhdGZvcm1Nb3VzZUV2ZW50LmgJKHJldmlzaW9uIDQ0OTg1KQorKysgV2ViQ29yZS9wbGF0 Zm9ybS9QbGF0Zm9ybU1vdXNlRXZlbnQuaAkod29ya2luZyBjb3B5KQpAQCAtOTAsNiArOTAsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIGNvbnN0IEludFBvaW50JiBwb3MoKSBjb25z dCB7IHJldHVybiBtX3Bvc2l0aW9uOyB9CiAgICAgICAgIGludCB4KCkgY29uc3QgeyByZXR1cm4g bV9wb3NpdGlvbi54KCk7IH0KICAgICAgICAgaW50IHkoKSBjb25zdCB7IHJldHVybiBtX3Bvc2l0 aW9uLnkoKTsgfQorICAgICAgICBjb25zdCBJbnRQb2ludCYgZ2xvYmFsUG9zKCkgY29uc3QgeyBy ZXR1cm4gbV9nbG9iYWxQb3NpdGlvbjsgfQogICAgICAgICBpbnQgZ2xvYmFsWCgpIGNvbnN0IHsg cmV0dXJuIG1fZ2xvYmFsUG9zaXRpb24ueCgpOyB9CiAgICAgICAgIGludCBnbG9iYWxZKCkgY29u c3QgeyByZXR1cm4gbV9nbG9iYWxQb3NpdGlvbi55KCk7IH0KICAgICAgICAgTW91c2VCdXR0b24g YnV0dG9uKCkgY29uc3QgeyByZXR1cm4gbV9idXR0b247IH0K 34540 2009-08-10 22:26:12 -0700 2009-08-10 22:26:12 -0700 Quick and dirty patch, as per my comments. patch-17052-qandd-1.txt text/plain 4869 viettrungluu SW5kZXg6IEZyYW1lVmlldy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gRnJhbWVWaWV3LmNwcAkocmV2aXNp b24gNDY5MTApCisrKyBGcmFtZVZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMzU0LDggKzEz NTQsMTAgQEAKICAgICAvLyBGaWd1cmUgb3V0IGlmIHdlIHJlYWxseSBtb3ZlZC4KICAgICBJbnRT aXplIG9mZnNldCA9IHNjcm9sbE9mZnNldCgpOwogICAgIFNjcm9sbFZpZXc6OnZhbHVlQ2hhbmdl ZChiYXIpOwotICAgIGlmIChvZmZzZXQgIT0gc2Nyb2xsT2Zmc2V0KCkpCisgICAgaWYgKG9mZnNl dCAhPSBzY3JvbGxPZmZzZXQoKSkgewogICAgICAgICBmcmFtZSgpLT5ldmVudEhhbmRsZXIoKS0+ c2VuZFNjcm9sbEV2ZW50KCk7CisgICAgICAgIGZyYW1lKCktPmV2ZW50SGFuZGxlcigpLT5tb3Vz ZU1vdmVkVmlydHVhbGx5KCk7CisgICAgfQogfQogCiB2b2lkIEZyYW1lVmlldzo6aW52YWxpZGF0 ZVNjcm9sbGJhclJlY3QoU2Nyb2xsYmFyKiBzY3JvbGxiYXIsIGNvbnN0IEludFJlY3QmIHJlY3Qp CkluZGV4OiBFdmVudEhhbmRsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBFdmVudEhhbmRsZXIuaAkocmV2 aXNpb24gNDY5MTApCisrKyBFdmVudEhhbmRsZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMTIxLDYg KzEyMSw3IEBACiAgICAgYm9vbCBtb3VzZURvd25NYXlTdGFydFNlbGVjdCgpIGNvbnN0IHsgcmV0 dXJuIG1fbW91c2VEb3duTWF5U3RhcnRTZWxlY3Q7IH0KIAogICAgIGJvb2wgbW91c2VNb3ZlZChj b25zdCBQbGF0Zm9ybU1vdXNlRXZlbnQmKTsKKyAgICBib29sIG1vdXNlTW92ZWRWaXJ0dWFsbHko KTsKIAogICAgIGJvb2wgaGFuZGxlTW91c2VQcmVzc0V2ZW50KGNvbnN0IFBsYXRmb3JtTW91c2VF dmVudCYpOwogICAgIGJvb2wgaGFuZGxlTW91c2VNb3ZlRXZlbnQoY29uc3QgUGxhdGZvcm1Nb3Vz ZUV2ZW50JiwgSGl0VGVzdFJlc3VsdCogaG92ZXJlZE5vZGUgPSAwKTsKQEAgLTIyMyw3ICsyMjQs OCBAQAogICAgIHZvaWQgaW52YWxpZGF0ZUNsaWNrKCk7CiAKICAgICBOb2RlKiBub2RlVW5kZXJN b3VzZSgpIGNvbnN0OwotICAgIAorCisgICAgdm9pZCB1cGRhdGVNb3VzZVBvc2l0aW9ucyhjb25z dCBQbGF0Zm9ybU1vdXNlRXZlbnQmKTsKICAgICB2b2lkIHVwZGF0ZU1vdXNlRXZlbnRUYXJnZXRO b2RlKE5vZGUqLCBjb25zdCBQbGF0Zm9ybU1vdXNlRXZlbnQmLCBib29sIGZpcmVNb3VzZU92ZXJP dXQpOwogICAgIHZvaWQgZmlyZU1vdXNlT3Zlck91dChib29sIGZpcmVNb3VzZU92ZXIgPSB0cnVl LCBib29sIGZpcmVNb3VzZU91dCA9IHRydWUsIGJvb2wgdXBkYXRlTGFzdE5vZGVVbmRlck1vdXNl ID0gdHJ1ZSk7CiAgICAgCkBAIC0zMzMsNiArMzM1LDcgQEAKICAgICBJbnRTaXplIG1fb2Zmc2V0 RnJvbVJlc2l6ZUNvcm5lcjsgICAvLyBpbiB0aGUgY29vcmRzIG9mIG1fcmVzaXplTGF5ZXIKICAg ICAKICAgICBJbnRQb2ludCBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uOworICAgIEludFBvaW50IG1f Y3VycmVudE1vdXNlR2xvYmFsUG9zaXRpb247CiAgICAgSW50UG9pbnQgbV9tb3VzZURvd25Qb3M7 IC8vIGluIG91ciB2aWV3J3MgY29vcmRzCiAgICAgZG91YmxlIG1fbW91c2VEb3duVGltZXN0YW1w OwogICAgIFBsYXRmb3JtTW91c2VFdmVudCBtX21vdXNlRG93bjsKSW5kZXg6IEV2ZW50SGFuZGxl ci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gRXZlbnRIYW5kbGVyLmNwcAkocmV2aXNpb24gNDY5MTApCisr KyBFdmVudEhhbmRsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xOTMsNiArMTkzLDcgQEAKICAg ICBtX2ZyYW1lU2V0QmVpbmdSZXNpemVkID0gMDsKICAgICBtX2RyYWdUYXJnZXQgPSAwOwogICAg IG1fY3VycmVudE1vdXNlUG9zaXRpb24gPSBJbnRQb2ludCgpOworICAgIG1fY3VycmVudE1vdXNl R2xvYmFsUG9zaXRpb24gPSBJbnRQb2ludCgpOwogICAgIG1fbW91c2VQcmVzc05vZGUgPSAwOwog ICAgIG1fbW91c2VQcmVzc2VkID0gZmFsc2U7CiAgICAgbV9jYXB0dXJlc0RyYWdnaW5nID0gZmFs c2U7CkBAIC0xMTAzLDcgKzExMDQsNyBAQAogCiAgICAgbV9tb3VzZVByZXNzZWQgPSB0cnVlOwog ICAgIG1fY2FwdHVyZXNEcmFnZ2luZyA9IHRydWU7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlv biA9IG1vdXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVu dCk7CiAgICAgbV9tb3VzZURvd25UaW1lc3RhbXAgPSBtb3VzZUV2ZW50LnRpbWVzdGFtcCgpOwog ICAgIG1fbW91c2VEb3duTWF5U3RhcnREcmFnID0gZmFsc2U7CiAgICAgbV9tb3VzZURvd25NYXlT dGFydFNlbGVjdCA9IGZhbHNlOwpAQCAtMTI0Niw3ICsxMjQ3LDcgQEAKIAogICAgIC8vIFdlIGdl dCB0aGlzIGluc3RlYWQgb2YgYSBzZWNvbmQgbW91c2UtdXAgCiAgICAgbV9tb3VzZVByZXNzZWQg PSBmYWxzZTsKLSAgICBtX2N1cnJlbnRNb3VzZVBvc2l0aW9uID0gbW91c2VFdmVudC5wb3MoKTsK KyAgICB1cGRhdGVNb3VzZVBvc2l0aW9ucyhtb3VzZUV2ZW50KTsKIAogICAgIEhpdFRlc3RSZXF1 ZXN0IHJlcXVlc3QoSGl0VGVzdFJlcXVlc3Q6OkFjdGl2ZSk7CiAgICAgTW91c2VFdmVudFdpdGhI aXRUZXN0UmVzdWx0cyBtZXYgPSBwcmVwYXJlTW91c2VFdmVudChyZXF1ZXN0LCBtb3VzZUV2ZW50 KTsKQEAgLTEyOTEsNiArMTI5MiwyNSBAQAogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKKy8vIENh bGwgdGhpcyBhZnRlciAiZXZlbnRzIiAoc2Nyb2xsaW5nLCByZXNpemluZywgd2luZG93IG1vdmlu ZywgbWlzYy4gbGF5b3V0cykKKy8vIHdoaWNoIGNhdXNlIHRoZSBtb3VzZSB0byBtb3ZlIHJlbGF0 aXZlIHRvIGFueSBlbGVtZW50cy4KKy8vIEZJWE1FKHZpZXR0cnVuZ2x1dUBnbWFpbC5jb20pOiBj dXJyZW50bHkgb25seSBzZXQgdXAgZm9yIHNjcm9sbGluZzsgY3VycmVudGx5CisvLyBqdXN0IHNl bmRzIGEgZmFrZSBtb3VzZSBtb3ZlIGV2ZW50LgorLy8gVE9ETyh2aWV0dHJ1bmdsdXVAZ21haWwu Y29tKTogZGVjb3VwbGUgdGhlIG1vdXNlIG1vdmUgY29kZSBzbyB0aGF0IHRoZSBmYWtlCisvLyBt b3VzZSBtb3ZlIGV2ZW50IGlzbid0IG5lZWRlZC4KK2Jvb2wgRXZlbnRIYW5kbGVyOjptb3VzZU1v dmVkVmlydHVhbGx5KCkKK3sKKyAgICBNb3VzZUJ1dHRvbiBjdXJyQnV0dG9uID0gbV9tb3VzZVBy ZXNzZWQgPyBtX21vdXNlRG93bi5idXR0b24oKSA6IE5vQnV0dG9uOworICAgIGludCBjdXJyQ2xp Y2tDb3VudCA9IG1fbW91c2VQcmVzc2VkID8gbV9tb3VzZURvd24uY2xpY2tDb3VudCgpIDogMDsK KyAgICAvLyBXZSBoYXZlIG5vIHBhcnRpY3VsYXIgcmVhc29uIHRvIGJlbGlldmUgdGhhdCB0aGUg c3RhdGVzIG9mCisgICAgLy8gc2hpZnQvY3RybC9hbHQvbWV0YSBhcmUgY3VycmVudCwgZXZlbiBp ZiB0aGUgbW91c2UgaXMgcHJlc3NlZC4KKworICAgIFBsYXRmb3JtTW91c2VFdmVudCBmYWtlRXZl bnQobV9jdXJyZW50TW91c2VQb3NpdGlvbiwKKyAgICAgICAgICAgIG1fY3VycmVudE1vdXNlR2xv YmFsUG9zaXRpb24sIGN1cnJCdXR0b24sIE1vdXNlRXZlbnRNb3ZlZCwKKyAgICAgICAgICAgIGN1 cnJDbGlja0NvdW50LCBmYWxzZSwgZmFsc2UsIGZhbHNlLCBmYWxzZSwgMC4wKTsKKyAgICByZXR1 cm4gbW91c2VNb3ZlZChmYWtlRXZlbnQpOworfQorCiBib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxl TW91c2VNb3ZlRXZlbnQoY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3VzZUV2ZW50LCBIaXRU ZXN0UmVzdWx0KiBob3ZlcmVkTm9kZSkKIHsKICAgICAvLyBpbiBSYWRhciAzNzAzNzY4IHdlIHNh dyBmcmVxdWVudCBjcmFzaGVzIGFwcGFyZW50bHkgZHVlIHRvIHRoZQpAQCAtMTMwMiw3ICsxMzIy LDcgQEAKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgUmVmUHRyPEZyYW1lVmlldz4gcHJv dGVjdG9yKG1fZnJhbWUtPnZpZXcoKSk7Ci0gICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9IG1v dXNlRXZlbnQucG9zKCk7CisgICAgdXBkYXRlTW91c2VQb3NpdGlvbnMobW91c2VFdmVudCk7CiAK ICAgICBpZiAobV9ob3ZlclRpbWVyLmlzQWN0aXZlKCkpCiAgICAgICAgIG1faG92ZXJUaW1lci5z dG9wKCk7CkBAIC0xNDA1LDcgKzE0MjUsNyBAQAogI2VuZGlmCiAKICAgICBtX21vdXNlUHJlc3Nl ZCA9IGZhbHNlOwotICAgIG1fY3VycmVudE1vdXNlUG9zaXRpb24gPSBtb3VzZUV2ZW50LnBvcygp OworICAgIHVwZGF0ZU1vdXNlUG9zaXRpb25zKG1vdXNlRXZlbnQpOwogCiAjaWYgRU5BQkxFKFNW RykKICAgICBpZiAobV9zdmdQYW4pIHsKQEAgLTE1OTIsNiArMTYxMiwxMyBAQAogfQogI2VuZGlm CiAKK3ZvaWQgRXZlbnRIYW5kbGVyOjp1cGRhdGVNb3VzZVBvc2l0aW9ucyhjb25zdCBQbGF0Zm9y bU1vdXNlRXZlbnQmIG1vdXNlRXZlbnQpCit7CisgICAgbV9jdXJyZW50TW91c2VQb3NpdGlvbiA9 IG1vdXNlRXZlbnQucG9zKCk7CisgICAgbV9jdXJyZW50TW91c2VHbG9iYWxQb3NpdGlvbi5zZXRY KG1vdXNlRXZlbnQuZ2xvYmFsWCgpKTsKKyAgICBtX2N1cnJlbnRNb3VzZUdsb2JhbFBvc2l0aW9u LnNldFkobW91c2VFdmVudC5nbG9iYWxZKCkpOworfQorCiB2b2lkIEV2ZW50SGFuZGxlcjo6dXBk YXRlTW91c2VFdmVudFRhcmdldE5vZGUoTm9kZSogdGFyZ2V0Tm9kZSwgY29uc3QgUGxhdGZvcm1N b3VzZUV2ZW50JiBtb3VzZUV2ZW50LCBib29sIGZpcmVNb3VzZU92ZXJPdXQpCiB7CiAgICAgTm9k ZSogcmVzdWx0ID0gdGFyZ2V0Tm9kZTsK