158531 2016-06-08 10:51:16 -0700 [GTK] WebKit2GTK+ does not handle touchmove and touchend events correctly 2017-10-04 10:33:32 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Local Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 andrunko aperez aperez beidson berto bugs-noreply carlosg cgarcia clopez commit-queue darin gustavo mcatanzaro mrobinson oldest_to_newest 1200497 0 andrunko 2016-06-08 10:51:16 -0700 - Open with whatever version of WebKit2GTK+ https://patrickhlauke.github.io/touch/tests/event-listener.html - Touch the "Test button!" and move the finger while touching - touchstart is received correctly - no touchmove nor touchend event is received The same page works fine in Chrome. 1200504 1 280816 andrunko 2016-06-08 11:10:49 -0700 Created attachment 280816 Patch 1200506 2 commit-queue 2016-06-08 11:12:12 -0700 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 1200507 3 andrunko 2016-06-08 11:13:02 -0700 (In reply to comment #1) > Created attachment 280816 [details] > Patch With this patch it should work the same as Google Chrome. touchupdate/end events are always received by the page even when the page doesnt not handle (prevent) the touchbegin event. 1200744 4 280816 cgarcia 2016-06-08 23:47:15 -0700 Comment on attachment 280816 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=280816&action=review Thanks for the patch! Have you run the layout tests? Does this fix any test previously failing? I'm not an expert on touch events, so I'll leave that part to Carlos Garnacho, and I'll just do a more general review. > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:339 > + // Ignored attempt to cancel an END touch event while a BEGIN touch event was processed > + // by the gesture controller (wasn't handled by WebProcess), for example because > + // scrolling is in progress and cannot be interrupted. I'm not sure I understand this comment. I think the idea is that we want to pass END touch events to the gesture controller even when the web process handled the event, right? And here we are checking if this is an END handled by the web process while the BEGIN was not handled, right? How do we know that BEGIN was not handled by the web process? > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:341 > + if (gestureController.handleEvent(event.nativeEvent())) > + return; Don't we need to also remove the sequence id from the touch event list? > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:346 > + } else > + return; > +#else > return; > +#endif I think this could be simplified, if we remove the #else, then we don't need the } else and we avoid the double return there. > Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:350 > #if HAVE(GTK_GESTURES) > GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget)); And here again we handle the event when not handled by the web process. What about something like this? #if HAVE(GTK_GESTURES) GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget)); if (!wasEventHandled || (touchEvent->type == GDK_TOUCH_END && gestureController.isProcessingGestures())) wasEventHandled = gestureController.handleEvent(touchEvent); #endif if (wasEventHandled) return; > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:-995 > - // If we are already processing gestures is because the WebProcess didn't handle the > - // BEGIN touch event, so pass subsequent events to the GestureController. oh, I guess this comment answers one of my questions above, let's not lose this useful comment then :-) > Source/WebKit2/UIProcess/gtk/GestureController.cpp:51 > + // Received touchupdate/end without touchbegin, ignore events Nit: Comments should finish with period. > Source/WebKit2/UIProcess/gtk/GestureController.cpp:54 > + gtk_event_controller_reset(GTK_EVENT_CONTROLLER(m_dragGesture.gesture())); > + gtk_event_controller_reset(GTK_EVENT_CONTROLLER(m_zoomGesture.gesture())); Instead of exposing the internal gesture, i think this would look better if we add a reset() method to Gesture class, so this would be just: m_dragGesture.reset(); m_zoomGesture.reset(); 1200866 5 280816 andrunko 2016-06-09 09:56:59 -0700 Comment on attachment 280816 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=280816&action=review >> Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:339 >> + // scrolling is in progress and cannot be interrupted. > > I'm not sure I understand this comment. I think the idea is that we want to pass END touch events to the gesture controller even when the web process handled the event, right? And here we are checking if this is an END handled by the web process while the BEGIN was not handled, right? How do we know that BEGIN was not handled by the web process? What happens here is that we always want to pass the touchend event to the gesture controller if touchbegin ever got to it. This is for example to avoid starting handling a gesture (touchbegin - e.g. scroll in progress) and not receiving a touchend. Note that I got this comment from google-chrome (this comment is spit out on console.log if the user tries to prevent touchend (ev.preventDefault()) but didnt prevent touchbegin. The conditional (if gestureController.isProcessingGestures) is only true if touchbegin reached the gesture controller. >> Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:341 >> + return; > > Don't we need to also remove the sequence id from the touch event list? No, because the sequence id is now always removed in WebViewBase touchEvent handler (when receiving touchend) The sequence is now: WebViewBase receives the event (adds/remove from touch event list accordingly) -> PageProxy -> WebProcess -> PageClientImpl -> GestureController (it may not get here depending whether the event was handled by the page or not). >> Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:346 >> +#endif > > I think this could be simplified, if we remove the #else, then we don't need the } else and we avoid the double return there. Will update it. >> Source/WebKit2/UIProcess/API/gtk/PageClientImpl.cpp:350 >> GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget)); > > And here again we handle the event when not handled by the web process. What about something like this? > > #if HAVE(GTK_GESTURES) > GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget)); > if (!wasEventHandled || (touchEvent->type == GDK_TOUCH_END && gestureController.isProcessingGestures())) > wasEventHandled = gestureController.handleEvent(touchEvent); > #endif > > if (wasEventHandled) > return; I will check this one. >> Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp:-995 >> - // BEGIN touch event, so pass subsequent events to the GestureController. > > oh, I guess this comment answers one of my questions above, let's not lose this useful comment then :-) Yep, I will move this comment to PageClientImpl instead. >> Source/WebKit2/UIProcess/gtk/GestureController.cpp:51 >> + // Received touchupdate/end without touchbegin, ignore events > > Nit: Comments should finish with period. Will update :). >> Source/WebKit2/UIProcess/gtk/GestureController.cpp:54 >> + gtk_event_controller_reset(GTK_EVENT_CONTROLLER(m_zoomGesture.gesture())); > > Instead of exposing the internal gesture, i think this would look better if we add a reset() method to Gesture class, so this would be just: > > m_dragGesture.reset(); > m_zoomGesture.reset(); Good idea, I thought about it but the code was already there and I left it as it was :). I will update. 1201882 6 280816 carlosg 2016-06-13 10:54:20 -0700 Comment on attachment 280816 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=280816&action=review > Source/WebKit2/UIProcess/gtk/GestureController.cpp:58 > + // Received touchbegin while still processing another touch sequence, cancel previous sequence > + if (wasProcessingGestures && event->type == GDK_TOUCH_BEGIN) { This code branch concerns me somewhat (and it feels pretty central to this approach afaics :( ). If I'm reading the current code and your patch correctly, this will just reset gestures if a second/further touch is received, which sounds undesirable for the zoom gesture. It is worth pointing out that there's no right check that we can do here to prevent this case, there's basically no valid assumptions about what the next GdkEventSequence might be. Also, I find this a bit backwards. If we let webpages capture random events from an specific touchpoint event stream, we'll be potentially left with an inconsistent state in the GestureController until a next TOUCH_BEGIN event is received, which might be much later, or just never. 1201889 7 281183 andrunko 2016-06-13 11:33:35 -0700 Created attachment 281183 Patch 1201890 8 andrunko 2016-06-13 11:34:15 -0700 (In reply to comment #7) > Created attachment 281183 [details] > Patch This new patch should address Carlos Garcia suggestions. 1201891 9 andrunko 2016-06-13 11:43:25 -0700 (In reply to comment #6) > Comment on attachment 280816 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=280816&action=review > > > Source/WebKit2/UIProcess/gtk/GestureController.cpp:58 > > + // Received touchbegin while still processing another touch sequence, cancel previous sequence > > + if (wasProcessingGestures && event->type == GDK_TOUCH_BEGIN) { > > This code branch concerns me somewhat (and it feels pretty central to this > approach afaics :( ). > > If I'm reading the current code and your patch correctly, this will just > reset gestures if a second/further touch is received, which sounds > undesirable for the zoom gesture. It is worth pointing out that there's no > right check that we can do here to prevent this case, there's basically no > valid assumptions about what the next GdkEventSequence might be. > As for resetting the gestures, there are 2 cases here: - 1: the gesture controller did not receive a BEGIN touch event (handled by webprocess/page - gesture controller was not processing events) and we ignore any new touch event (UPDATE/END) - 2: the gesture controller received a BEGIN touch event but did not receive a END touch event (e.g. gesture controller received BEGIN and then another BEGIN event) > Also, I find this a bit backwards. If we let webpages capture random events > from an specific touchpoint event stream, we'll be potentially left with an > inconsistent state in the GestureController until a next TOUCH_BEGIN event > is received, which might be much later, or just never. The idea here is actually to not leave the gesture controller in a inconsistent state. We reset the gestures if we get into an inconsistent state as described above. From what I see, with these changes the gesture controller will never be in a inconsitent state. From what I see we have the following options: - The webpage prevents touch BEGIN - in this case the gesture controller will not receive any touch event. - the webpage do not prevent touch BEGIN but prevents touch UPDATE - in this case the gesture controller will not receive UPDATE events, but will receive the END event - the webpage cannot prevent a END touch event if it did not prevent a BEGIN touch event - END touch events always reach the gesture controller if a BEGIN touch event was received by it Please let me know if I am missing something. 1201921 10 carlosg 2016-06-13 12:57:38 -0700 (In reply to comment #9) > (In reply to comment #6) > > Comment on attachment 280816 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=280816&action=review > > > > > Source/WebKit2/UIProcess/gtk/GestureController.cpp:58 > > > + // Received touchbegin while still processing another touch sequence, cancel previous sequence > > > + if (wasProcessingGestures && event->type == GDK_TOUCH_BEGIN) { > > > > This code branch concerns me somewhat (and it feels pretty central to this > > approach afaics :( ). > > > > If I'm reading the current code and your patch correctly, this will just > > reset gestures if a second/further touch is received, which sounds > > undesirable for the zoom gesture. It is worth pointing out that there's no > > right check that we can do here to prevent this case, there's basically no > > valid assumptions about what the next GdkEventSequence might be. > > > As for resetting the gestures, there are 2 cases here: > - 1: the gesture controller did not receive a BEGIN touch event (handled by > webprocess/page - gesture controller was not processing events) and we > ignore any new touch event (UPDATE/END) > - 2: the gesture controller received a BEGIN touch event but did not receive > a END touch event (e.g. gesture controller received BEGIN and then another > BEGIN event) Again, think about multitouch :), each touchpoint has its own BEGIN/UPDATE.../END lifetime, just with different GdkEventSequences. Receiving a second BEGIN event is not a good indication that any previous touch handling is now stale. > > > Also, I find this a bit backwards. If we let webpages capture random events > > from an specific touchpoint event stream, we'll be potentially left with an > > inconsistent state in the GestureController until a next TOUCH_BEGIN event > > is received, which might be much later, or just never. > The idea here is actually to not leave the gesture controller in a > inconsistent state. We reset the gestures if we get into an inconsistent > state as described above. > From what I see, with these changes the gesture controller will never be in > a inconsitent state. > > From what I see we have the following options: > - The webpage prevents touch BEGIN - in this case the gesture controller > will not receive any touch event. > - the webpage do not prevent touch BEGIN but prevents touch UPDATE - in this > case the gesture controller will not receive UPDATE events, but will receive > the END event > - the webpage cannot prevent a END touch event if it did not prevent a BEGIN > touch event - END touch events always reach the gesture controller if a > BEGIN touch event was received by it > > Please let me know if I am missing something. According to http://www.w3.org/TR/touch-events/ : - The touchstart event: "If the preventDefault method is called on this event, it should prevent any default actions caused by any touch events associated with the same active touch point, including mouse events or scrolling." - The touchmove event: "If the preventDefault method is called on the *first* touchmove event of an active touch point, it should prevent any default action caused by any touchmove event associated with the same active touch point, such as scrolling." So, presumably we should honor this last point about the touchmove event, although as far as I can see in https://patrickhlauke.github.io/touch/tests/report.js, that just won't help for the testcase you pasted in the bug description, as there's no trace of preventDefault there. I'd argue that's a bug in the testcase, not WebKit's. 1202252 11 281268 andrunko 2016-06-14 11:36:04 -0700 Created attachment 281268 Patch 1202258 12 andrunko 2016-06-14 11:44:15 -0700 (In reply to comment #10) > (In reply to comment #9) > Again, think about multitouch :), each touchpoint has its own > BEGIN/UPDATE.../END lifetime, just with different GdkEventSequences. > Receiving a second BEGIN event is not a good indication that any previous > touch handling is now stale. > Of course, I made a change that may fix this issue. I am now checking if the same sequence is already being handled by the gesture, and only if so we reset the gesture. Note that I dont have a touchscreen device here, so I am testing by injecting fake touch events directly and cant test the zoom gesture. > > > > > Also, I find this a bit backwards. If we let webpages capture random events > > > from an specific touchpoint event stream, we'll be potentially left with an > > > inconsistent state in the GestureController until a next TOUCH_BEGIN event > > > is received, which might be much later, or just never. > > The idea here is actually to not leave the gesture controller in a > > inconsistent state. We reset the gestures if we get into an inconsistent > > state as described above. > > From what I see, with these changes the gesture controller will never be in > > a inconsitent state. > > > > From what I see we have the following options: > > - The webpage prevents touch BEGIN - in this case the gesture controller > > will not receive any touch event. > > - the webpage do not prevent touch BEGIN but prevents touch UPDATE - in this > > case the gesture controller will not receive UPDATE events, but will receive > > the END event > > - the webpage cannot prevent a END touch event if it did not prevent a BEGIN > > touch event - END touch events always reach the gesture controller if a > > BEGIN touch event was received by it > > > > Please let me know if I am missing something. > > According to http://www.w3.org/TR/touch-events/ : > > - The touchstart event: "If the preventDefault method is called on this > event, it should prevent any default actions caused by any touch events > associated with the same active touch point, including mouse events or > scrolling." > > - The touchmove event: "If the preventDefault method is called on the > *first* touchmove event of an active touch point, it should prevent any > default action caused by any touchmove event associated with the same active > touch point, such as scrolling." > The touchstart should already be correct. As for the touchmove, I believe this is (or should be) handled by WebProcess itself (WebCore/page/EventHandler.cpp) and signal that the subsequent touchmove events (if the first one was prevented) are handled by it when invoking the PageClient::doneWithTouchEvent. > So, presumably we should honor this last point about the touchmove event, > although as far as I can see in > https://patrickhlauke.github.io/touch/tests/report.js, that just won't help > for the testcase you pasted in the bug description, as there's no trace of > preventDefault there. I'd argue that's a bug in the testcase, not WebKit's. This test is basically to print the events when using touch sequences on the "Test button". It does not invoke preventDefault on any handler. The problem here is that currently (master) only touchbegin arrives on the page, while the same test works fine (we get touchupdate/end on the page) on both firefox and chrome. If I understood correctly, the proper behaviour is that all touch events should reach the page but some of them may be prevented and thus not reach the gesture controller. 1202435 13 andrunko 2016-06-14 18:55:23 -0700 Now that I am thinking about it, I remembered why I added the conditional "+ if (wasProcessingGestures && event->type == GDK_TOUCH_BEGIN) {" on GestureController::handleEvent. This was actually to fix an issue I was having where I was calling ev.preventDefault on touchend from the page and then I would get touchbegin reaching the gesture controller but no touchend. This was later fixed by the change in PlageClientImpl::doneWithTouchEvent where the touchend event gets to the gesture controller even if ev.preventDefault was called on it, as long as touchbegin reached the gesture controller. In other words, this conditional is only needed in case 2 touchbegin events of the *same* sequence gets to the gesture controller, which should never happen afaik - unless we have a bogus touch device... I will update the patch to remove this conditional, please let me know what you think. 1202438 14 281312 andrunko 2016-06-14 18:59:14 -0700 Created attachment 281312 Patch 1203752 15 andrunko 2016-06-20 07:59:44 -0700 (In reply to comment #14) > Created attachment 281312 [details] > Patch Hi Carlos, did you have the chance to check this new patch? Thanks 1205085 16 andrunko 2016-06-24 09:00:52 -0700 Note that bug 155750 changes affect this patch here. We need to also reset the kinetic gesture if the changes there get merged before this one (or update the patch there if this one gets in first). 1209554 17 mcatanzaro 2016-07-10 13:38:56 -0700 (In reply to comment #15) > Hi Carlos, did you have the chance to check this new patch? Thanks Hey Carlos Garnacho, got time for another look? 1340436 18 281312 beidson 2017-08-19 16:01:47 -0700 Comment on attachment 281312 Patch r-, as this has been pending review for over a year now. It is near-impossible that this patch still applies to trunk and unlikely to still be relevant in its current form. 1340786 19 318679 aperez 2017-08-21 15:28:33 -0700 Created attachment 318679 Patch I have updated Andre's patch so ut applies cleanly to trunk 1340810 20 318679 clopez 2017-08-21 16:20:48 -0700 Comment on attachment 318679 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=318679&action=review > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:349 > + if (!wasEventHandled || (touchEvent->type == GTK_TOUCH_END && gestureController.isProcessingGestures())) { It fail to build on the EWS, maybe you mean GDK_TOUCH_END here? 1340832 21 aperez 2017-08-21 16:40:40 -0700 (In reply to Carlos Alberto Lopez Perez from comment #20) > Comment on attachment 318679 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=318679&action=review > > > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:349 > > + if (!wasEventHandled || (touchEvent->type == GTK_TOUCH_END && gestureController.isProcessingGestures())) { > > It fail to build on the EWS, maybe you mean GDK_TOUCH_END here? Indeed, I'll fix this and re-upload. FWIW, it would be good to have Carlos Garnacho review the patch, my experience with touch events handling is very limited, and while the changes introduced sound logical in my mind, I would prefer someone else to check this patch. 1340834 22 318694 aperez 2017-08-21 16:41:32 -0700 Created attachment 318694 Patch 1355863 23 318694 clopez 2017-10-03 09:39:32 -0700 Comment on attachment 318694 Patch I confirm this fixes touch events on WebKitGTK+. I tested this succesfully here: https://people.igalia.com/clopez/wkbug/touchevents/test3.html (that test is broken without this) r=me 1356062 24 318694 carlosg 2017-10-03 14:56:53 -0700 Comment on attachment 318694 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=318694&action=review > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:356 > + wasEventHandled = gestureController.handleEvent(event.nativeEvent()); IIUC here we bypass wasEventHandled for touchend so the gestureController can undo state in the GtkGestures underneath, even if they were entirely/partially handled by the webpage. Wouldn't it be clearer to add a reset() method to GestureController that resets all 3 contained gestures and just change this function to have a beginning like this?: if (wasEventHandled) { gestureController.reset(); return; } i.e. resetting the gestureController altogether whenever the webpage handles a touch event. This way all gestures are reset at once instead of touch sequence by touch sequence. I'm afraid relaying touchend events like this patch does may trigger further action from the GestureController, as eg. GtkGestureSwipe will trigger kinetic scroll upon receiving GDK_TOUCH_END (more on that below). > Source/WebKit/UIProcess/gtk/GestureController.cpp:53 > + if (!wasProcessingGestures && (event->type == GDK_TOUCH_UPDATE || event->type == GDK_TOUCH_END)) { I don't quite understand here that this branch checks for !isProcessingGestures() as opposed to the PageClientImpl::doneWithTouchEvent() change that checks for isProcessingGestures(). Is this unintended? a leftover from the previous approach? I have the impression that the touchend given from doneWithTouchEvent() would not fall through this branch, thus would be fed to the GtkGestures. And anyway... This looks kinda unnecessary if you go with the GestureController::reset() approach I suggest :) > Source/WebKit/UIProcess/gtk/GestureController.cpp:55 > + m_zoomGesture.reset(); FWIW, there is now a m_swipeGesture that should be reset too :). 1356320 25 318694 mcatanzaro 2017-10-04 03:39:51 -0700 Comment on attachment 318694 Patch OK, thanks for working on this Adrian. Please address Garnacho's comments. 1356413 26 aperez 2017-10-04 07:51:42 -0700 First of all, thanks a lot again for letting us drag you back to this patch for reviews — I feel like we are getting closer to landing it (In reply to Carlos Garnacho from comment #24) > Comment on attachment 318694 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=318694&action=review > > > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:356 > > + wasEventHandled = gestureController.handleEvent(event.nativeEvent()); > > IIUC here we bypass wasEventHandled for touchend so the gestureController > can undo state in the GtkGestures underneath, even if they were > entirely/partially handled by the webpage. > > Wouldn't it be clearer to add a reset() method to GestureController that > resets all 3 contained gestures and just change this function to have a > beginning like this?: > > if (wasEventHandled) { > gestureController.reset(); > return; > } > > i.e. resetting the gestureController altogether whenever the webpage handles > a touch event. This way all gestures are reset at once instead of touch > sequence by touch sequence. Adding a GestureController::reset() method does indeed sound like a good idea, and if/when additional gestures are added later there will be a clear location where to reset its state. > I'm afraid relaying touchend events like this patch does may trigger further > action from the GestureController, as eg. GtkGestureSwipe will trigger > kinetic scroll upon receiving GDK_TOUCH_END (more on that below). > > > Source/WebKit/UIProcess/gtk/GestureController.cpp:53 > > + if (!wasProcessingGestures && (event->type == GDK_TOUCH_UPDATE || event->type == GDK_TOUCH_END)) { > > I don't quite understand here that this branch checks for > !isProcessingGestures() as opposed to the > PageClientImpl::doneWithTouchEvent() change that checks for > isProcessingGestures(). Is this unintended? a leftover from the previous > approach? I have the impression that the touchend given from > doneWithTouchEvent() would not fall through this branch, thus would be fed > to the GtkGestures. > > And anyway... This looks kinda unnecessary if you go with the > GestureController::reset() approach I suggest :) I have tried locally to remove this snippet after adding the ::reset() method, and it works. IMHO with this simplification the code is more obvious and doesn't raise eyebrows as much — which is good. > > Source/WebKit/UIProcess/gtk/GestureController.cpp:55 > > + m_zoomGesture.reset(); > > FWIW, there is now a m_swipeGesture that should be reset too :). Great catch! I'll upload a patch in a few minutes with the suggestions applied. 1356415 27 322671 aperez 2017-10-04 07:55:13 -0700 Created attachment 322671 Patch 1356423 28 aperez 2017-10-04 08:19:31 -0700 From #webkitgtk+ in Freenode: [17:03] <garnacho> aperezdc: it does look perfect to me code-wise :). \o/ 1356493 29 322671 commit-queue 2017-10-04 10:33:30 -0700 Comment on attachment 322671 Patch Clearing flags on attachment: 322671 Committed r222855: <http://trac.webkit.org/changeset/222855> 1356494 30 commit-queue 2017-10-04 10:33:32 -0700 All reviewed patches have been landed. Closing bug. 280816 2016-06-08 11:10:49 -0700 2016-06-13 11:33:26 -0700 Patch bug-158531-20160608151215.patch text/plain 6551 andrunko U3VidmVyc2lvbiBSZXZpc2lvbjogMjAxODEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZDZkZmVkNDQ5MDQ2YjMx OTc2NmRhODA2NDI3ZDRhNzA0ZmJhMTUxMi4uZTU5ZTczNzJiY2M1NGJlNTE0Y2ZlM2I2Y2EzNmVk ZjcwMWMzY2NmZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDE2LTA2LTA4ICBBbmRy ZSBNb3JlaXJhIE1hZ2FsaGFlcyAgIDxhbmRyZS5tYWdhbGhhZXNAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFdlYktpdDJHVEsrIGRvZXMgbm90IGhhbmRsZSB0b3VjaG1vdmUgYW5kIHRvdWNo ZW5kIGV2ZW50cyBjb3JyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE1ODUzMQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIERvIG5vdCBieXBhc3MgV2ViQ29yZSBldmVudCBoYW5kbGluZyB3aGVuIHJl Y2VpdmluZyB0b3VjaCBldmVudHMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9QYWdl Q2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsOjpkb25lV2l0 aFRvdWNoRXZlbnQpOiBNYWtlIHN1cmUgdG91Y2hlbmQgcmVhY2hzIGdlc3R1cmUgY29udHJvbGxl cgorICAgICAgICBpZiB0b3VjaGJlZ2luIGV2ZXIgZ290IHRvIGl0LgorICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZp ZXdCYXNlVG91Y2hFdmVudCk6IERvIG5vdCBpbnZva2UgZ2VzdHVyZSBjb250cm9sbGVyIGRpcmVj dGx5IGJ5CisgICAgICAgIGJ5cGFzc2luZyBXZWJDb3JlIGV2ZW50IGhhbmRsaW5nLgorICAgICAg ICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViS2l0 OjpHZXN0dXJlQ29udHJvbGxlcjo6aGFuZGxlRXZlbnQpOiBSZXNldCBnZXN0dXJlIGNvbnRyb2xs ZXIgd2hlbiB0b3VjaHVwZGF0ZS9lbmQgaXMKKyAgICAgICAgcmVjZWl2ZWQgd2l0aG91dCB0b3Vj aGJlZ2luIG9yIHRvdWNoYmVnaW4gaXMgcmVjZWl2ZWQgd2hpbGUgc3RpbGwgcHJvY2Vzc2luZyBh bm90aGVyIHRvdWNoCisgICAgICAgIHNlcXVlbmNlIChiZWZvcmUgdG91Y2hlbmQpLgorICAgICAg ICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaDoKKyAgICAgICAgKFdlYktpdDo6 R2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmU6Omdlc3R1cmUpOgorCiAyMDE2LTA2LTA2ICBBbnR0 aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJLaXQgbWVtb3J5IGNh Y2hlIGRvZXNuJ3QgcmVzcGVjdCBWYXJ5IGhlYWRlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCmluZGV4IDNjMmY4NmVhYjNlMGU3 MmQyOWQxY2U0MTQ0MDE2YjI0M2E1ZjQ2NDUuLmU0MjMwNmE4NTIzOTY3ZWE2ZTI0MjVlNjViZjll ZTUzZTc2OWVmZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1BhZ2VDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTMyOCw4ICszMjgsMjMgQEAgdm9pZCBQYWdlQ2xpZW50 SW1wbDo6YmVnYW5FeGl0RnVsbFNjcmVlbihjb25zdCBJbnRSZWN0JiAvKiBpbml0aWFsRnJhbWUg Ki8sIGNvbnMKICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogdm9pZCBQYWdlQ2xpZW50SW1wbDo6 ZG9uZVdpdGhUb3VjaEV2ZW50KGNvbnN0IE5hdGl2ZVdlYlRvdWNoRXZlbnQmIGV2ZW50LCBib29s IHdhc0V2ZW50SGFuZGxlZCkKIHsKLSAgICBpZiAod2FzRXZlbnRIYW5kbGVkKQorICAgIGNvbnN0 IEdka0V2ZW50KiB0b3VjaEV2ZW50ID0gZXZlbnQubmF0aXZlRXZlbnQoKTsKKworICAgIGlmICh3 YXNFdmVudEhhbmRsZWQpIHsKKyNpZiBIQVZFKEdUS19HRVNUVVJFUykKKyAgICAgICAgR2VzdHVy ZUNvbnRyb2xsZXImIGdlc3R1cmVDb250cm9sbGVyID0gd2Via2l0V2ViVmlld0Jhc2VHZXN0dXJl Q29udHJvbGxlcihXRUJLSVRfV0VCX1ZJRVdfQkFTRShtX3ZpZXdXaWRnZXQpKTsKKyAgICAgICAg aWYgKHRvdWNoRXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX0VORCAmJiBnZXN0dXJlQ29udHJvbGxl ci5pc1Byb2Nlc3NpbmdHZXN0dXJlcygpKSB7CisgICAgICAgICAgICAvLyBJZ25vcmVkIGF0dGVt cHQgdG8gY2FuY2VsIGFuIEVORCB0b3VjaCBldmVudCB3aGlsZSBhIEJFR0lOIHRvdWNoIGV2ZW50 IHdhcyBwcm9jZXNzZWQKKyAgICAgICAgICAgIC8vIGJ5IHRoZSBnZXN0dXJlIGNvbnRyb2xsZXIg KHdhc24ndCBoYW5kbGVkIGJ5IFdlYlByb2Nlc3MpLCBmb3IgZXhhbXBsZSBiZWNhdXNlCisgICAg ICAgICAgICAvLyBzY3JvbGxpbmcgaXMgaW4gcHJvZ3Jlc3MgYW5kIGNhbm5vdCBiZSBpbnRlcnJ1 cHRlZC4KKyAgICAgICAgICAgIGlmIChnZXN0dXJlQ29udHJvbGxlci5oYW5kbGVFdmVudChldmVu dC5uYXRpdmVFdmVudCgpKSkKKyAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0gZWxz ZQorICAgICAgICAgICAgcmV0dXJuOworI2Vsc2UKICAgICAgICAgcmV0dXJuOworI2VuZGlmCisg ICAgfQogCiAjaWYgSEFWRShHVEtfR0VTVFVSRVMpCiAgICAgR2VzdHVyZUNvbnRyb2xsZXImIGdl c3R1cmVDb250cm9sbGVyID0gd2Via2l0V2ViVmlld0Jhc2VHZXN0dXJlQ29udHJvbGxlcihXRUJL SVRfV0VCX1ZJRVdfQkFTRShtX3ZpZXdXaWRnZXQpKTsKQEAgLTMzOCw4ICszNTMsNiBAQCB2b2lk IFBhZ2VDbGllbnRJbXBsOjpkb25lV2l0aFRvdWNoRXZlbnQoY29uc3QgTmF0aXZlV2ViVG91Y2hF dmVudCYgZXZlbnQsIGJvb2wgdwogI2VuZGlmCiAKICAgICAvLyBFbXVsYXRlIHBvaW50ZXIgZXZl bnRzIGlmIHVuaGFuZGxlZC4KLSAgICBjb25zdCBHZGtFdmVudCogdG91Y2hFdmVudCA9IGV2ZW50 Lm5hdGl2ZUV2ZW50KCk7Ci0KICAgICBpZiAoIXRvdWNoRXZlbnQtPnRvdWNoLmVtdWxhdGluZ19w b2ludGVyKQogICAgICAgICByZXR1cm47CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcAppbmRleCBjYjBhZTMzNzcxYTZj ZmVmMjY2MjViN2QwNGJiMTFkZTUzZmViYTc3Li5kNzg3NTcxNzVlYWU3NjYwNDFiZmU1ZDAzZWFm NTM3ZDRlMjI1ZDM1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCkBAIC05ODgsMjAgKzk4OCw2IEBAIHN0YXRpYyBn Ym9vbGVhbiB3ZWJraXRXZWJWaWV3QmFzZVRvdWNoRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdk a0V2ZW50VG91Y2gqIGV2CiAgICAgR2RrRXZlbnQqIHRvdWNoRXZlbnQgPSByZWludGVycHJldF9j YXN0PEdka0V2ZW50Kj4oZXZlbnQpOwogICAgIHVpbnQzMl90IHNlcXVlbmNlID0gR1BPSU5URVJf VE9fVUlOVChnZGtfZXZlbnRfZ2V0X2V2ZW50X3NlcXVlbmNlKHRvdWNoRXZlbnQpKTsKIAotI2lm IEhBVkUoR1RLX0dFU1RVUkVTKQotICAgIEdlc3R1cmVDb250cm9sbGVyJiBnZXN0dXJlQ29udHJv bGxlciA9IHdlYmtpdFdlYlZpZXdCYXNlR2VzdHVyZUNvbnRyb2xsZXIod2ViVmlld0Jhc2UpOwot ICAgIGlmIChnZXN0dXJlQ29udHJvbGxlci5pc1Byb2Nlc3NpbmdHZXN0dXJlcygpKSB7Ci0gICAg ICAgIC8vIElmIHdlIGFyZSBhbHJlYWR5IHByb2Nlc3NpbmcgZ2VzdHVyZXMgaXMgYmVjYXVzZSB0 aGUgV2ViUHJvY2VzcyBkaWRuJ3QgaGFuZGxlIHRoZQotICAgICAgICAvLyBCRUdJTiB0b3VjaCBl dmVudCwgc28gcGFzcyBzdWJzZXF1ZW50IGV2ZW50cyB0byB0aGUgR2VzdHVyZUNvbnRyb2xsZXIu Ci0gICAgICAgIGdlc3R1cmVDb250cm9sbGVyLmhhbmRsZUV2ZW50KHRvdWNoRXZlbnQpOwotICAg ICAgICAvLyBSZW1vdmUgdGhlIGdlc3R1cmUgZXZlbnQgc2VxdWVuY2UgZnJvbSB0aGUgaGFuZGxl ZCB0b3VjaCBldmVudHMKLSAgICAgICAgLy8gbGlzdCB0byBhdm9pZCB0aGUgZ2VzdXJlIHNlcXVl bmNlIGFuZCBhIHRvdWNoIHNlcXVlbmNlIG9mIHNhbWUKLSAgICAgICAgLy8gSUQgdG8gY29uZmxp Y3QuCi0gICAgICAgIHByaXYtPnRvdWNoRXZlbnRzLnJlbW92ZShzZXF1ZW5jZSk7Ci0gICAgICAg IHJldHVybiBUUlVFOwotICAgIH0KLSNlbmRpZgotCiAgICAgc3dpdGNoICh0b3VjaEV2ZW50LT50 eXBlKSB7CiAgICAgY2FzZSBHREtfVE9VQ0hfQkVHSU46IHsKICAgICAgICAgQVNTRVJUKCFwcml2 LT50b3VjaEV2ZW50cy5jb250YWlucyhzZXF1ZW5jZSkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVyLmNwcAppbmRleCA3ZTE1NzdjYmE4YjE1 NzA1MjY0ZTViYTU0NzVmZmM1OTYyZGFiODg5Li5mZGExNDE4Y2FiZTgzZDhhZWY4OTE0NWJiNmZk OGFkYmRjZGMxNzRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dl c3R1cmVDb250cm9sbGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dl c3R1cmVDb250cm9sbGVyLmNwcApAQCAtNDgsNiArNDgsMTggQEAgR2VzdHVyZUNvbnRyb2xsZXI6 Okdlc3R1cmVDb250cm9sbGVyKFdlYlBhZ2VQcm94eSYgcGFnZSkKIGJvb2wgR2VzdHVyZUNvbnRy b2xsZXI6OmhhbmRsZUV2ZW50KGNvbnN0IEdka0V2ZW50KiBldmVudCkKIHsKICAgICBib29sIHdh c1Byb2Nlc3NpbmdHZXN0dXJlcyA9IGlzUHJvY2Vzc2luZ0dlc3R1cmVzKCk7CisgICAgLy8gUmVj ZWl2ZWQgdG91Y2h1cGRhdGUvZW5kIHdpdGhvdXQgdG91Y2hiZWdpbiwgaWdub3JlIGV2ZW50cwor ICAgIGlmICghd2FzUHJvY2Vzc2luZ0dlc3R1cmVzICYmIChldmVudC0+dHlwZSA9PSBHREtfVE9V Q0hfVVBEQVRFIHx8IGV2ZW50LT50eXBlID09IEdES19UT1VDSF9FTkQpKSB7CisgICAgICAgIGd0 a19ldmVudF9jb250cm9sbGVyX3Jlc2V0KEdUS19FVkVOVF9DT05UUk9MTEVSKG1fZHJhZ0dlc3R1 cmUuZ2VzdHVyZSgpKSk7CisgICAgICAgIGd0a19ldmVudF9jb250cm9sbGVyX3Jlc2V0KEdUS19F VkVOVF9DT05UUk9MTEVSKG1fem9vbUdlc3R1cmUuZ2VzdHVyZSgpKSk7CisgICAgICAgIHJldHVy biBGQUxTRTsKKyAgICB9CisgICAgLy8gUmVjZWl2ZWQgdG91Y2hiZWdpbiB3aGlsZSBzdGlsbCBw cm9jZXNzaW5nIGFub3RoZXIgdG91Y2ggc2VxdWVuY2UsIGNhbmNlbCBwcmV2aW91cyBzZXF1ZW5j ZQorICAgIGlmICh3YXNQcm9jZXNzaW5nR2VzdHVyZXMgJiYgZXZlbnQtPnR5cGUgPT0gR0RLX1RP VUNIX0JFR0lOKSB7CisgICAgICAgIGd0a19ldmVudF9jb250cm9sbGVyX3Jlc2V0KEdUS19FVkVO VF9DT05UUk9MTEVSKG1fZHJhZ0dlc3R1cmUuZ2VzdHVyZSgpKSk7CisgICAgICAgIGd0a19ldmVu dF9jb250cm9sbGVyX3Jlc2V0KEdUS19FVkVOVF9DT05UUk9MTEVSKG1fem9vbUdlc3R1cmUuZ2Vz dHVyZSgpKSk7CisgICAgfQorCiAgICAgbV9kcmFnR2VzdHVyZS5oYW5kbGVFdmVudChldmVudCk7 CiAgICAgbV96b29tR2VzdHVyZS5oYW5kbGVFdmVudChldmVudCk7CiAgICAgcmV0dXJuIGV2ZW50 LT50eXBlID09IEdES19UT1VDSF9FTkQgPyB3YXNQcm9jZXNzaW5nR2VzdHVyZXMgOiBpc1Byb2Nl c3NpbmdHZXN0dXJlcygpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0 ay9HZXN0dXJlQ29udHJvbGxlci5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9HZXN0 dXJlQ29udHJvbGxlci5oCmluZGV4IDg2NzkyZGY0MmNmNGMzNGY4OWQ4ZGZkN2MwMTkxMTk5MDQx Njc0Y2EuLmQ3NGRhN2UwNGE0YTk2ZjJhMjk4ZmUzZDYyOGFkYTZiNTYxNzQ1YzYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVyLmgKQEAgLTU1 LDYgKzU1LDggQEAgcHJpdmF0ZToKICAgICAgICAgYm9vbCBpc0FjdGl2ZSgpIGNvbnN0OwogICAg ICAgICB2b2lkIGhhbmRsZUV2ZW50KGNvbnN0IEdka0V2ZW50Kik7CiAKKyAgICAgICAgR3RrR2Vz dHVyZSogZ2VzdHVyZSgpIHsgcmV0dXJuIG1fZ2VzdHVyZS5nZXQoKTsgfQorCiAgICAgcHJvdGVj dGVkOgogICAgICAgICBHZXN0dXJlKEd0a0dlc3R1cmUqLCBXZWJQYWdlUHJveHkmKTsKIAo= 281183 2016-06-13 11:33:35 -0700 2016-06-14 11:35:54 -0700 Patch bug-158531-20160613153508.patch text/plain 6786 andrunko U3VidmVyc2lvbiBSZXZpc2lvbjogMjAxODEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZDZkZmVkNDQ5MDQ2YjMx OTc2NmRhODA2NDI3ZDRhNzA0ZmJhMTUxMi4uYTg5Mjk5MGVlN2UwODc2NGIwOTQxYmNiOTY1ODA5 MDMxNjJlZjFjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDE2LTA2LTEzICBBbmRy ZSBNb3JlaXJhIE1hZ2FsaGFlcyAgIDxhbmRyZS5tYWdhbGhhZXNAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFdlYktpdDJHVEsrIGRvZXMgbm90IGhhbmRsZSB0b3VjaG1vdmUgYW5kIHRvdWNo ZW5kIGV2ZW50cyBjb3JyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE1ODUzMQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIERvIG5vdCBieXBhc3MgV2ViQ29yZSBldmVudCBoYW5kbGluZyB3aGVuIHJl Y2VpdmluZyB0b3VjaCBldmVudHMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9QYWdl Q2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsOjpkb25lV2l0 aFRvdWNoRXZlbnQpOiBNYWtlIHN1cmUgdG91Y2hlbmQgcmVhY2hzIGdlc3R1cmUgY29udHJvbGxl cgorICAgICAgICBpZiB0b3VjaGJlZ2luIGV2ZXIgZ290IHRvIGl0LgorICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZp ZXdCYXNlVG91Y2hFdmVudCk6IERvIG5vdCBpbnZva2UgZ2VzdHVyZSBjb250cm9sbGVyIGRpcmVj dGx5IGJ5CisgICAgICAgIGJ5cGFzc2luZyBXZWJDb3JlIGV2ZW50IGhhbmRsaW5nLgorICAgICAg ICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViS2l0 OjpHZXN0dXJlQ29udHJvbGxlcjo6aGFuZGxlRXZlbnQpOiBSZXNldCBnZXN0dXJlIGNvbnRyb2xs ZXIgd2hlbiB0b3VjaHVwZGF0ZS9lbmQgaXMKKyAgICAgICAgcmVjZWl2ZWQgd2l0aG91dCB0b3Vj aGJlZ2luIG9yIHRvdWNoYmVnaW4gaXMgcmVjZWl2ZWQgd2hpbGUgc3RpbGwgcHJvY2Vzc2luZyBh bm90aGVyIHRvdWNoCisgICAgICAgIHNlcXVlbmNlIChiZWZvcmUgdG91Y2hlbmQpLgorICAgICAg ICAoV2ViS2l0OjpHZXN0dXJlQ29udHJvbGxlcjo6R2VzdHVyZTo6cmVzZXQpOgorICAgICAgICAq IFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaDoKKwogMjAxNi0wNi0wNiAgQW50dGkg S29pdmlzdG8gIDxhbnR0aUBhcHBsZS5jb20+CiAKICAgICAgICAgV2ViS2l0IG1lbW9yeSBjYWNo ZSBkb2Vzbid0IHJlc3BlY3QgVmFyeSBoZWFkZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAppbmRleCAzYzJmODZlYWIzZTBlNzJk MjlkMWNlNDE0NDAxNmIyNDNhNWY0NjQ1Li4wNThhMWU3ZTIwMTM4NzdiZWM1OTgxMjI2N2RhYTA5 Y2U2NjdlZGNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9Q YWdlQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv UGFnZUNsaWVudEltcGwuY3BwCkBAIC0zMjgsMTggKzMyOCwyNSBAQCB2b2lkIFBhZ2VDbGllbnRJ bXBsOjpiZWdhbkV4aXRGdWxsU2NyZWVuKGNvbnN0IEludFJlY3QmIC8qIGluaXRpYWxGcmFtZSAq LywgY29ucwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiB2b2lkIFBhZ2VDbGllbnRJbXBsOjpk b25lV2l0aFRvdWNoRXZlbnQoY29uc3QgTmF0aXZlV2ViVG91Y2hFdmVudCYgZXZlbnQsIGJvb2wg d2FzRXZlbnRIYW5kbGVkKQogewotICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCi0gICAgICAgIHJl dHVybjsKKyAgICBjb25zdCBHZGtFdmVudCogdG91Y2hFdmVudCA9IGV2ZW50Lm5hdGl2ZUV2ZW50 KCk7CiAKICNpZiBIQVZFKEdUS19HRVNUVVJFUykKICAgICBHZXN0dXJlQ29udHJvbGxlciYgZ2Vz dHVyZUNvbnRyb2xsZXIgPSB3ZWJraXRXZWJWaWV3QmFzZUdlc3R1cmVDb250cm9sbGVyKFdFQktJ VF9XRUJfVklFV19CQVNFKG1fdmlld1dpZGdldCkpOwotICAgIGlmIChnZXN0dXJlQ29udHJvbGxl ci5oYW5kbGVFdmVudChldmVudC5uYXRpdmVFdmVudCgpKSkKLSAgICAgICAgcmV0dXJuOworICAg IGlmICghd2FzRXZlbnRIYW5kbGVkIHx8ICh0b3VjaEV2ZW50LT50eXBlID09IEdES19UT1VDSF9F TkQgJiYgZ2VzdHVyZUNvbnRyb2xsZXIuaXNQcm9jZXNzaW5nR2VzdHVyZXMoKSkpIHsKKyAgICAg ICAgLy8gSWdub3JlZCBhdHRlbXB0IHRvIGNhbmNlbCBhbiBFTkQgdG91Y2ggZXZlbnQgd2hpbGUg YSBCRUdJTiB0b3VjaCBldmVudCB3YXMgcHJvY2Vzc2VkCisgICAgICAgIC8vIGJ5IHRoZSBnZXN0 dXJlIGNvbnRyb2xsZXIgKHdhc24ndCBoYW5kbGVkIGJ5IFdlYlByb2Nlc3MpLCBmb3IgZXhhbXBs ZSBiZWNhdXNlCisgICAgICAgIC8vIHNjcm9sbGluZyBpcyBpbiBwcm9ncmVzcyBhbmQgY2Fubm90 IGJlIGludGVycnVwdGVkIC0gaWYgd2UgYXJlIGFscmVhZHkgcHJvY2Vzc2luZworICAgICAgICAv LyBnZXN0dXJlcyBpcyBiZWNhdXNlIHRoZSBXZWJQcm9jZXNzIGRpZG4ndCBoYW5kbGUgdGhlIEJF R0lOIHRvdWNoIGV2ZW50LAorICAgICAgICAvLyBzbyBsZXRzIHBhc3MgdGhlIEVORCB0b3VjaCBl dmVudCB0byB0aGUgR2VzdHVyZUNvbnRyb2xsZXIgZXZlbiBpZiBpdCB3YXMKKyAgICAgICAgLy8g aGFuZGxlZCBieSB0aGUgV2ViUHJvY2Vzcy4KKyAgICAgICAgd2FzRXZlbnRIYW5kbGVkID0gZ2Vz dHVyZUNvbnRyb2xsZXIuaGFuZGxlRXZlbnQoZXZlbnQubmF0aXZlRXZlbnQoKSk7CisgICAgfQog I2VuZGlmCiAKLSAgICAvLyBFbXVsYXRlIHBvaW50ZXIgZXZlbnRzIGlmIHVuaGFuZGxlZC4KLSAg ICBjb25zdCBHZGtFdmVudCogdG91Y2hFdmVudCA9IGV2ZW50Lm5hdGl2ZUV2ZW50KCk7CisgICAg aWYgKHdhc0V2ZW50SGFuZGxlZCkKKyAgICAgICAgcmV0dXJuOwogCisgICAgLy8gRW11bGF0ZSBw b2ludGVyIGV2ZW50cyBpZiB1bmhhbmRsZWQuCiAgICAgaWYgKCF0b3VjaEV2ZW50LT50b3VjaC5l bXVsYXRpbmdfcG9pbnRlcikKICAgICAgICAgcmV0dXJuOwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKaW5kZXggY2Iw YWUzMzc3MWE2Y2ZlZjI2NjI1YjdkMDRiYjExZGU1M2ZlYmE3Ny4uZDc4NzU3MTc1ZWFlNzY2MDQx YmZlNWQwM2VhZjUzN2Q0ZTIyNWQzNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcApAQCAtOTg4LDIwICs5ODgsNiBA QCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2ViVmlld0Jhc2VUb3VjaEV2ZW50KEd0a1dpZGdldCog d2lkZ2V0LCBHZGtFdmVudFRvdWNoKiBldgogICAgIEdka0V2ZW50KiB0b3VjaEV2ZW50ID0gcmVp bnRlcnByZXRfY2FzdDxHZGtFdmVudCo+KGV2ZW50KTsKICAgICB1aW50MzJfdCBzZXF1ZW5jZSA9 IEdQT0lOVEVSX1RPX1VJTlQoZ2RrX2V2ZW50X2dldF9ldmVudF9zZXF1ZW5jZSh0b3VjaEV2ZW50 KSk7CiAKLSNpZiBIQVZFKEdUS19HRVNUVVJFUykKLSAgICBHZXN0dXJlQ29udHJvbGxlciYgZ2Vz dHVyZUNvbnRyb2xsZXIgPSB3ZWJraXRXZWJWaWV3QmFzZUdlc3R1cmVDb250cm9sbGVyKHdlYlZp ZXdCYXNlKTsKLSAgICBpZiAoZ2VzdHVyZUNvbnRyb2xsZXIuaXNQcm9jZXNzaW5nR2VzdHVyZXMo KSkgewotICAgICAgICAvLyBJZiB3ZSBhcmUgYWxyZWFkeSBwcm9jZXNzaW5nIGdlc3R1cmVzIGlz IGJlY2F1c2UgdGhlIFdlYlByb2Nlc3MgZGlkbid0IGhhbmRsZSB0aGUKLSAgICAgICAgLy8gQkVH SU4gdG91Y2ggZXZlbnQsIHNvIHBhc3Mgc3Vic2VxdWVudCBldmVudHMgdG8gdGhlIEdlc3R1cmVD b250cm9sbGVyLgotICAgICAgICBnZXN0dXJlQ29udHJvbGxlci5oYW5kbGVFdmVudCh0b3VjaEV2 ZW50KTsKLSAgICAgICAgLy8gUmVtb3ZlIHRoZSBnZXN0dXJlIGV2ZW50IHNlcXVlbmNlIGZyb20g dGhlIGhhbmRsZWQgdG91Y2ggZXZlbnRzCi0gICAgICAgIC8vIGxpc3QgdG8gYXZvaWQgdGhlIGdl c3VyZSBzZXF1ZW5jZSBhbmQgYSB0b3VjaCBzZXF1ZW5jZSBvZiBzYW1lCi0gICAgICAgIC8vIElE IHRvIGNvbmZsaWN0LgotICAgICAgICBwcml2LT50b3VjaEV2ZW50cy5yZW1vdmUoc2VxdWVuY2Up OwotICAgICAgICByZXR1cm4gVFJVRTsKLSAgICB9Ci0jZW5kaWYKLQogICAgIHN3aXRjaCAodG91 Y2hFdmVudC0+dHlwZSkgewogICAgIGNhc2UgR0RLX1RPVUNIX0JFR0lOOiB7CiAgICAgICAgIEFT U0VSVCghcHJpdi0+dG91Y2hFdmVudHMuY29udGFpbnMoc2VxdWVuY2UpKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuY3BwIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAKaW5kZXggN2Ux NTc3Y2JhOGIxNTcwNTI2NGU1YmE1NDc1ZmZjNTk2MmRhYjg4OS4uNDQxNzdjZGQ1NmFjNGE4MTRi NWE5OGQ4ODAxYTdmZjNiMWQxMjAxNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAKQEAgLTQ4LDYgKzQ4LDE4IEBAIEdlc3R1cmVD b250cm9sbGVyOjpHZXN0dXJlQ29udHJvbGxlcihXZWJQYWdlUHJveHkmIHBhZ2UpCiBib29sIEdl c3R1cmVDb250cm9sbGVyOjpoYW5kbGVFdmVudChjb25zdCBHZGtFdmVudCogZXZlbnQpCiB7CiAg ICAgYm9vbCB3YXNQcm9jZXNzaW5nR2VzdHVyZXMgPSBpc1Byb2Nlc3NpbmdHZXN0dXJlcygpOwor ICAgIC8vIFJlY2VpdmVkIHRvdWNodXBkYXRlL2VuZCB3aXRob3V0IHRvdWNoYmVnaW4sIGlnbm9y ZSBldmVudHMuCisgICAgaWYgKCF3YXNQcm9jZXNzaW5nR2VzdHVyZXMgJiYgKGV2ZW50LT50eXBl ID09IEdES19UT1VDSF9VUERBVEUgfHwgZXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX0VORCkpIHsK KyAgICAgICAgbV9kcmFnR2VzdHVyZS5yZXNldCgpOworICAgICAgICBtX3pvb21HZXN0dXJlLnJl c2V0KCk7CisgICAgICAgIHJldHVybiBGQUxTRTsKKyAgICB9CisgICAgLy8gUmVjZWl2ZWQgdG91 Y2hiZWdpbiB3aGlsZSBzdGlsbCBwcm9jZXNzaW5nIGFub3RoZXIgdG91Y2ggc2VxdWVuY2UsIGNh bmNlbCBwcmV2aW91cyBzZXF1ZW5jZS4KKyAgICBpZiAod2FzUHJvY2Vzc2luZ0dlc3R1cmVzICYm IGV2ZW50LT50eXBlID09IEdES19UT1VDSF9CRUdJTikgeworICAgICAgICBtX2RyYWdHZXN0dXJl LnJlc2V0KCk7CisgICAgICAgIG1fem9vbUdlc3R1cmUucmVzZXQoKTsKKyAgICB9CisKICAgICBt X2RyYWdHZXN0dXJlLmhhbmRsZUV2ZW50KGV2ZW50KTsKICAgICBtX3pvb21HZXN0dXJlLmhhbmRs ZUV2ZW50KGV2ZW50KTsKICAgICByZXR1cm4gZXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX0VORCA/ IHdhc1Byb2Nlc3NpbmdHZXN0dXJlcyA6IGlzUHJvY2Vzc2luZ0dlc3R1cmVzKCk7CkBAIC02NSw2 ICs3NywxMSBAQCBHZXN0dXJlQ29udHJvbGxlcjo6R2VzdHVyZTo6R2VzdHVyZShHdGtHZXN0dXJl KiBnZXN0dXJlLCBXZWJQYWdlUHJveHkmIHBhZ2UpCiAgICAgZ3RrX2V2ZW50X2NvbnRyb2xsZXJf c2V0X3Byb3BhZ2F0aW9uX3BoYXNlKEdUS19FVkVOVF9DT05UUk9MTEVSKG1fZ2VzdHVyZS5nZXQo KSksIEdUS19QSEFTRV9OT05FKTsKIH0KIAordm9pZCBHZXN0dXJlQ29udHJvbGxlcjo6R2VzdHVy ZTo6cmVzZXQoKQoreworICAgIGd0a19ldmVudF9jb250cm9sbGVyX3Jlc2V0KEdUS19FVkVOVF9D T05UUk9MTEVSKG1fZ2VzdHVyZS5nZXQoKSkpOworfQorCiBib29sIEdlc3R1cmVDb250cm9sbGVy OjpHZXN0dXJlOjppc0FjdGl2ZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGd0a19nZXN0dXJlX2lz X2FjdGl2ZShtX2dlc3R1cmUuZ2V0KCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L2d0ay9HZXN0dXJlQ29udHJvbGxlci5oCmluZGV4IDg2NzkyZGY0MmNmNGMzNGY4OWQ4ZGZkN2Mw MTkxMTk5MDQxNjc0Y2EuLmMxMTFhODE1M2Q3MjJmYTNhNDk3NjU0ODJmMWQ1OTdiMTg2MTI0Yjcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xs ZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVy LmgKQEAgLTUyLDYgKzUyLDcgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBjbGFzcyBHZXN0dXJl IHsKICAgICBwdWJsaWM6CisgICAgICAgIHZvaWQgcmVzZXQoKTsKICAgICAgICAgYm9vbCBpc0Fj dGl2ZSgpIGNvbnN0OwogICAgICAgICB2b2lkIGhhbmRsZUV2ZW50KGNvbnN0IEdka0V2ZW50Kik7 CiAK 281268 2016-06-14 11:36:04 -0700 2016-06-14 18:59:06 -0700 Patch bug-158531-20160614153738.patch text/plain 7485 andrunko U3VidmVyc2lvbiBSZXZpc2lvbjogMjAxODEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZDZkZmVkNDQ5MDQ2YjMx OTc2NmRhODA2NDI3ZDRhNzA0ZmJhMTUxMi4uYTAyYWRlNTkxYzFmNGRmNWJmOWFkODdhMmQyMmNh YjQyZTdjOTY3MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDE2LTA2LTE0ICBBbmRy ZSBNb3JlaXJhIE1hZ2FsaGFlcyAgIDxhbmRyZS5tYWdhbGhhZXNAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFdlYktpdDJHVEsrIGRvZXMgbm90IGhhbmRsZSB0b3VjaG1vdmUgYW5kIHRvdWNo ZW5kIGV2ZW50cyBjb3JyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE1ODUzMQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIERvIG5vdCBieXBhc3MgV2ViQ29yZSBldmVudCBoYW5kbGluZyB3aGVuIHJl Y2VpdmluZyB0b3VjaCBldmVudHMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9QYWdl Q2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsOjpkb25lV2l0 aFRvdWNoRXZlbnQpOiBNYWtlIHN1cmUgdG91Y2hlbmQgcmVhY2hzIGdlc3R1cmUgY29udHJvbGxl cgorICAgICAgICBpZiB0b3VjaGJlZ2luIGV2ZXIgZ290IHRvIGl0LgorICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZp ZXdCYXNlVG91Y2hFdmVudCk6IERvIG5vdCBpbnZva2UgZ2VzdHVyZSBjb250cm9sbGVyIGRpcmVj dGx5IGJ5CisgICAgICAgIGJ5cGFzc2luZyBXZWJDb3JlIGV2ZW50IGhhbmRsaW5nLgorICAgICAg ICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViS2l0 OjpHZXN0dXJlQ29udHJvbGxlcjo6aGFuZGxlRXZlbnQpOiBSZXNldCBnZXN0dXJlIGNvbnRyb2xs ZXIgd2hlbiB0b3VjaHVwZGF0ZS9lbmQgaXMKKyAgICAgICAgcmVjZWl2ZWQgd2l0aG91dCB0b3Vj aGJlZ2luIG9yIHRvdWNoYmVnaW4gaXMgcmVjZWl2ZWQgd2l0aCB0aGUgc2FtZSB0b3VjaCBzZXF1 ZW5jZSB3aGlsZQorICAgICAgICBzdGlsbCBwcm9jZXNzaW5nIHRoZSBzZXF1ZW5jZSAoYmVmb3Jl IHRvdWNoZW5kKS4KKyAgICAgICAgKFdlYktpdDo6R2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmU6 OnJlc2V0KToKKyAgICAgICAgKFdlYktpdDo6R2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmU6Omhh bmRsZXNTZXF1ZW5jZSk6CisgICAgICAgICogVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxl ci5oOgorCiAyMDE2LTA2LTA2ICBBbnR0aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4KIAog ICAgICAgICBXZWJLaXQgbWVtb3J5IGNhY2hlIGRvZXNuJ3QgcmVzcGVjdCBWYXJ5IGhlYWRlcgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudElt cGwuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu Y3BwCmluZGV4IDNjMmY4NmVhYjNlMGU3MmQyOWQxY2U0MTQ0MDE2YjI0M2E1ZjQ2NDUuLjA1OGEx ZTdlMjAxMzg3N2JlYzU5ODEyMjY3ZGFhMDljZTY2N2VkY2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTMyOCwxOCAr MzI4LDI1IEBAIHZvaWQgUGFnZUNsaWVudEltcGw6OmJlZ2FuRXhpdEZ1bGxTY3JlZW4oY29uc3Qg SW50UmVjdCYgLyogaW5pdGlhbEZyYW1lICovLCBjb25zCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5U UykKIHZvaWQgUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoVG91Y2hFdmVudChjb25zdCBOYXRpdmVX ZWJUb3VjaEV2ZW50JiBldmVudCwgYm9vbCB3YXNFdmVudEhhbmRsZWQpCiB7Ci0gICAgaWYgKHdh c0V2ZW50SGFuZGxlZCkKLSAgICAgICAgcmV0dXJuOworICAgIGNvbnN0IEdka0V2ZW50KiB0b3Vj aEV2ZW50ID0gZXZlbnQubmF0aXZlRXZlbnQoKTsKIAogI2lmIEhBVkUoR1RLX0dFU1RVUkVTKQog ICAgIEdlc3R1cmVDb250cm9sbGVyJiBnZXN0dXJlQ29udHJvbGxlciA9IHdlYmtpdFdlYlZpZXdC YXNlR2VzdHVyZUNvbnRyb2xsZXIoV0VCS0lUX1dFQl9WSUVXX0JBU0UobV92aWV3V2lkZ2V0KSk7 Ci0gICAgaWYgKGdlc3R1cmVDb250cm9sbGVyLmhhbmRsZUV2ZW50KGV2ZW50Lm5hdGl2ZUV2ZW50 KCkpKQotICAgICAgICByZXR1cm47CisgICAgaWYgKCF3YXNFdmVudEhhbmRsZWQgfHwgKHRvdWNo RXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX0VORCAmJiBnZXN0dXJlQ29udHJvbGxlci5pc1Byb2Nl c3NpbmdHZXN0dXJlcygpKSkgeworICAgICAgICAvLyBJZ25vcmVkIGF0dGVtcHQgdG8gY2FuY2Vs IGFuIEVORCB0b3VjaCBldmVudCB3aGlsZSBhIEJFR0lOIHRvdWNoIGV2ZW50IHdhcyBwcm9jZXNz ZWQKKyAgICAgICAgLy8gYnkgdGhlIGdlc3R1cmUgY29udHJvbGxlciAod2Fzbid0IGhhbmRsZWQg YnkgV2ViUHJvY2VzcyksIGZvciBleGFtcGxlIGJlY2F1c2UKKyAgICAgICAgLy8gc2Nyb2xsaW5n IGlzIGluIHByb2dyZXNzIGFuZCBjYW5ub3QgYmUgaW50ZXJydXB0ZWQgLSBpZiB3ZSBhcmUgYWxy ZWFkeSBwcm9jZXNzaW5nCisgICAgICAgIC8vIGdlc3R1cmVzIGlzIGJlY2F1c2UgdGhlIFdlYlBy b2Nlc3MgZGlkbid0IGhhbmRsZSB0aGUgQkVHSU4gdG91Y2ggZXZlbnQsCisgICAgICAgIC8vIHNv IGxldHMgcGFzcyB0aGUgRU5EIHRvdWNoIGV2ZW50IHRvIHRoZSBHZXN0dXJlQ29udHJvbGxlciBl dmVuIGlmIGl0IHdhcworICAgICAgICAvLyBoYW5kbGVkIGJ5IHRoZSBXZWJQcm9jZXNzLgorICAg ICAgICB3YXNFdmVudEhhbmRsZWQgPSBnZXN0dXJlQ29udHJvbGxlci5oYW5kbGVFdmVudChldmVu dC5uYXRpdmVFdmVudCgpKTsKKyAgICB9CiAjZW5kaWYKIAotICAgIC8vIEVtdWxhdGUgcG9pbnRl ciBldmVudHMgaWYgdW5oYW5kbGVkLgotICAgIGNvbnN0IEdka0V2ZW50KiB0b3VjaEV2ZW50ID0g ZXZlbnQubmF0aXZlRXZlbnQoKTsKKyAgICBpZiAod2FzRXZlbnRIYW5kbGVkKQorICAgICAgICBy ZXR1cm47CiAKKyAgICAvLyBFbXVsYXRlIHBvaW50ZXIgZXZlbnRzIGlmIHVuaGFuZGxlZC4KICAg ICBpZiAoIXRvdWNoRXZlbnQtPnRvdWNoLmVtdWxhdGluZ19wb2ludGVyKQogICAgICAgICByZXR1 cm47CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYlZpZXdCYXNlLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYlZpZXdCYXNlLmNwcAppbmRleCBjYjBhZTMzNzcxYTZjZmVmMjY2MjViN2QwNGJiMTFkZTUz ZmViYTc3Li5kNzg3NTcxNzVlYWU3NjYwNDFiZmU1ZDAzZWFmNTM3ZDRlMjI1ZDM1IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jh c2UuY3BwCkBAIC05ODgsMjAgKzk4OCw2IEBAIHN0YXRpYyBnYm9vbGVhbiB3ZWJraXRXZWJWaWV3 QmFzZVRvdWNoRXZlbnQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0V2ZW50VG91Y2gqIGV2CiAgICAg R2RrRXZlbnQqIHRvdWNoRXZlbnQgPSByZWludGVycHJldF9jYXN0PEdka0V2ZW50Kj4oZXZlbnQp OwogICAgIHVpbnQzMl90IHNlcXVlbmNlID0gR1BPSU5URVJfVE9fVUlOVChnZGtfZXZlbnRfZ2V0 X2V2ZW50X3NlcXVlbmNlKHRvdWNoRXZlbnQpKTsKIAotI2lmIEhBVkUoR1RLX0dFU1RVUkVTKQot ICAgIEdlc3R1cmVDb250cm9sbGVyJiBnZXN0dXJlQ29udHJvbGxlciA9IHdlYmtpdFdlYlZpZXdC YXNlR2VzdHVyZUNvbnRyb2xsZXIod2ViVmlld0Jhc2UpOwotICAgIGlmIChnZXN0dXJlQ29udHJv bGxlci5pc1Byb2Nlc3NpbmdHZXN0dXJlcygpKSB7Ci0gICAgICAgIC8vIElmIHdlIGFyZSBhbHJl YWR5IHByb2Nlc3NpbmcgZ2VzdHVyZXMgaXMgYmVjYXVzZSB0aGUgV2ViUHJvY2VzcyBkaWRuJ3Qg aGFuZGxlIHRoZQotICAgICAgICAvLyBCRUdJTiB0b3VjaCBldmVudCwgc28gcGFzcyBzdWJzZXF1 ZW50IGV2ZW50cyB0byB0aGUgR2VzdHVyZUNvbnRyb2xsZXIuCi0gICAgICAgIGdlc3R1cmVDb250 cm9sbGVyLmhhbmRsZUV2ZW50KHRvdWNoRXZlbnQpOwotICAgICAgICAvLyBSZW1vdmUgdGhlIGdl c3R1cmUgZXZlbnQgc2VxdWVuY2UgZnJvbSB0aGUgaGFuZGxlZCB0b3VjaCBldmVudHMKLSAgICAg ICAgLy8gbGlzdCB0byBhdm9pZCB0aGUgZ2VzdXJlIHNlcXVlbmNlIGFuZCBhIHRvdWNoIHNlcXVl bmNlIG9mIHNhbWUKLSAgICAgICAgLy8gSUQgdG8gY29uZmxpY3QuCi0gICAgICAgIHByaXYtPnRv dWNoRXZlbnRzLnJlbW92ZShzZXF1ZW5jZSk7Ci0gICAgICAgIHJldHVybiBUUlVFOwotICAgIH0K LSNlbmRpZgotCiAgICAgc3dpdGNoICh0b3VjaEV2ZW50LT50eXBlKSB7CiAgICAgY2FzZSBHREtf VE9VQ0hfQkVHSU46IHsKICAgICAgICAgQVNTRVJUKCFwcml2LT50b3VjaEV2ZW50cy5jb250YWlu cyhzZXF1ZW5jZSkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9H ZXN0dXJlQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1 cmVDb250cm9sbGVyLmNwcAppbmRleCA3ZTE1NzdjYmE4YjE1NzA1MjY0ZTViYTU0NzVmZmM1OTYy ZGFiODg5Li42ZjU4MTM4MjE2NzI2OTlkNTA0OTJjMDcyZDUwMTExNzQxODA4ZjFiIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVyLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVyLmNwcApA QCAtNDgsNiArNDgsMjIgQEAgR2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmVDb250cm9sbGVyKFdl YlBhZ2VQcm94eSYgcGFnZSkKIGJvb2wgR2VzdHVyZUNvbnRyb2xsZXI6OmhhbmRsZUV2ZW50KGNv bnN0IEdka0V2ZW50KiBldmVudCkKIHsKICAgICBib29sIHdhc1Byb2Nlc3NpbmdHZXN0dXJlcyA9 IGlzUHJvY2Vzc2luZ0dlc3R1cmVzKCk7CisgICAgLy8gUmVjZWl2ZWQgdG91Y2h1cGRhdGUvZW5k IHdpdGhvdXQgdG91Y2hiZWdpbiwgaWdub3JlIGV2ZW50cy4KKyAgICBpZiAoIXdhc1Byb2Nlc3Np bmdHZXN0dXJlcyAmJiAoZXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX1VQREFURSB8fCBldmVudC0+ dHlwZSA9PSBHREtfVE9VQ0hfRU5EKSkgeworICAgICAgICBtX2RyYWdHZXN0dXJlLnJlc2V0KCk7 CisgICAgICAgIG1fem9vbUdlc3R1cmUucmVzZXQoKTsKKyAgICAgICAgcmV0dXJuIEZBTFNFOwor ICAgIH0KKyAgICBpZiAod2FzUHJvY2Vzc2luZ0dlc3R1cmVzICYmIGV2ZW50LT50eXBlID09IEdE S19UT1VDSF9CRUdJTikgeworICAgICAgICAvLyBSZWNlaXZlZCB0b3VjaGJlZ2luIHdoaWxlIHN0 aWxsIHByb2Nlc3NpbmcgdGhlIHNhbWUgdG91Y2ggc2VxdWVuY2UsCisgICAgICAgIC8vIHJlc2V0 IGdlc3R1cmUgdG8gYSBjb25zaXN0ZW50IHN0YXRlLgorICAgICAgICBHZGtFdmVudFNlcXVlbmNl KiBzZXF1ZW5jZSA9IGdka19ldmVudF9nZXRfZXZlbnRfc2VxdWVuY2UoZXZlbnQpOworICAgICAg ICBpZiAobV9kcmFnR2VzdHVyZS5oYW5kbGVzU2VxdWVuY2Uoc2VxdWVuY2UpKQorICAgICAgICAg ICAgbV9kcmFnR2VzdHVyZS5yZXNldCgpOworICAgICAgICBpZiAobV96b29tR2VzdHVyZS5oYW5k bGVzU2VxdWVuY2Uoc2VxdWVuY2UpKQorICAgICAgICAgICAgbV96b29tR2VzdHVyZS5yZXNldCgp OworICAgIH0KKwogICAgIG1fZHJhZ0dlc3R1cmUuaGFuZGxlRXZlbnQoZXZlbnQpOwogICAgIG1f em9vbUdlc3R1cmUuaGFuZGxlRXZlbnQoZXZlbnQpOwogICAgIHJldHVybiBldmVudC0+dHlwZSA9 PSBHREtfVE9VQ0hfRU5EID8gd2FzUHJvY2Vzc2luZ0dlc3R1cmVzIDogaXNQcm9jZXNzaW5nR2Vz dHVyZXMoKTsKQEAgLTY1LDExICs4MSwyMSBAQCBHZXN0dXJlQ29udHJvbGxlcjo6R2VzdHVyZTo6 R2VzdHVyZShHdGtHZXN0dXJlKiBnZXN0dXJlLCBXZWJQYWdlUHJveHkmIHBhZ2UpCiAgICAgZ3Rr X2V2ZW50X2NvbnRyb2xsZXJfc2V0X3Byb3BhZ2F0aW9uX3BoYXNlKEdUS19FVkVOVF9DT05UUk9M TEVSKG1fZ2VzdHVyZS5nZXQoKSksIEdUS19QSEFTRV9OT05FKTsKIH0KIAordm9pZCBHZXN0dXJl Q29udHJvbGxlcjo6R2VzdHVyZTo6cmVzZXQoKQoreworICAgIGd0a19ldmVudF9jb250cm9sbGVy X3Jlc2V0KEdUS19FVkVOVF9DT05UUk9MTEVSKG1fZ2VzdHVyZS5nZXQoKSkpOworfQorCiBib29s IEdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJlOjppc0FjdGl2ZSgpIGNvbnN0CiB7CiAgICAgcmV0 dXJuIGd0a19nZXN0dXJlX2lzX2FjdGl2ZShtX2dlc3R1cmUuZ2V0KCkpOwogfQogCitib29sIEdl c3R1cmVDb250cm9sbGVyOjpHZXN0dXJlOjpoYW5kbGVzU2VxdWVuY2UoR2RrRXZlbnRTZXF1ZW5j ZSogc2VxdWVuY2UpIGNvbnN0Cit7CisgICAgcmV0dXJuIGd0a19nZXN0dXJlX2hhbmRsZXNfc2Vx dWVuY2UobV9nZXN0dXJlLmdldCgpLCBzZXF1ZW5jZSk7Cit9CisKIHZvaWQgR2VzdHVyZUNvbnRy b2xsZXI6Okdlc3R1cmU6OmhhbmRsZUV2ZW50KGNvbnN0IEdka0V2ZW50KiBldmVudCkKIHsKICAg ICBndGtfZXZlbnRfY29udHJvbGxlcl9oYW5kbGVfZXZlbnQoR1RLX0VWRU5UX0NPTlRST0xMRVIo bV9nZXN0dXJlLmdldCgpKSwgZXZlbnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L2d0ay9HZXN0dXJlQ29udHJvbGxlci5oCmluZGV4IDg2NzkyZGY0MmNmNGMzNGY4OWQ4ZGZkN2Mw MTkxMTk5MDQxNjc0Y2EuLmJkYzdmZjM5ZjA2NzhmODU3NzljNDBmNjBkNWNhMTk0ZTE0OTA1MzAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xs ZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVy LmgKQEAgLTUyLDcgKzUyLDkgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBjbGFzcyBHZXN0dXJl IHsKICAgICBwdWJsaWM6CisgICAgICAgIHZvaWQgcmVzZXQoKTsKICAgICAgICAgYm9vbCBpc0Fj dGl2ZSgpIGNvbnN0OworICAgICAgICBib29sIGhhbmRsZXNTZXF1ZW5jZShHZGtFdmVudFNlcXVl bmNlKikgY29uc3Q7CiAgICAgICAgIHZvaWQgaGFuZGxlRXZlbnQoY29uc3QgR2RrRXZlbnQqKTsK IAogICAgIHByb3RlY3RlZDoK 281312 2016-06-14 18:59:14 -0700 2017-08-21 15:27:14 -0700 Patch bug-158531-20160614230049.patch text/plain 6447 andrunko U3VidmVyc2lvbiBSZXZpc2lvbjogMjAxODEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZDZkZmVkNDQ5MDQ2YjMx OTc2NmRhODA2NDI3ZDRhNzA0ZmJhMTUxMi4uOTc4OGVkMDM4ZGFjM2FhNDM5YzNkNzg3ODZjMTVl NGFlMGIyMGRkOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDE2LTA2LTE0ICBBbmRy ZSBNb3JlaXJhIE1hZ2FsaGFlcyAgIDxhbmRyZS5tYWdhbGhhZXNAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFdlYktpdDJHVEsrIGRvZXMgbm90IGhhbmRsZSB0b3VjaG1vdmUgYW5kIHRvdWNo ZW5kIGV2ZW50cyBjb3JyZWN0bHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE1ODUzMQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIERvIG5vdCBieXBhc3MgV2ViQ29yZSBldmVudCBoYW5kbGluZyB3aGVuIHJl Y2VpdmluZyB0b3VjaCBldmVudHMuCisKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9QYWdl Q2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnRJbXBsOjpkb25lV2l0 aFRvdWNoRXZlbnQpOiBNYWtlIHN1cmUgdG91Y2hlbmQgcmVhY2hzIGdlc3R1cmUgY29udHJvbGxl cgorICAgICAgICBpZiB0b3VjaGJlZ2luIGV2ZXIgZ290IHRvIGl0LgorICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZp ZXdCYXNlVG91Y2hFdmVudCk6IERvIG5vdCBpbnZva2UgZ2VzdHVyZSBjb250cm9sbGVyIGRpcmVj dGx5IGJ5CisgICAgICAgIGJ5cGFzc2luZyBXZWJDb3JlIGV2ZW50IGhhbmRsaW5nLgorICAgICAg ICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViS2l0 OjpHZXN0dXJlQ29udHJvbGxlcjo6aGFuZGxlRXZlbnQpOiBSZXNldCBnZXN0dXJlIGNvbnRyb2xs ZXIgd2hlbiB0b3VjaHVwZGF0ZS9lbmQgaXMKKyAgICAgICAgcmVjZWl2ZWQgd2l0aG91dCB0b3Vj aGJlZ2luLgorICAgICAgICAoV2ViS2l0OjpHZXN0dXJlQ29udHJvbGxlcjo6R2VzdHVyZTo6cmVz ZXQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaDoKKwogMjAx Ni0wNi0wNiAgQW50dGkgS29pdmlzdG8gIDxhbnR0aUBhcHBsZS5jb20+CiAKICAgICAgICAgV2Vi S2l0IG1lbW9yeSBjYWNoZSBkb2Vzbid0IHJlc3BlY3QgVmFyeSBoZWFkZXIKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcCBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAppbmRleCAz YzJmODZlYWIzZTBlNzJkMjlkMWNlNDE0NDAxNmIyNDNhNWY0NjQ1Li4wNThhMWU3ZTIwMTM4Nzdi ZWM1OTgxMjI2N2RhYTA5Y2U2NjdlZGNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCkBAIC0zMjgsMTggKzMyOCwyNSBAQCB2 b2lkIFBhZ2VDbGllbnRJbXBsOjpiZWdhbkV4aXRGdWxsU2NyZWVuKGNvbnN0IEludFJlY3QmIC8q IGluaXRpYWxGcmFtZSAqLywgY29ucwogI2lmIEVOQUJMRShUT1VDSF9FVkVOVFMpCiB2b2lkIFBh Z2VDbGllbnRJbXBsOjpkb25lV2l0aFRvdWNoRXZlbnQoY29uc3QgTmF0aXZlV2ViVG91Y2hFdmVu dCYgZXZlbnQsIGJvb2wgd2FzRXZlbnRIYW5kbGVkKQogewotICAgIGlmICh3YXNFdmVudEhhbmRs ZWQpCi0gICAgICAgIHJldHVybjsKKyAgICBjb25zdCBHZGtFdmVudCogdG91Y2hFdmVudCA9IGV2 ZW50Lm5hdGl2ZUV2ZW50KCk7CiAKICNpZiBIQVZFKEdUS19HRVNUVVJFUykKICAgICBHZXN0dXJl Q29udHJvbGxlciYgZ2VzdHVyZUNvbnRyb2xsZXIgPSB3ZWJraXRXZWJWaWV3QmFzZUdlc3R1cmVD b250cm9sbGVyKFdFQktJVF9XRUJfVklFV19CQVNFKG1fdmlld1dpZGdldCkpOwotICAgIGlmIChn ZXN0dXJlQ29udHJvbGxlci5oYW5kbGVFdmVudChldmVudC5uYXRpdmVFdmVudCgpKSkKLSAgICAg ICAgcmV0dXJuOworICAgIGlmICghd2FzRXZlbnRIYW5kbGVkIHx8ICh0b3VjaEV2ZW50LT50eXBl ID09IEdES19UT1VDSF9FTkQgJiYgZ2VzdHVyZUNvbnRyb2xsZXIuaXNQcm9jZXNzaW5nR2VzdHVy ZXMoKSkpIHsKKyAgICAgICAgLy8gSWdub3JlZCBhdHRlbXB0IHRvIGNhbmNlbCBhbiBFTkQgdG91 Y2ggZXZlbnQgd2hpbGUgYSBCRUdJTiB0b3VjaCBldmVudCB3YXMgcHJvY2Vzc2VkCisgICAgICAg IC8vIGJ5IHRoZSBnZXN0dXJlIGNvbnRyb2xsZXIgKHdhc24ndCBoYW5kbGVkIGJ5IFdlYlByb2Nl c3MpLCBmb3IgZXhhbXBsZSBiZWNhdXNlCisgICAgICAgIC8vIHNjcm9sbGluZyBpcyBpbiBwcm9n cmVzcyBhbmQgY2Fubm90IGJlIGludGVycnVwdGVkIC0gaWYgd2UgYXJlIGFscmVhZHkgcHJvY2Vz c2luZworICAgICAgICAvLyBnZXN0dXJlcyBpcyBiZWNhdXNlIHRoZSBXZWJQcm9jZXNzIGRpZG4n dCBoYW5kbGUgdGhlIEJFR0lOIHRvdWNoIGV2ZW50LAorICAgICAgICAvLyBzbyBsZXRzIHBhc3Mg dGhlIEVORCB0b3VjaCBldmVudCB0byB0aGUgR2VzdHVyZUNvbnRyb2xsZXIgZXZlbiBpZiBpdCB3 YXMKKyAgICAgICAgLy8gaGFuZGxlZCBieSB0aGUgV2ViUHJvY2Vzcy4KKyAgICAgICAgd2FzRXZl bnRIYW5kbGVkID0gZ2VzdHVyZUNvbnRyb2xsZXIuaGFuZGxlRXZlbnQoZXZlbnQubmF0aXZlRXZl bnQoKSk7CisgICAgfQogI2VuZGlmCiAKLSAgICAvLyBFbXVsYXRlIHBvaW50ZXIgZXZlbnRzIGlm IHVuaGFuZGxlZC4KLSAgICBjb25zdCBHZGtFdmVudCogdG91Y2hFdmVudCA9IGV2ZW50Lm5hdGl2 ZUV2ZW50KCk7CisgICAgaWYgKHdhc0V2ZW50SGFuZGxlZCkKKyAgICAgICAgcmV0dXJuOwogCisg ICAgLy8gRW11bGF0ZSBwb2ludGVyIGV2ZW50cyBpZiB1bmhhbmRsZWQuCiAgICAgaWYgKCF0b3Vj aEV2ZW50LT50b3VjaC5lbXVsYXRpbmdfcG9pbnRlcikKICAgICAgICAgcmV0dXJuOwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFz ZS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFz ZS5jcHAKaW5kZXggY2IwYWUzMzc3MWE2Y2ZlZjI2NjI1YjdkMDRiYjExZGU1M2ZlYmE3Ny4uZDc4 NzU3MTc1ZWFlNzY2MDQxYmZlNWQwM2VhZjUzN2Q0ZTIyNWQzNSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcApAQCAt OTg4LDIwICs5ODgsNiBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2ViVmlld0Jhc2VUb3VjaEV2 ZW50KEd0a1dpZGdldCogd2lkZ2V0LCBHZGtFdmVudFRvdWNoKiBldgogICAgIEdka0V2ZW50KiB0 b3VjaEV2ZW50ID0gcmVpbnRlcnByZXRfY2FzdDxHZGtFdmVudCo+KGV2ZW50KTsKICAgICB1aW50 MzJfdCBzZXF1ZW5jZSA9IEdQT0lOVEVSX1RPX1VJTlQoZ2RrX2V2ZW50X2dldF9ldmVudF9zZXF1 ZW5jZSh0b3VjaEV2ZW50KSk7CiAKLSNpZiBIQVZFKEdUS19HRVNUVVJFUykKLSAgICBHZXN0dXJl Q29udHJvbGxlciYgZ2VzdHVyZUNvbnRyb2xsZXIgPSB3ZWJraXRXZWJWaWV3QmFzZUdlc3R1cmVD b250cm9sbGVyKHdlYlZpZXdCYXNlKTsKLSAgICBpZiAoZ2VzdHVyZUNvbnRyb2xsZXIuaXNQcm9j ZXNzaW5nR2VzdHVyZXMoKSkgewotICAgICAgICAvLyBJZiB3ZSBhcmUgYWxyZWFkeSBwcm9jZXNz aW5nIGdlc3R1cmVzIGlzIGJlY2F1c2UgdGhlIFdlYlByb2Nlc3MgZGlkbid0IGhhbmRsZSB0aGUK LSAgICAgICAgLy8gQkVHSU4gdG91Y2ggZXZlbnQsIHNvIHBhc3Mgc3Vic2VxdWVudCBldmVudHMg dG8gdGhlIEdlc3R1cmVDb250cm9sbGVyLgotICAgICAgICBnZXN0dXJlQ29udHJvbGxlci5oYW5k bGVFdmVudCh0b3VjaEV2ZW50KTsKLSAgICAgICAgLy8gUmVtb3ZlIHRoZSBnZXN0dXJlIGV2ZW50 IHNlcXVlbmNlIGZyb20gdGhlIGhhbmRsZWQgdG91Y2ggZXZlbnRzCi0gICAgICAgIC8vIGxpc3Qg dG8gYXZvaWQgdGhlIGdlc3VyZSBzZXF1ZW5jZSBhbmQgYSB0b3VjaCBzZXF1ZW5jZSBvZiBzYW1l Ci0gICAgICAgIC8vIElEIHRvIGNvbmZsaWN0LgotICAgICAgICBwcml2LT50b3VjaEV2ZW50cy5y ZW1vdmUoc2VxdWVuY2UpOwotICAgICAgICByZXR1cm4gVFJVRTsKLSAgICB9Ci0jZW5kaWYKLQog ICAgIHN3aXRjaCAodG91Y2hFdmVudC0+dHlwZSkgewogICAgIGNhc2UgR0RLX1RPVUNIX0JFR0lO OiB7CiAgICAgICAgIEFTU0VSVCghcHJpdi0+dG91Y2hFdmVudHMuY29udGFpbnMoc2VxdWVuY2Up KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRy b2xsZXIuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxl ci5jcHAKaW5kZXggN2UxNTc3Y2JhOGIxNTcwNTI2NGU1YmE1NDc1ZmZjNTk2MmRhYjg4OS4uMzQx MTExYzg3Nzc4YTFkZTkzZmE1OWVjYjQ3YjJmOTMzZDAwZGYwOSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAKQEAgLTQ4LDYgKzQ4 LDEzIEBAIEdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJlQ29udHJvbGxlcihXZWJQYWdlUHJveHkm IHBhZ2UpCiBib29sIEdlc3R1cmVDb250cm9sbGVyOjpoYW5kbGVFdmVudChjb25zdCBHZGtFdmVu dCogZXZlbnQpCiB7CiAgICAgYm9vbCB3YXNQcm9jZXNzaW5nR2VzdHVyZXMgPSBpc1Byb2Nlc3Np bmdHZXN0dXJlcygpOworICAgIC8vIFJlY2VpdmVkIHRvdWNodXBkYXRlL2VuZCB3aXRob3V0IHRv dWNoYmVnaW4sIGlnbm9yZSBldmVudHMuCisgICAgaWYgKCF3YXNQcm9jZXNzaW5nR2VzdHVyZXMg JiYgKGV2ZW50LT50eXBlID09IEdES19UT1VDSF9VUERBVEUgfHwgZXZlbnQtPnR5cGUgPT0gR0RL X1RPVUNIX0VORCkpIHsKKyAgICAgICAgbV9kcmFnR2VzdHVyZS5yZXNldCgpOworICAgICAgICBt X3pvb21HZXN0dXJlLnJlc2V0KCk7CisgICAgICAgIHJldHVybiBGQUxTRTsKKyAgICB9CisKICAg ICBtX2RyYWdHZXN0dXJlLmhhbmRsZUV2ZW50KGV2ZW50KTsKICAgICBtX3pvb21HZXN0dXJlLmhh bmRsZUV2ZW50KGV2ZW50KTsKICAgICByZXR1cm4gZXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX0VO RCA/IHdhc1Byb2Nlc3NpbmdHZXN0dXJlcyA6IGlzUHJvY2Vzc2luZ0dlc3R1cmVzKCk7CkBAIC02 NSw2ICs3MiwxMSBAQCBHZXN0dXJlQ29udHJvbGxlcjo6R2VzdHVyZTo6R2VzdHVyZShHdGtHZXN0 dXJlKiBnZXN0dXJlLCBXZWJQYWdlUHJveHkmIHBhZ2UpCiAgICAgZ3RrX2V2ZW50X2NvbnRyb2xs ZXJfc2V0X3Byb3BhZ2F0aW9uX3BoYXNlKEdUS19FVkVOVF9DT05UUk9MTEVSKG1fZ2VzdHVyZS5n ZXQoKSksIEdUS19QSEFTRV9OT05FKTsKIH0KIAordm9pZCBHZXN0dXJlQ29udHJvbGxlcjo6R2Vz dHVyZTo6cmVzZXQoKQoreworICAgIGd0a19ldmVudF9jb250cm9sbGVyX3Jlc2V0KEdUS19FVkVO VF9DT05UUk9MTEVSKG1fZ2VzdHVyZS5nZXQoKSkpOworfQorCiBib29sIEdlc3R1cmVDb250cm9s bGVyOjpHZXN0dXJlOjppc0FjdGl2ZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGd0a19nZXN0dXJl X2lzX2FjdGl2ZShtX2dlc3R1cmUuZ2V0KCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oCmluZGV4IDg2NzkyZGY0MmNmNGMzNGY4OWQ4ZGZk N2MwMTkxMTk5MDQxNjc0Y2EuLmMxMTFhODE1M2Q3MjJmYTNhNDk3NjU0ODJmMWQ1OTdiMTg2MTI0 YjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRy b2xsZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9s bGVyLmgKQEAgLTUyLDYgKzUyLDcgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBjbGFzcyBHZXN0 dXJlIHsKICAgICBwdWJsaWM6CisgICAgICAgIHZvaWQgcmVzZXQoKTsKICAgICAgICAgYm9vbCBp c0FjdGl2ZSgpIGNvbnN0OwogICAgICAgICB2b2lkIGhhbmRsZUV2ZW50KGNvbnN0IEdka0V2ZW50 Kik7CiAK 318679 2017-08-21 15:28:33 -0700 2017-08-21 16:41:08 -0700 Patch bug-158531-20170822012832.patch text/plain 6403 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwOTg0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDU4MzBlYmI5MDVhZDYwOTkx NTI1Nzc2MjllNzJiZjJjYWJmZDUwOTAuLjhkYTk0ZDY5Nzk0NzIyZmQ2NTdiZTQ0OGFiNjc4NjYz MTkyNWY1NzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTctMDgtMjEgIEFkcmlhbiBQ ZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBXZWJL aXQyR1RLKyBkb2VzIG5vdCBoYW5kbGUgdG91Y2htb3ZlIGFuZCB0b3VjaGVuZCBldmVudHMgY29y cmVjdGx5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NTg1MzEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBE byBub3QgYnlwYXNzIFdlYkNvcmUgZXZlbnQgaGFuZGxpbmcgd2hlbiByZWNlaXZpbmcgdG91Y2gg ZXZlbnRzLgorCisgICAgICAgIEJhc2VkIG9uIGEgcGF0Y2ggYnkgQW5kcmUgTW9yZWlyYSBNYWdh bGhhZXMgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+LgorCisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpQYWdl Q2xpZW50SW1wbDo6ZG9uZVdpdGhUb3VjaEV2ZW50KTogTWFrZSBzdXJlIHRvdWNoZW5kIHJlYWNo ZXMgZ2VzdHVyZSBjb250cm9sbGVyIGlmIHRvdWNoYmVnaW4gZXZldCBnb3QgdG8gaXQuCisgICAg ICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwOgorICAgICAgICAo d2Via2l0V2ViVmlld0Jhc2VUb3VjaEV2ZW50KTogRG8gbm90IGludm9rZSBnZXN0dXJlIGNvbnRy b2xsZXIgZGlyZWN0bHkgYnkgYnlwYXNzaW5nIFdlYkNvcmUgZXZlbnQgaGFuZGxpbmcuCisgICAg ICAgICogVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHA6CisgICAgICAgIChXZWJL aXQ6Okdlc3R1cmVDb250cm9sbGVyOjpoYW5kbGVFdmVudCk6IFJlc2V0IGdlc3R1cmUgY29udHJv bGxlciB3aGVuIHRvdWNocGFkdXBkYXRlL2VuZCBpcyByZWNlaXZlZCB3aXRob3V0IHRvdWNoYmVn aW4uCisgICAgICAgIChXZWJLaXQ6Okdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJlOjpyZXNldCk6 IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaDoKKwog MjAxNy0wOC0yMSAgWW9zaGlha2kgSml0c3VrYXdhICA8WW9zaGlha2kuSml0c3VrYXdhQHNvbnku Y29tPgogCiAgICAgICAgIFtQQUxdIE1vdmUgc3BpL21hYyBkaXJlY3RvcnkgaW50byBQQUwKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu Y3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAK aW5kZXggMjI5M2NiMjQwMmMxNmJjZmI0MTY4ODIwMjE1MGI3NDE0NTk1NGE3MC4uOWY5ZTRkMWY1 YmI5NjMxYWQ0ZGY4YmFkYzZhZTAyYWVhN2ZmN2U3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTM0MiwxOCArMzQyLDI1 IEBAIHZvaWQgUGFnZUNsaWVudEltcGw6OmJlZ2FuRXhpdEZ1bGxTY3JlZW4oY29uc3QgSW50UmVj dCYgLyogaW5pdGlhbEZyYW1lICovLCBjb25zCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKIHZv aWQgUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoVG91Y2hFdmVudChjb25zdCBOYXRpdmVXZWJUb3Vj aEV2ZW50JiBldmVudCwgYm9vbCB3YXNFdmVudEhhbmRsZWQpCiB7Ci0gICAgaWYgKHdhc0V2ZW50 SGFuZGxlZCkKLSAgICAgICAgcmV0dXJuOworICAgIGNvbnN0IEdka0V2ZW50KiB0b3VjaEV2ZW50 ID0gZXZlbnQubmF0aXZlRXZlbnQoKTsKIAogI2lmIEhBVkUoR1RLX0dFU1RVUkVTKQogICAgIEdl c3R1cmVDb250cm9sbGVyJiBnZXN0dXJlQ29udHJvbGxlciA9IHdlYmtpdFdlYlZpZXdCYXNlR2Vz dHVyZUNvbnRyb2xsZXIoV0VCS0lUX1dFQl9WSUVXX0JBU0UobV92aWV3V2lkZ2V0KSk7Ci0gICAg aWYgKGdlc3R1cmVDb250cm9sbGVyLmhhbmRsZUV2ZW50KGV2ZW50Lm5hdGl2ZUV2ZW50KCkpKQot ICAgICAgICByZXR1cm47CisgICAgaWYgKCF3YXNFdmVudEhhbmRsZWQgfHwgKHRvdWNoRXZlbnQt PnR5cGUgPT0gR1RLX1RPVUNIX0VORCAmJiBnZXN0dXJlQ29udHJvbGxlci5pc1Byb2Nlc3NpbmdH ZXN0dXJlcygpKSkgeworICAgICAgICAvLyBJZ25vcmVkIGF0dGVtcHQgdG8gY2FuY2VsIGFuIEVO RCB0b3VjaCBldmVudCB3aGlsZSBhIEJFR0lOIHRvdWNoIGV2ZW50IHdhcyBwcm9jZXNzZWQKKyAg ICAgICAgLy8gYnkgdGhlIGdlc3R1cmUgY29udHJvbGxlciAod2Fzbid0IGhhbmRsZWQgYnkgV2Vi UHJvY2VzcyksIGZvciBleGFtcGxlIGJlY2F1c2UKKyAgICAgICAgLy8gc2Nyb2xsaW5nIGlzIGlu IHByb2dyZXNzIGFuZCBjYW5ub3QgYmUgaW50ZXJydXB0ZWQgLSBpZiB3ZSBhcmUgYWxyZWFkeSBw cm9jZXNzaW5nCisgICAgICAgIC8vIGdlc3R1cmVzIGlzIGJlY2F1c2UgdGhlIFdlYlByb2Nlc3Mg ZGlkbid0IGhhbmRsZSB0aGUgQkVHSU4gdG91Y2ggZXZlbnQsCisgICAgICAgIC8vIHNvIGxldHMg cGFzcyB0aGUgRU5EIHRvdWNoIGV2ZW50IHRvIHRoZSBHZXN0dXJlQ29udHJvbGxlciBldmVuIGlm IGl0IHdhcworICAgICAgICAvLyBoYW5kbGVkIGJ5IHRoZSBXZWJQcm9jZXNzLgorICAgICAgICB3 YXNFdmVudEhhbmRsZWQgPSBnZXN0dXJlQ29udHJvbGxlci5oYW5kbGVFdmVudChldmVudC5uYXRp dmVFdmVudCgpKTsKKyAgICB9CiAjZW5kaWYKIAorICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCisg ICAgICAgIHJldHVybjsKKwogICAgIC8vIEVtdWxhdGUgcG9pbnRlciBldmVudHMgaWYgdW5oYW5k bGVkLgotICAgIGNvbnN0IEdka0V2ZW50KiB0b3VjaEV2ZW50ID0gZXZlbnQubmF0aXZlRXZlbnQo KTsKLQogICAgIGlmICghdG91Y2hFdmVudC0+dG91Y2guZW11bGF0aW5nX3BvaW50ZXIpCiAgICAg ICAgIHJldHVybjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdCYXNlLmNwcAppbmRleCBlNGYwNTEwYTMyOGY2MmJmZmNiZTZlMTllZTQx OGQ0ZTlhMWRkNTgzLi5kZmEwZTU0OGQ4NDNkMWJlMGYyZjkwOTc0Zjc5MmQ2YjhiNDY4OTg4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdC YXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZp ZXdCYXNlLmNwcApAQCAtOTI3LDIwICs5MjcsNiBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2Vi Vmlld0Jhc2VUb3VjaEV2ZW50KEd0a1dpZGdldCogd2lkZ2V0LCBHZGtFdmVudFRvdWNoKiBldgog ICAgIEdka0V2ZW50KiB0b3VjaEV2ZW50ID0gcmVpbnRlcnByZXRfY2FzdDxHZGtFdmVudCo+KGV2 ZW50KTsKICAgICB1aW50MzJfdCBzZXF1ZW5jZSA9IEdQT0lOVEVSX1RPX1VJTlQoZ2RrX2V2ZW50 X2dldF9ldmVudF9zZXF1ZW5jZSh0b3VjaEV2ZW50KSk7CiAKLSNpZiBIQVZFKEdUS19HRVNUVVJF UykKLSAgICBHZXN0dXJlQ29udHJvbGxlciYgZ2VzdHVyZUNvbnRyb2xsZXIgPSB3ZWJraXRXZWJW aWV3QmFzZUdlc3R1cmVDb250cm9sbGVyKHdlYlZpZXdCYXNlKTsKLSAgICBpZiAoZ2VzdHVyZUNv bnRyb2xsZXIuaXNQcm9jZXNzaW5nR2VzdHVyZXMoKSkgewotICAgICAgICAvLyBJZiB3ZSBhcmUg YWxyZWFkeSBwcm9jZXNzaW5nIGdlc3R1cmVzIGlzIGJlY2F1c2UgdGhlIFdlYlByb2Nlc3MgZGlk bid0IGhhbmRsZSB0aGUKLSAgICAgICAgLy8gQkVHSU4gdG91Y2ggZXZlbnQsIHNvIHBhc3Mgc3Vi c2VxdWVudCBldmVudHMgdG8gdGhlIEdlc3R1cmVDb250cm9sbGVyLgotICAgICAgICBnZXN0dXJl Q29udHJvbGxlci5oYW5kbGVFdmVudCh0b3VjaEV2ZW50KTsKLSAgICAgICAgLy8gUmVtb3ZlIHRo ZSBnZXN0dXJlIGV2ZW50IHNlcXVlbmNlIGZyb20gdGhlIGhhbmRsZWQgdG91Y2ggZXZlbnRzCi0g ICAgICAgIC8vIGxpc3QgdG8gYXZvaWQgdGhlIGdlc3VyZSBzZXF1ZW5jZSBhbmQgYSB0b3VjaCBz ZXF1ZW5jZSBvZiBzYW1lCi0gICAgICAgIC8vIElEIHRvIGNvbmZsaWN0LgotICAgICAgICBwcml2 LT50b3VjaEV2ZW50cy5yZW1vdmUoc2VxdWVuY2UpOwotICAgICAgICByZXR1cm4gVFJVRTsKLSAg ICB9Ci0jZW5kaWYKLQogICAgIHN3aXRjaCAodG91Y2hFdmVudC0+dHlwZSkgewogICAgIGNhc2Ug R0RLX1RPVUNIX0JFR0lOOiB7CiAgICAgICAgIEFTU0VSVCghcHJpdi0+dG91Y2hFdmVudHMuY29u dGFpbnMoc2VxdWVuY2UpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0 ay9HZXN0dXJlQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvR2Vz dHVyZUNvbnRyb2xsZXIuY3BwCmluZGV4IDExNGNjNWYxYzYxMmIxNzYwODY3MWJhNDA0NjVlMDQw ZjhmMGJlMDUuLmRkMWU1MDcwNmZmZTY0ZDkyODZhZDRjMGMwYzM3ZmFkOThiMzBmYjUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAK KysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVyLmNwcApA QCAtNDksNiArNDksMTMgQEAgR2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmVDb250cm9sbGVyKFdl YlBhZ2VQcm94eSYgcGFnZSkKIGJvb2wgR2VzdHVyZUNvbnRyb2xsZXI6OmhhbmRsZUV2ZW50KGNv bnN0IEdka0V2ZW50KiBldmVudCkKIHsKICAgICBib29sIHdhc1Byb2Nlc3NpbmdHZXN0dXJlcyA9 IGlzUHJvY2Vzc2luZ0dlc3R1cmVzKCk7CisgICAgLy8gUmVjZWl2ZWQgdG91Y2h1cGRhdGUvZW5k IHdpdGhvdXQgdG91Y2hiZWdpbiwgaWdub3JlIGV2ZW50cy4KKyAgICBpZiAoIXdhc1Byb2Nlc3Np bmdHZXN0dXJlcyAmJiAoZXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX1VQREFURSB8fCBldmVudC0+ dHlwZSA9PSBHREtfVE9VQ0hfRU5EKSkgeworICAgICAgICBtX2RyYWdHZXN0dXJlLnJlc2V0KCk7 CisgICAgICAgIG1fem9vbUdlc3R1cmUucmVzZXQoKTsKKyAgICAgICAgcmV0dXJuIEZBTFNFOwor ICAgIH0KKwogICAgIG1fZHJhZ0dlc3R1cmUuaGFuZGxlRXZlbnQoZXZlbnQpOwogICAgIG1fc3dp cGVHZXN0dXJlLmhhbmRsZUV2ZW50KGV2ZW50KTsKICAgICBtX3pvb21HZXN0dXJlLmhhbmRsZUV2 ZW50KGV2ZW50KTsKQEAgLTY3LDYgKzc0LDExIEBAIEdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJl OjpHZXN0dXJlKEd0a0dlc3R1cmUqIGdlc3R1cmUsIFdlYlBhZ2VQcm94eSYgcGFnZSkKICAgICBn dGtfZXZlbnRfY29udHJvbGxlcl9zZXRfcHJvcGFnYXRpb25fcGhhc2UoR1RLX0VWRU5UX0NPTlRS T0xMRVIobV9nZXN0dXJlLmdldCgpKSwgR1RLX1BIQVNFX05PTkUpOwogfQogCit2b2lkIEdlc3R1 cmVDb250cm9sbGVyOjpHZXN0dXJlOjpyZXNldCgpCit7CisgICAgZ3RrX2V2ZW50X2NvbnRyb2xs ZXJfcmVzZXQoR1RLX0VWRU5UX0NPTlRST0xMRVIobV9nZXN0dXJlLmdldCgpKSk7Cit9CisKIGJv b2wgR2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmU6OmlzQWN0aXZlKCkgY29uc3QKIHsKICAgICBy ZXR1cm4gZ3RrX2dlc3R1cmVfaXNfYWN0aXZlKG1fZ2VzdHVyZS5nZXQoKSk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaCBiL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oCmluZGV4IGU5NjAzMWZi OWUyYTMyN2FlOWM2MThkMTRmZTllNDMyNTg2Y2ViMDYuLjE3M2FmMmM3NGUxOGMwMmI2NGYzMGU1 OTIwYWQ0MTRlOTQxNTNhMzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0 ay9HZXN0dXJlQ29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9H ZXN0dXJlQ29udHJvbGxlci5oCkBAIC01Miw2ICs1Miw3IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAg ICAgY2xhc3MgR2VzdHVyZSB7CiAgICAgcHVibGljOgorICAgICAgICB2b2lkIHJlc2V0KCk7CiAg ICAgICAgIGJvb2wgaXNBY3RpdmUoKSBjb25zdDsKICAgICAgICAgdm9pZCBoYW5kbGVFdmVudChj b25zdCBHZGtFdmVudCopOwogCg== 318694 2017-08-21 16:41:32 -0700 2017-10-04 07:54:35 -0700 Patch bug-158531-20170822024131.patch text/plain 6403 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjIwOTg0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDU4MzBlYmI5MDVhZDYwOTkx NTI1Nzc2MjllNzJiZjJjYWJmZDUwOTAuLjhkYTk0ZDY5Nzk0NzIyZmQ2NTdiZTQ0OGFiNjc4NjYz MTkyNWY1NzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTctMDgtMjEgIEFkcmlhbiBQ ZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBXZWJL aXQyR1RLKyBkb2VzIG5vdCBoYW5kbGUgdG91Y2htb3ZlIGFuZCB0b3VjaGVuZCBldmVudHMgY29y cmVjdGx5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NTg1MzEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBE byBub3QgYnlwYXNzIFdlYkNvcmUgZXZlbnQgaGFuZGxpbmcgd2hlbiByZWNlaXZpbmcgdG91Y2gg ZXZlbnRzLgorCisgICAgICAgIEJhc2VkIG9uIGEgcGF0Y2ggYnkgQW5kcmUgTW9yZWlyYSBNYWdh bGhhZXMgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+LgorCisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpQYWdl Q2xpZW50SW1wbDo6ZG9uZVdpdGhUb3VjaEV2ZW50KTogTWFrZSBzdXJlIHRvdWNoZW5kIHJlYWNo ZXMgZ2VzdHVyZSBjb250cm9sbGVyIGlmIHRvdWNoYmVnaW4gZXZldCBnb3QgdG8gaXQuCisgICAg ICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwOgorICAgICAgICAo d2Via2l0V2ViVmlld0Jhc2VUb3VjaEV2ZW50KTogRG8gbm90IGludm9rZSBnZXN0dXJlIGNvbnRy b2xsZXIgZGlyZWN0bHkgYnkgYnlwYXNzaW5nIFdlYkNvcmUgZXZlbnQgaGFuZGxpbmcuCisgICAg ICAgICogVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHA6CisgICAgICAgIChXZWJL aXQ6Okdlc3R1cmVDb250cm9sbGVyOjpoYW5kbGVFdmVudCk6IFJlc2V0IGdlc3R1cmUgY29udHJv bGxlciB3aGVuIHRvdWNocGFkdXBkYXRlL2VuZCBpcyByZWNlaXZlZCB3aXRob3V0IHRvdWNoYmVn aW4uCisgICAgICAgIChXZWJLaXQ6Okdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJlOjpyZXNldCk6 IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaDoKKwog MjAxNy0wOC0yMSAgWW9zaGlha2kgSml0c3VrYXdhICA8WW9zaGlha2kuSml0c3VrYXdhQHNvbnku Y29tPgogCiAgICAgICAgIFtQQUxdIE1vdmUgc3BpL21hYyBkaXJlY3RvcnkgaW50byBQQUwKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu Y3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAK aW5kZXggMjI5M2NiMjQwMmMxNmJjZmI0MTY4ODIwMjE1MGI3NDE0NTk1NGE3MC4uNWUyNTZhYWEz ZmNhMjM5OTBiNDgwMWIzMTk4NTYyZWVhYTljZDBhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTM0MiwxOCArMzQyLDI1 IEBAIHZvaWQgUGFnZUNsaWVudEltcGw6OmJlZ2FuRXhpdEZ1bGxTY3JlZW4oY29uc3QgSW50UmVj dCYgLyogaW5pdGlhbEZyYW1lICovLCBjb25zCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKIHZv aWQgUGFnZUNsaWVudEltcGw6OmRvbmVXaXRoVG91Y2hFdmVudChjb25zdCBOYXRpdmVXZWJUb3Vj aEV2ZW50JiBldmVudCwgYm9vbCB3YXNFdmVudEhhbmRsZWQpCiB7Ci0gICAgaWYgKHdhc0V2ZW50 SGFuZGxlZCkKLSAgICAgICAgcmV0dXJuOworICAgIGNvbnN0IEdka0V2ZW50KiB0b3VjaEV2ZW50 ID0gZXZlbnQubmF0aXZlRXZlbnQoKTsKIAogI2lmIEhBVkUoR1RLX0dFU1RVUkVTKQogICAgIEdl c3R1cmVDb250cm9sbGVyJiBnZXN0dXJlQ29udHJvbGxlciA9IHdlYmtpdFdlYlZpZXdCYXNlR2Vz dHVyZUNvbnRyb2xsZXIoV0VCS0lUX1dFQl9WSUVXX0JBU0UobV92aWV3V2lkZ2V0KSk7Ci0gICAg aWYgKGdlc3R1cmVDb250cm9sbGVyLmhhbmRsZUV2ZW50KGV2ZW50Lm5hdGl2ZUV2ZW50KCkpKQot ICAgICAgICByZXR1cm47CisgICAgaWYgKCF3YXNFdmVudEhhbmRsZWQgfHwgKHRvdWNoRXZlbnQt PnR5cGUgPT0gR0RLX1RPVUNIX0VORCAmJiBnZXN0dXJlQ29udHJvbGxlci5pc1Byb2Nlc3NpbmdH ZXN0dXJlcygpKSkgeworICAgICAgICAvLyBJZ25vcmVkIGF0dGVtcHQgdG8gY2FuY2VsIGFuIEVO RCB0b3VjaCBldmVudCB3aGlsZSBhIEJFR0lOIHRvdWNoIGV2ZW50IHdhcyBwcm9jZXNzZWQKKyAg ICAgICAgLy8gYnkgdGhlIGdlc3R1cmUgY29udHJvbGxlciAod2Fzbid0IGhhbmRsZWQgYnkgV2Vi UHJvY2VzcyksIGZvciBleGFtcGxlIGJlY2F1c2UKKyAgICAgICAgLy8gc2Nyb2xsaW5nIGlzIGlu IHByb2dyZXNzIGFuZCBjYW5ub3QgYmUgaW50ZXJydXB0ZWQgLSBpZiB3ZSBhcmUgYWxyZWFkeSBw cm9jZXNzaW5nCisgICAgICAgIC8vIGdlc3R1cmVzIGlzIGJlY2F1c2UgdGhlIFdlYlByb2Nlc3Mg ZGlkbid0IGhhbmRsZSB0aGUgQkVHSU4gdG91Y2ggZXZlbnQsCisgICAgICAgIC8vIHNvIGxldHMg cGFzcyB0aGUgRU5EIHRvdWNoIGV2ZW50IHRvIHRoZSBHZXN0dXJlQ29udHJvbGxlciBldmVuIGlm IGl0IHdhcworICAgICAgICAvLyBoYW5kbGVkIGJ5IHRoZSBXZWJQcm9jZXNzLgorICAgICAgICB3 YXNFdmVudEhhbmRsZWQgPSBnZXN0dXJlQ29udHJvbGxlci5oYW5kbGVFdmVudChldmVudC5uYXRp dmVFdmVudCgpKTsKKyAgICB9CiAjZW5kaWYKIAorICAgIGlmICh3YXNFdmVudEhhbmRsZWQpCisg ICAgICAgIHJldHVybjsKKwogICAgIC8vIEVtdWxhdGUgcG9pbnRlciBldmVudHMgaWYgdW5oYW5k bGVkLgotICAgIGNvbnN0IEdka0V2ZW50KiB0b3VjaEV2ZW50ID0gZXZlbnQubmF0aXZlRXZlbnQo KTsKLQogICAgIGlmICghdG91Y2hFdmVudC0+dG91Y2guZW11bGF0aW5nX3BvaW50ZXIpCiAgICAg ICAgIHJldHVybjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdCYXNlLmNwcAppbmRleCBlNGYwNTEwYTMyOGY2MmJmZmNiZTZlMTllZTQx OGQ0ZTlhMWRkNTgzLi5kZmEwZTU0OGQ4NDNkMWJlMGYyZjkwOTc0Zjc5MmQ2YjhiNDY4OTg4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdC YXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZp ZXdCYXNlLmNwcApAQCAtOTI3LDIwICs5MjcsNiBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0V2Vi Vmlld0Jhc2VUb3VjaEV2ZW50KEd0a1dpZGdldCogd2lkZ2V0LCBHZGtFdmVudFRvdWNoKiBldgog ICAgIEdka0V2ZW50KiB0b3VjaEV2ZW50ID0gcmVpbnRlcnByZXRfY2FzdDxHZGtFdmVudCo+KGV2 ZW50KTsKICAgICB1aW50MzJfdCBzZXF1ZW5jZSA9IEdQT0lOVEVSX1RPX1VJTlQoZ2RrX2V2ZW50 X2dldF9ldmVudF9zZXF1ZW5jZSh0b3VjaEV2ZW50KSk7CiAKLSNpZiBIQVZFKEdUS19HRVNUVVJF UykKLSAgICBHZXN0dXJlQ29udHJvbGxlciYgZ2VzdHVyZUNvbnRyb2xsZXIgPSB3ZWJraXRXZWJW aWV3QmFzZUdlc3R1cmVDb250cm9sbGVyKHdlYlZpZXdCYXNlKTsKLSAgICBpZiAoZ2VzdHVyZUNv bnRyb2xsZXIuaXNQcm9jZXNzaW5nR2VzdHVyZXMoKSkgewotICAgICAgICAvLyBJZiB3ZSBhcmUg YWxyZWFkeSBwcm9jZXNzaW5nIGdlc3R1cmVzIGlzIGJlY2F1c2UgdGhlIFdlYlByb2Nlc3MgZGlk bid0IGhhbmRsZSB0aGUKLSAgICAgICAgLy8gQkVHSU4gdG91Y2ggZXZlbnQsIHNvIHBhc3Mgc3Vi c2VxdWVudCBldmVudHMgdG8gdGhlIEdlc3R1cmVDb250cm9sbGVyLgotICAgICAgICBnZXN0dXJl Q29udHJvbGxlci5oYW5kbGVFdmVudCh0b3VjaEV2ZW50KTsKLSAgICAgICAgLy8gUmVtb3ZlIHRo ZSBnZXN0dXJlIGV2ZW50IHNlcXVlbmNlIGZyb20gdGhlIGhhbmRsZWQgdG91Y2ggZXZlbnRzCi0g ICAgICAgIC8vIGxpc3QgdG8gYXZvaWQgdGhlIGdlc3VyZSBzZXF1ZW5jZSBhbmQgYSB0b3VjaCBz ZXF1ZW5jZSBvZiBzYW1lCi0gICAgICAgIC8vIElEIHRvIGNvbmZsaWN0LgotICAgICAgICBwcml2 LT50b3VjaEV2ZW50cy5yZW1vdmUoc2VxdWVuY2UpOwotICAgICAgICByZXR1cm4gVFJVRTsKLSAg ICB9Ci0jZW5kaWYKLQogICAgIHN3aXRjaCAodG91Y2hFdmVudC0+dHlwZSkgewogICAgIGNhc2Ug R0RLX1RPVUNIX0JFR0lOOiB7CiAgICAgICAgIEFTU0VSVCghcHJpdi0+dG91Y2hFdmVudHMuY29u dGFpbnMoc2VxdWVuY2UpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0 ay9HZXN0dXJlQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvR2Vz dHVyZUNvbnRyb2xsZXIuY3BwCmluZGV4IDExNGNjNWYxYzYxMmIxNzYwODY3MWJhNDA0NjVlMDQw ZjhmMGJlMDUuLmRkMWU1MDcwNmZmZTY0ZDkyODZhZDRjMGMwYzM3ZmFkOThiMzBmYjUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAK KysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvZ3RrL0dlc3R1cmVDb250cm9sbGVyLmNwcApA QCAtNDksNiArNDksMTMgQEAgR2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmVDb250cm9sbGVyKFdl YlBhZ2VQcm94eSYgcGFnZSkKIGJvb2wgR2VzdHVyZUNvbnRyb2xsZXI6OmhhbmRsZUV2ZW50KGNv bnN0IEdka0V2ZW50KiBldmVudCkKIHsKICAgICBib29sIHdhc1Byb2Nlc3NpbmdHZXN0dXJlcyA9 IGlzUHJvY2Vzc2luZ0dlc3R1cmVzKCk7CisgICAgLy8gUmVjZWl2ZWQgdG91Y2h1cGRhdGUvZW5k IHdpdGhvdXQgdG91Y2hiZWdpbiwgaWdub3JlIGV2ZW50cy4KKyAgICBpZiAoIXdhc1Byb2Nlc3Np bmdHZXN0dXJlcyAmJiAoZXZlbnQtPnR5cGUgPT0gR0RLX1RPVUNIX1VQREFURSB8fCBldmVudC0+ dHlwZSA9PSBHREtfVE9VQ0hfRU5EKSkgeworICAgICAgICBtX2RyYWdHZXN0dXJlLnJlc2V0KCk7 CisgICAgICAgIG1fem9vbUdlc3R1cmUucmVzZXQoKTsKKyAgICAgICAgcmV0dXJuIEZBTFNFOwor ICAgIH0KKwogICAgIG1fZHJhZ0dlc3R1cmUuaGFuZGxlRXZlbnQoZXZlbnQpOwogICAgIG1fc3dp cGVHZXN0dXJlLmhhbmRsZUV2ZW50KGV2ZW50KTsKICAgICBtX3pvb21HZXN0dXJlLmhhbmRsZUV2 ZW50KGV2ZW50KTsKQEAgLTY3LDYgKzc0LDExIEBAIEdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJl OjpHZXN0dXJlKEd0a0dlc3R1cmUqIGdlc3R1cmUsIFdlYlBhZ2VQcm94eSYgcGFnZSkKICAgICBn dGtfZXZlbnRfY29udHJvbGxlcl9zZXRfcHJvcGFnYXRpb25fcGhhc2UoR1RLX0VWRU5UX0NPTlRS T0xMRVIobV9nZXN0dXJlLmdldCgpKSwgR1RLX1BIQVNFX05PTkUpOwogfQogCit2b2lkIEdlc3R1 cmVDb250cm9sbGVyOjpHZXN0dXJlOjpyZXNldCgpCit7CisgICAgZ3RrX2V2ZW50X2NvbnRyb2xs ZXJfcmVzZXQoR1RLX0VWRU5UX0NPTlRST0xMRVIobV9nZXN0dXJlLmdldCgpKSk7Cit9CisKIGJv b2wgR2VzdHVyZUNvbnRyb2xsZXI6Okdlc3R1cmU6OmlzQWN0aXZlKCkgY29uc3QKIHsKICAgICBy ZXR1cm4gZ3RrX2dlc3R1cmVfaXNfYWN0aXZlKG1fZ2VzdHVyZS5nZXQoKSk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaCBiL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oCmluZGV4IGU5NjAzMWZi OWUyYTMyN2FlOWM2MThkMTRmZTllNDMyNTg2Y2ViMDYuLjE3M2FmMmM3NGUxOGMwMmI2NGYzMGU1 OTIwYWQ0MTRlOTQxNTNhMzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0 ay9HZXN0dXJlQ29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9H ZXN0dXJlQ29udHJvbGxlci5oCkBAIC01Miw2ICs1Miw3IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAg ICAgY2xhc3MgR2VzdHVyZSB7CiAgICAgcHVibGljOgorICAgICAgICB2b2lkIHJlc2V0KCk7CiAg ICAgICAgIGJvb2wgaXNBY3RpdmUoKSBjb25zdDsKICAgICAgICAgdm9pZCBoYW5kbGVFdmVudChj b25zdCBHZGtFdmVudCopOwogCg== 322671 2017-10-04 07:55:13 -0700 2017-10-04 10:33:30 -0700 Patch bug-158531-20171004165504.patch text/plain 5633 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjIyODIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDc4ZmJjMDVmNzgzMWU3NWVh OGNhMTJlYzQwMmJjMWIzNGQ1YmE5YWQuLjNmNDkxY2QwZDAyYTMzMDFmNDdkZTUyY2JhNTJmMDcw ZDZjZjA0MDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMTctMDgtMjEgIEFkcmlhbiBQ ZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBXZWJL aXQyR1RLKyBkb2VzIG5vdCBoYW5kbGUgdG91Y2htb3ZlIGFuZCB0b3VjaGVuZCBldmVudHMgY29y cmVjdGx5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NTg1MzEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBE byBub3QgYnlwYXNzIFdlYkNvcmUgZXZlbnQgaGFuZGxpbmcgd2hlbiByZWNlaXZpbmcgdG91Y2gg ZXZlbnRzLgorCisgICAgICAgIEJhc2VkIG9uIGEgcGF0Y2ggYnkgQW5kcmUgTW9yZWlyYSBNYWdh bGhhZXMgPGFuZHJlLm1hZ2FsaGFlc0Bjb2xsYWJvcmEuY28udWs+LgorICAgICAgICBUaGFua3Mg dG8gQ2FybG9zIEdhcm5hY2hvIDxjYXJsb3NnQGdub21lLm9yZz4gZm9yIGhlbHBpbmcgb3V0IHJl dmlld2luZyB0aGUgY29kZS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGll bnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6UGFnZUNsaWVudEltcGw6OmRvbmVXaXRoVG91 Y2hFdmVudCk6IE1ha2Ugc3VyZSB0b3VjaGVuZCByZWFjaGVzIGdlc3R1cmUgY29udHJvbGxlciBp ZiB0b3VjaGJlZ2luIGV2ZXQgZ290IHRvIGl0LgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdCYXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdCYXNlVG91Y2hF dmVudCk6IERvIG5vdCBpbnZva2UgZ2VzdHVyZSBjb250cm9sbGVyIGRpcmVjdGx5IGJ5IGJ5cGFz c2luZyBXZWJDb3JlIGV2ZW50IGhhbmRsaW5nLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvR2Vz dHVyZUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViS2l0OjpHZXN0dXJlQ29udHJvbGxlcjo6 cmVzZXQpOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6R2VzdHVyZUNvbnRyb2xsZXI6OmhhbmRs ZUV2ZW50KTogUmVzZXQgZ2VzdHVyZSBjb250cm9sbGVyIHdoZW4gdG91Y2hwYWR1cGRhdGUvZW5k IGlzIHJlY2VpdmVkIHdpdGhvdXQgdG91Y2hiZWdpbi4KKyAgICAgICAgKFdlYktpdDo6R2VzdHVy ZUNvbnRyb2xsZXI6Okdlc3R1cmU6OnJlc2V0KTogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNz L2d0ay9HZXN0dXJlQ29udHJvbGxlci5oOgorCiAyMDE3LTEwLTAzICBDaHJpcyBEdW1leiAgPGNk dW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgU2hhcmVkU3RyaW5nSGFzaFN0b3JlIHNob3VsZCBz dXBwb3J0IHJlbW92aW5nIGhhc2hlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcAppbmRleCAyMjkzY2IyNDAyYzE2YmNmYjQxNjg4MjAy MTUwYjc0MTQ1OTU0YTcwLi4xODg2ZDgxYzk1NGI3MjkwYmVmZGM3YmZlMWEyZmY1NmIzZjlkZDQz IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJ bXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJ bXBsLmNwcApAQCAtMzQyLDE4ICszNDIsMjEgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbDo6YmVnYW5F eGl0RnVsbFNjcmVlbihjb25zdCBJbnRSZWN0JiAvKiBpbml0aWFsRnJhbWUgKi8sIGNvbnMKICNp ZiBFTkFCTEUoVE9VQ0hfRVZFTlRTKQogdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZG9uZVdpdGhUb3Vj aEV2ZW50KGNvbnN0IE5hdGl2ZVdlYlRvdWNoRXZlbnQmIGV2ZW50LCBib29sIHdhc0V2ZW50SGFu ZGxlZCkKIHsKLSAgICBpZiAod2FzRXZlbnRIYW5kbGVkKQotICAgICAgICByZXR1cm47CisgICAg Y29uc3QgR2RrRXZlbnQqIHRvdWNoRXZlbnQgPSBldmVudC5uYXRpdmVFdmVudCgpOwogCiAjaWYg SEFWRShHVEtfR0VTVFVSRVMpCiAgICAgR2VzdHVyZUNvbnRyb2xsZXImIGdlc3R1cmVDb250cm9s bGVyID0gd2Via2l0V2ViVmlld0Jhc2VHZXN0dXJlQ29udHJvbGxlcihXRUJLSVRfV0VCX1ZJRVdf QkFTRShtX3ZpZXdXaWRnZXQpKTsKLSAgICBpZiAoZ2VzdHVyZUNvbnRyb2xsZXIuaGFuZGxlRXZl bnQoZXZlbnQubmF0aXZlRXZlbnQoKSkpCisgICAgaWYgKHdhc0V2ZW50SGFuZGxlZCkgeworICAg ICAgICBnZXN0dXJlQ29udHJvbGxlci5yZXNldCgpOwogICAgICAgICByZXR1cm47CisgICAgfQor ICAgIHdhc0V2ZW50SGFuZGxlZCA9IGdlc3R1cmVDb250cm9sbGVyLmhhbmRsZUV2ZW50KGV2ZW50 Lm5hdGl2ZUV2ZW50KCkpOwogI2VuZGlmCiAKKyAgICBpZiAod2FzRXZlbnRIYW5kbGVkKQorICAg ICAgICByZXR1cm47CisKICAgICAvLyBFbXVsYXRlIHBvaW50ZXIgZXZlbnRzIGlmIHVuaGFuZGxl ZC4KLSAgICBjb25zdCBHZGtFdmVudCogdG91Y2hFdmVudCA9IGV2ZW50Lm5hdGl2ZUV2ZW50KCk7 Ci0KICAgICBpZiAoIXRvdWNoRXZlbnQtPnRvdWNoLmVtdWxhdGluZ19wb2ludGVyKQogICAgICAg ICByZXR1cm47CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViVmlld0Jhc2UuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJWaWV3QmFzZS5jcHAKaW5kZXggZTRmMDUxMGEzMjhmNjJiZmZjYmU2ZTE5ZWU0MThk NGU5YTFkZDU4My4uZGZhMGU1NDhkODQzZDFiZTBmMmY5MDk3NGY3OTJkNmI4YjQ2ODk4OCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFz ZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3 QmFzZS5jcHAKQEAgLTkyNywyMCArOTI3LDYgQEAgc3RhdGljIGdib29sZWFuIHdlYmtpdFdlYlZp ZXdCYXNlVG91Y2hFdmVudChHdGtXaWRnZXQqIHdpZGdldCwgR2RrRXZlbnRUb3VjaCogZXYKICAg ICBHZGtFdmVudCogdG91Y2hFdmVudCA9IHJlaW50ZXJwcmV0X2Nhc3Q8R2RrRXZlbnQqPihldmVu dCk7CiAgICAgdWludDMyX3Qgc2VxdWVuY2UgPSBHUE9JTlRFUl9UT19VSU5UKGdka19ldmVudF9n ZXRfZXZlbnRfc2VxdWVuY2UodG91Y2hFdmVudCkpOwogCi0jaWYgSEFWRShHVEtfR0VTVFVSRVMp Ci0gICAgR2VzdHVyZUNvbnRyb2xsZXImIGdlc3R1cmVDb250cm9sbGVyID0gd2Via2l0V2ViVmll d0Jhc2VHZXN0dXJlQ29udHJvbGxlcih3ZWJWaWV3QmFzZSk7Ci0gICAgaWYgKGdlc3R1cmVDb250 cm9sbGVyLmlzUHJvY2Vzc2luZ0dlc3R1cmVzKCkpIHsKLSAgICAgICAgLy8gSWYgd2UgYXJlIGFs cmVhZHkgcHJvY2Vzc2luZyBnZXN0dXJlcyBpcyBiZWNhdXNlIHRoZSBXZWJQcm9jZXNzIGRpZG4n dCBoYW5kbGUgdGhlCi0gICAgICAgIC8vIEJFR0lOIHRvdWNoIGV2ZW50LCBzbyBwYXNzIHN1YnNl cXVlbnQgZXZlbnRzIHRvIHRoZSBHZXN0dXJlQ29udHJvbGxlci4KLSAgICAgICAgZ2VzdHVyZUNv bnRyb2xsZXIuaGFuZGxlRXZlbnQodG91Y2hFdmVudCk7Ci0gICAgICAgIC8vIFJlbW92ZSB0aGUg Z2VzdHVyZSBldmVudCBzZXF1ZW5jZSBmcm9tIHRoZSBoYW5kbGVkIHRvdWNoIGV2ZW50cwotICAg ICAgICAvLyBsaXN0IHRvIGF2b2lkIHRoZSBnZXN1cmUgc2VxdWVuY2UgYW5kIGEgdG91Y2ggc2Vx dWVuY2Ugb2Ygc2FtZQotICAgICAgICAvLyBJRCB0byBjb25mbGljdC4KLSAgICAgICAgcHJpdi0+ dG91Y2hFdmVudHMucmVtb3ZlKHNlcXVlbmNlKTsKLSAgICAgICAgcmV0dXJuIFRSVUU7Ci0gICAg fQotI2VuZGlmCi0KICAgICBzd2l0Y2ggKHRvdWNoRXZlbnQtPnR5cGUpIHsKICAgICBjYXNlIEdE S19UT1VDSF9CRUdJTjogewogICAgICAgICBBU1NFUlQoIXByaXYtPnRvdWNoRXZlbnRzLmNvbnRh aW5zKHNlcXVlbmNlKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsv R2VzdHVyZUNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvZ3RrL0dlc3R1 cmVDb250cm9sbGVyLmNwcAppbmRleCAxMTRjYzVmMWM2MTJiMTc2MDg2NzFiYTQwNDY1ZTA0MGY4 ZjBiZTA1Li5kNzgzYjJmYjIyYzQ2N2JkNThiZmQ0Njk0YmVlNjE2YjQwZDIxOTRmIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5jcHAKQEAg LTY3LDYgKzY3LDExIEBAIEdlc3R1cmVDb250cm9sbGVyOjpHZXN0dXJlOjpHZXN0dXJlKEd0a0dl c3R1cmUqIGdlc3R1cmUsIFdlYlBhZ2VQcm94eSYgcGFnZSkKICAgICBndGtfZXZlbnRfY29udHJv bGxlcl9zZXRfcHJvcGFnYXRpb25fcGhhc2UoR1RLX0VWRU5UX0NPTlRST0xMRVIobV9nZXN0dXJl LmdldCgpKSwgR1RLX1BIQVNFX05PTkUpOwogfQogCit2b2lkIEdlc3R1cmVDb250cm9sbGVyOjpH ZXN0dXJlOjpyZXNldCgpCit7CisgICAgZ3RrX2V2ZW50X2NvbnRyb2xsZXJfcmVzZXQoR1RLX0VW RU5UX0NPTlRST0xMRVIobV9nZXN0dXJlLmdldCgpKSk7Cit9CisKIGJvb2wgR2VzdHVyZUNvbnRy b2xsZXI6Okdlc3R1cmU6OmlzQWN0aXZlKCkgY29uc3QKIHsKICAgICByZXR1cm4gZ3RrX2dlc3R1 cmVfaXNfYWN0aXZlKG1fZ2VzdHVyZS5nZXQoKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9ndGsvR2VzdHVyZUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxlci5oCmluZGV4IGU5NjAzMWZiOWUyYTMyN2FlOWM2MThk MTRmZTllNDMyNTg2Y2ViMDYuLjVhYzQzMTA4OWMzM2YxZDg4NGMxMGNlMWE4OTVkZDBkM2FiN2Q0 ZDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJv bGxlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9HZXN0dXJlQ29udHJvbGxl ci5oCkBAIC00OSw5ICs0OSwxNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBpc1Byb2Nlc3NpbmdHZXN0 dXJlcygpIGNvbnN0OwogICAgIGJvb2wgaGFuZGxlRXZlbnQoY29uc3QgR2RrRXZlbnQqKTsKIAor ICAgIHZvaWQgcmVzZXQoKQorICAgIHsKKyAgICAgICAgbV9kcmFnR2VzdHVyZS5yZXNldCgpOwor ICAgICAgICBtX3N3aXBlR2VzdHVyZS5yZXNldCgpOworICAgICAgICBtX3pvb21HZXN0dXJlLnJl c2V0KCk7CisgICAgfQorCiBwcml2YXRlOgogICAgIGNsYXNzIEdlc3R1cmUgewogICAgIHB1Ymxp YzoKKyAgICAgICAgdm9pZCByZXNldCgpOwogICAgICAgICBib29sIGlzQWN0aXZlKCkgY29uc3Q7 CiAgICAgICAgIHZvaWQgaGFuZGxlRXZlbnQoY29uc3QgR2RrRXZlbnQqKTsKIAo=